java中的锁池和等待池

在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.

 

 

在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. 
[java] view plain copy


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();  

    }  

}  
 

 

https://blog.csdn.net/emailed/article/details/4689220