Synchronized還可作用於一個類，用法如下：

<span style="font-size:18px;">public class ClassName {
  public void method() {
     synchronized(ClassName.class) {
        // TODO
     }
   }
}</span>

具體的例項如下：

<span style="font-size:18px;">public class SyncThread implementsRunnable{
  private static int count;
 
  public SyncThread() {
     count = 0;
   }
 
   public static void method() {
     synchronized(SyncThread.class) {
        for (int i = 0; i < 5; i ++) {
           try {
              System.out.println(Thread.currentThread().getName() + ":" +(count++));
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
        }
     }
   }
 
  public void run() {
      method();
}
 
  public int getCount() {
     return count;
   }
 
         publicstatic void main(String[] args){
                   SyncThreadsyncThread1 = new SyncThread();
                   SyncThreadsyncThread2 = new SyncThread();
                   SyncThreadsyncThread3 = new SyncThread();
                   Threadthread1 = new Thread(syncThread1, "SyncThread1");
                   Threadthread2 = new Thread(syncThread2, "SyncThread2");
                   Threadthread3 = new Thread(syncThread3, "SyncThread3");
                   thread1.start();
                   thread2.start();
                   thread3.start();
         }
}</span>
 

執行結果：

        程式碼的差異不大，執行的結果是一樣的，當synchronized修飾一個類的時候，是給這個類加鎖，類的所有例項化出來的物件用的是同一把鎖。

        再做一個實驗，在以上的程式碼中新增一個方法method2，但是不使用synchronize進行修飾，程式碼如下：

<span style="font-size:18px;">public class SyncThread implementsRunnable{
  private static int count;
 
  public SyncThread() {
     count = 0;
   }
 
   public static void method() {
     synchronized(SyncThread.class) {
        for (int i = 0; i < 5; i ++) {
           try {
              System.out.println(Thread.currentThread().getName() + ":" +(count++));
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
            }
        }
     }
   }
 public static void method2() {
   for (int i = 100; i < 105; i ++) {
        try {
            System.out.println(Thread.currentThread().getName() + ":" +(count++)+ "——" + "method2");
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
     } 
   }
 
  public void run() {
      method2();
    }
  public int getCount() {
     return count;
   }
 
         publicstatic void main(String[] args){
                   SyncThreadsyncThread1 = new SyncThread();
                   SyncThreadsyncThread2 = new SyncThread();
                   SyncThreadsyncThread3 = new SyncThread();
                   Threadthread1 = new Thread(syncThread1, "SyncThread1");
                   Threadthread2 = new Thread(syncThread2, "SyncThread2");
                   Threadthread3 = new Thread(syncThread3, "SyncThread3");
                   thread1.start();
                   thread2.start();
                   thread3.start();
         }
}</span>
 

執行結果如下：

        雖然這裡的synchronize修飾的是一個類，但並不是對類的所有方法都統一的修飾了，只是修飾了某個方法，使得這個類的所有物件在使用這個被修飾的方法時保持同步。

總結：

         一、 無論synchronized關鍵字加在方法上還是物件上，如果被作用的是非靜態的，則它取得的鎖是物件；如果synchronized作用的是一個靜態方法或一個類，則它取得的鎖是對類，該類所有的物件同一把鎖。 

         二、 誰拿到這個鎖誰就可以執行它鎖控制的那段程式碼，其他的必須等待。