Java synchronized关键字学习二

接上一篇博文： 
synchronized(非this对象x) 格式的写法是将x对象本身作为“对象监视器”，这样就可以得出如下3个结论： 
1)当多个线程同时执行synchronized(x){}同步代码块时呈同步效果； 
2)当其他线程执行x对象方法里面的synchronized同步方法时呈同步效果； 
3)当其他线程执行x对象方法里面的synchronized(this)代码块时也呈现同步效果； 
上面3个结论，其实仔细阅读上篇博客不难理解，通俗一点的说就是，对象监视器的问题，同一个对象监视器的话，必然同步；若是存在不同对象监视器，但是之间是嵌套的，仍然是同步的。 
若其他线程调用不加synchronized关键字的方法时，还是异步调用。

静态同步synchronized方法与synchronized(class)代码块

修改上一篇博文中synchronizedLock包中的ObjectService类，如下

 
 

  
  

   
   public class ObjectService {
  
  
  
  

   
       synchronized public static void serviceMethodA() {
  
  
  
  

   
           try {
  
  
  
  

   
               System.out.println("A begin time="+ System.currentTimeMillis());
  
  
  
  

   
               Thread.sleep(2000);
  
  
  
  

   
               System.out.println("A end  end="+ System.currentTimeMillis());
  
  
  
  

   
           }catch (InterruptedException e) {
  
  
  
  

   
               e.printStackTrace();
  
  
  
  

   
           }
  
  
  
  

   
       }
  
  
  
  

   
       synchronized public static void serviceMethodB(){
  
  
  
  

   
           System.out.println("B begin time="+System.currentTimeMillis());
  
  
  
  

   
           System.out.println("B end  end="+System.currentTimeMillis());
  
  
  
  

   
       }
  
  
  
  

   
   }
  
  
 
 

将关键字synchronized应用在static静态方法上，若是多个线程执行，还是同步的，和将关键字synchronized加到非static方法上使用的效果是一样的。只是本质稍微有点不同，synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到非static静态方法上则是给对象加锁。其实还是使用的同一个对象监视器，因而是同步的。

为了验证是不是同一把锁，继续采用上边的代码，做一些修改进行测试验证，首先在ObjectService 类中再添加一个synchronized方法serviceMethodC：

 
 

  
  

   
   synchronized public void serviceMethodC(){
  
  
  
  

   
           System.out.println("C begin time="+System.currentTimeMillis());
  
  
  
  

   
           System.out.println("C end  end="+System.currentTimeMillis());
  
  
  
  

   
   }
  
  
 
 

添加线程文件ThreadC.java:

 
 

  
  

   
   package synchronizedLock;
  
  
  
  

   
    
  
  
  
  

   
   public class ThreadC extends Thread{
  
  
  
  

   
       private ObjectService service;
  
  
  
  

   
       public ThreadC(ObjectService service) {
  
  
  
  

   
           super();
  
  
  
  

   
           this.service = service;
  
  
  
  

   
       }
  
  
  
  

   
       @Override
  
  
  
  

   
       public void run() {
  
  
  
  

   
           super.run();
  
  
  
  

   
           service.serviceMethodC();
  
  
  
  

   
       }
  
  
  
  

   
   }
  
  
 
 

修改MainTest.java文件，在main方法末尾添加如下三行：

 
 

  
  

   
       ThreadC c = new ThreadC(service);
  
  
  
  

   
       c.setName("c");
  
  
  
  

   
       c.start();
  
  
 
 

运行代码测试结果如下：

 
 

  
  

   
   A begin time=1488855826118
  
  
  
  

   
   C begin time=1488855826121
  
  
  
  

   
   C end  end=1488855826121
  
  
  
  

   
   A end  end=1488855828120
  
  
  
  

   
   B begin time=1488855828121
  
  
  
  

   
   B end  end=1488855828121
  
  
 
 

可以发现A、B是同步的，但C是异步的，因而就可以确定synchronized加到static方法（Class锁）和加到非static方法（对象锁）上是不同的锁。 
对于Class来说，一个类可以创建多个对象，那么这个Class锁和该类的所有实例对象又是什么关系呢？其实不难理解，可以想一想当前的“对象监视器”有几个，显而易见，虽然创建了多个实例对象，但是对象监视器也就是锁只有一把Class锁，因而是对所有实例对象起作用的，也就是所有实例对象之间是同步的。

同步synchronized(class)代码块作用和synchronized static方法作用一样，只是写法稍有不同：

 
 

  
  

   
   synchronized(ObjectService .class) {...}   //ObjectService为类名
  
  
 
 

总之，对于synchronized关键字使用，最需要注意的就是对象监视器，多个线程获取的是不同的监视器，就是异步的；否则就是同步的。