学习和理解JAVA线程同步--生产者与消费者例子

学习和理解JAVA线程同步--生产者与消费者例子

JAVA线程同步通常需要使用sychronized对临界资源进行加锁，所谓的临界资源就是指这些线程共同使用的资源。

sychronized通常是放在方法名前，这是表示这个方法是同步的，实际上是对this加锁。

或者放在一个对象前，对某个共同使用的对象加锁。

生产者和消费者的例子是非常经典的，这里需要定义一个池子，用于往里放入产品。定义生产者不断生产产品，当池子不满的情况下可以继续放，满了则等待。

消费者一直从池子取，池子空则等待。

我们使用实现runnable来实现生产者和消费者。

写一个同步栈作为池子，对push和pop方法进行同步。
代码如下：

 class SycnStack{
     private Integer index=0;
     private char[] data;

     public SycnStack(int num){
         data = new char[num];
     }

     public void push(char c){
         synchronized (this) {//对index加锁为何不行？？？必须this
             while(index==data.length-1)
             {
                 System.out.println("池子已经满，不能放入了！"+Thread.currentThread().toString());
                 try {
                     this.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             this.notify();//获取锁
                 data[index]=c;
                 System.out.println("放入"+c+" "+Thread.currentThread().toString());
                 index++;
         }
     }
     public Character pop(){
         synchronized (this) {
             while(index==0){
                 System.out.println("池子已经空了，取不了了！"+Thread.currentThread().toString());
                 try {
                     this.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             this.notify();
                 index--;
                 char c = data[index];
                 System.out.println("取出"+c+" "+Thread.currentThread().toString());
                 return c;
         }
     }

然后写生产者和消费者，其run方法就是不断的生产产品放入池子或取出产品：

 class Producer implements Runnable{
     private SycnStack stack;
     public Producer(SycnStack stack){
         this.stack = stack;
     }
     @Override
     public void run() {
         int i=10;
         while(i-->0){
             stack.push( (char)(26*Math.random()+'A'));
             Thread.yield();
         }
     }
 }
 class Consumer implements Runnable{
     private SycnStack stack;
     public Consumer(SycnStack stack){
         this.stack = stack;
     }
     @Override
     public void run() {
         int i=10;
         while(i-->0){
             stack.pop();
             Thread.yield();
         }
     }
 }

main方法如下，创建一个栈用于放产品，然后创建生产者和消费者都用这个产品栈，并启动：

 public class ProductorConsumer {

     public static void main(String[] args){

         SycnStack s = new SycnStack(5);
         new Thread(new Producer(s)).start();
         new Thread(new Consumer(s)).start();
     }

 }

结果如下：

 放入G Thread[Thread-0,5,main]
 放入L Thread[Thread-0,5,main]
 放入D Thread[Thread-0,5,main]
 放入K Thread[Thread-0,5,main]
 池子已经满，不能放入了！Thread[Thread-0,5,main]
 取出K Thread[Thread-1,5,main]
 放入P Thread[Thread-0,5,main]
 池子已经满，不能放入了！Thread[Thread-0,5,main]
 取出P Thread[Thread-1,5,main]
 放入E Thread[Thread-0,5,main]
 池子已经满，不能放入了！Thread[Thread-0,5,main]
 取出E Thread[Thread-1,5,main]
 放入M Thread[Thread-0,5,main]
 池子已经满，不能放入了！Thread[Thread-0,5,main]
 取出M Thread[Thread-1,5,main]
 放入P Thread[Thread-0,5,main]
 池子已经满，不能放入了！Thread[Thread-0,5,main]
 取出P Thread[Thread-1,5,main]
 放入Q Thread[Thread-0,5,main]
 池子已经满，不能放入了！Thread[Thread-0,5,main]
 取出Q Thread[Thread-1,5,main]
 放入L Thread[Thread-0,5,main]
 取出L Thread[Thread-1,5,main]
 取出D Thread[Thread-1,5,main]
 取出L Thread[Thread-1,5,main]
 取出G Thread[Thread-1,5,main]

再看同步栈的代码第十行，是对this加锁，指的就是对当前这个栈加锁。

之前我测试使用对index加锁，发现是会报错的，我想可能是因为临界资源不仅是index,还有data,如果只对index加锁，当一个线程在用栈的时候，另一个线程仍然能够使用这个栈，就会造成index的混乱之后就报错了。

如果谁有更详细的解释也可以告诉我。