线程间不同synchronized方法的调用

    以前在学习java sychronized方法在县城之间的同步时，一直把注意力集中在同一个synchronized方法的同步，也就是说，以前自己只知道当一个对象获得了同步锁，并进入一个synchronized方法（比如a()）中时，另一个线程在同一个对象上不能再进入到a()方法中。今天在看wait方法时突然想到，另一个线程在同一个对象上是否可以调用这个对象上的其他synchronized方法呢？下面的代码回答了我的问题：

  
    

   
     import
   
      java.util.concurrent.ExecutorService;

   
     import
   
      java.util.concurrent.Executors;

   
     import
   
      java.util.concurrent.TimeUnit;


   
     /**
   
     
 * 测试当一个线程获取同步锁进入同步控制方法后，另一个线程是否可以调用同一个
 * 对象的另外一个同步控制方法
 * 
 * 结果证明，在一个线程获得某对象的锁，并进入该对象的一个同步方法后，其他线程
 * 是无法再调用该对象的任何同步访法的，直到那个线程释放锁
   
     
 *
 
   
     */
   
     


   
     class
   
      TestSynchronized {
 
   
     public
   
      
   
     synchronized
   
      
   
     void
   
      f() {
 
   
     try
   
      {
 System.out.println(
   
     "
   
     In function f()
   
     "
   
     );
 System.out.println(
   
     "
   
     In function f(), sleeping
   
     "
   
     );
 TimeUnit.SECONDS.sleep(
   
     2
   
     );
 }
   
     catch
   
      (InterruptedException e) {
 System.out.println(
   
     "
   
     Exiting via f() exception
   
     "
   
     );
 }
 }
 
 
   
     public
   
      
   
     synchronized
   
      
   
     void
   
      g() { 
   
     
 System.out.println(
   
     "
   
     In function g()
   
     "
   
     );
 System.out.println(
   
     "
   
     In function g(), sleeping
   
     "
   
     ); 
   
     
 }
 
 
   
     public
   
      
   
     void
   
      k() {
 System.out.println(
   
     "
   
     In function k
   
     "
   
     );
 }
}


   
     class
   
      Run1 
   
     implements
   
      Runnable {
 
   
     private
   
      TestSynchronized test;
 
   
     public
   
      Run1(TestSynchronized test) {
 
   
     this
   
     .test 
   
     =
   
      test;
 }
 
 @Override
 
   
     public
   
      
   
     void
   
      run() {
 test.k();
 test.f();
 }
}


   
     class
   
      Run2 
   
     implements
   
      Runnable {
 
   
     private
   
      TestSynchronized test;
 
   
     public
   
      Run2(TestSynchronized test) {
 
   
     this
   
     .test 
   
     =
   
      test;
 }
 
 @Override
 
   
     public
   
      
   
     void
   
      run() {
 test.k();
 test.g();
 }
}


   
     public
   
      
   
     class
   
      ObjectSynchronized {
 
 
   
     public
   
      
   
     static
   
      
   
     void
   
      main(String[] args) 
   
     throws
   
      Exception{
 TestSynchronized test 
   
     =
   
      
   
     new
   
      TestSynchronized();
 Run1 run1 
   
     =
   
      
   
     new
   
      Run1(test);
 Run2 run2 
   
     =
   
      
   
     new
   
      Run2(test);
 ExecutorService exec 
   
     =
   
      Executors.newCachedThreadPool();
 
 exec.execute(run1);
 exec.execute(run2);
 
 exec.shutdown();
 }

}
  
    

运行这个程序的结果如下：

  
    

   
     In function k
In function f()
In function k
In function f(), sleeping
In function g()
In function g(), sleeping
  
    

    这说明，当一个线程A的某个对象获取锁进入一个同步方法之后，另一个线程B的同一个对象就不能再调用这个对象上的任何synchronized方法，直到线程A的那个对象释放锁。

    这也就是为什么wait()在调用时要释放对象已获取的锁的原因：如果线程A因为等待某个条件而调用wait()，如果它不释放已经获得的同步锁，那么其他线程可能就无法改变这个对象当中的某些条件（因为无法再进入这个对象的同步方法中），导致死锁的发生。