Java常用面试题15 synchronized方法的妙用 锁池和等待池的区别

问:

当一个线程进入一个对象的synchronized方法A之后，其它线程是否可进入此对象的synchronized方法B？ 

答：

不能。其它线程只能访问该对象的非同步方法，同步方法则不能进入。因为非静态方法上的synchronized修饰符要求执行方法时要获得对象的锁，如果已经进入A方法说明对象锁已经被取走，那么试图进入B方法的线程就只能在等锁池（注意不是等待池哦）中等待对象的锁。

拓展：

在Java中，每个对象都有两个池，锁(monitor)池和等待池

wait() ,notifyAll(),notify() 三个方法都是Object类中的方法.

 

锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。

 

等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.

 

下面通过一个例子来说明:

要求写两个线程，一个线程将某个对象的某个成员变量的值加1，而另外一个线程将这个成员变量的值减1.使得该变量的值始终处于[0,2].初始值为0.

 package com.tju;
 class Target
 {
     private int count;

     public synchronized void increase()
     {
         if(count == 2)
         {
             try
             {
                 wait();
             }
             catch (InterruptedException e)
             {
                 e.printStackTrace();
             }
         }
         count++;
         System.out.println(Thread.currentThread().getName() + ":" + count);
         notify();
     }

     public synchronized void decrease()
     {
         if(count == 0)
         {
             try
             {
                 //等待，由于Decrease线程调用的该方法,
                 //所以Decrease线程进入对象t(main函数中实例化的)的等待池，并且释放对象t的锁
                 wait();//Object类的方法
             }
             catch (InterruptedException e)
             {
                 e.printStackTrace();
             }
         }
         count--;
         System.out.println(Thread.currentThread().getName() + ":" + count);

         //唤醒线程Increase，Increase线程从等待池到锁池
         notify();
     }
 }
 class Increase extends Thread
 {
     private Target t;

     public Increase(Target t)
     {
         this.t = t;
     }
     @Override
     public void run()
     {
         for(int i = 0 ;i < 30; i++)
         {
             try
             {
                 Thread.sleep((long)(Math.random()*500));
             }
             catch (InterruptedException e)
             {
                 e.printStackTrace();
             }

             t.increase();
         }

     }

 }
 class Decrease extends Thread
 {

     private Target t;
     public Decrease(Target t)
     {
         this.t = t;
     }

     @Override
     public void run()
     {
         for(int i = 0 ; i < 30 ; i++)
         {
             try
             {
                 //随机睡眠0~500毫秒
                 //sleep方法的调用，不会释放对象t的锁
                 Thread.sleep((long)(Math.random()*500));
             }
             catch (InterruptedException e)
             {
                 e.printStackTrace();
             }

             t.decrease();

         }

     }

 }

 public class Test
 {
     public static void main(String[] args)
     {
         Target t = new Target();

         Thread t1 = new Increase(t);
         t1.setName("Increase");
         Thread t2 = new Decrease(t);
         t2.setName("Decrease");

         t1.start();
         t2.start();
     }
 }

 

转载自：http://blog.csdn.net/emailed/article/details/4689220