生产者与消费者解析

生产者与消费者解析

-Object类中有五个关于线程的方法：三个重载的wait()方法和notify()、notifyAll()
问题1：为什么这些方法不定义在Thread类里面作为静态方法使用？而是在Object类里面？

这个问题先放下，先看线程状态图:

new出一个线程后，处于Runnable状态，获得CPU控制权后执行，接着处于Running状态，如果没有控制，正常执行完毕会自动消亡即Dead。
处于Running状态的线程，第一：调用sleep或者join方法或者阻塞IO会进入阻塞状态，一旦释放会自动进入Runnable状态。第二：调用wait方法会使线程处于等待池(是个对象池)，一旦调用notify()或者interupt()方法线程会进入锁池(是个对象池)，然后就会进入Runnable状态，等待CPU控制权。第三：运行中的线程进入synchronized方法或者synchronized代码段，会进入锁池，并且只有在synchronized里面才能调用wait()方法。

 1 public  Class MyStack
 2 {
 3 private int[] a;
 4 private int MAX_SIZE;
 5 private int count;
 6
 7 public MyStack(){}
 8 public MyStack(int size)
 9{
10   MAX_SIZE=size;
11   a = new int[MAX_SIZE];
12} 
13
14  public synchronized void push()
15{
16    while(count==MAX_SIZE)
17{
18    try{
19    this.wait();
20    }catch(InterruptedException e)
21{
22}   
23}
24    a[count++]=count;
25    System.out.println(Thread.currentThread().getName():"当前线程增加一个数据后:"+count);
26     this.notifyAll();
27}
28public synchronized int pop()
29{
30   while(count==0)
31{   
32try{
33    this.wait();
34   }catch(InterruptedException e)
35{}
36}  
37   this.notifyAll();
38   System.out.println(Thread.currentThread().getName():"当前线程减少一个数据后:"+(count-1));
39   return a[--count];
40}
41}

 

 1 public  Class Producer  extends  Thread
 2 {
 3  private MyStack stack;
 4  public Producer(MyStack stack)
 5{
 6  this.stack= stack;
 7}
 8  @Override
 9  public void run()
10{
11  while(true)
12{
13   stack.push();
         try{
          Thread.sleep(200)
         }catch(Exception e)
        {}
14}
15}
16}

 

public  Class Consumer  extends  Thread
{
  private MyStack stack;
  public Consumer(MyStack stack)
{
   this.stack=stack;
}
  @Override
  public void run()
{
  while(true)
{
   stack.pop();
         try{
          Thread.sleep(200)
}catch(Exception e)
        {}

}

}

}

当调用push方法的时候，当前线程锁定this对象，当栈满了，开始调用wait()方法，使生产者线程处于等待池。当消费者线程通知生产者线程继续生产的时候，wait()方法终结，如果使用if条件，并且处于多线程状态（有若干个生产者线程），那么这个时候有可能另外一个处于锁池状态的线程开始执行，那么该线程会生产导致栈满，而这个时候刚执行完wait()方法的线程也开始生产，那么会导致溢出。所以采用while循环，继续判断栈是否满，如果不满，那么执行生产，这个时候绝对不会出现任何问题，因为synchronized该线程获得锁，其余线程无法进入，必定安全。

释放对象的锁：
1、执行完同步代码块，就会释放锁
2、执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进入对象的等待池。
3、执行同步代码块的过程中，遇到异常而导致线程终止，锁也会释放

不会释放锁：
1、执行了Thread.sleep()方法，当前线程放弃CPU，开始睡眠，但不会释放锁。
2、执行同步代码块的过程中，执行了Thread.yield()方法，当前线程放弃CPU但不会释放锁。