java中的synchronize（修饰类）

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作用的是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 

         二、 谁拿到这个锁谁就可以运行它锁控制的那段代码，其他的必须等待。