Java学习之线程通信（多线程（synchronized））--生产者消费者

分析线程经典案例生产者消费者

 /**
 共享数据
 */
 class Resource
 {
     private String name;
     private int count=1;
     private boolean flag=false;

     public synchronized void set(String name)
     {
         if(flag)
             try{this.wait();}catch(InterruptedException e){}
         this.name=name+count;
         count++;
         System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
         flag = true;
         notify();
     }

     public synchronized void out()
     {
         if(!flag)
             try{this.wait();}catch(InterruptedException e){}
         System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
         flag = false;
         notify();
     }
 }

 //定义线程任务（生产者线程）
 class Producer implements Runnable
 {
     private Resource r;

     Producer(Resource r)
     {
         this.r=r;
     }
     public void run()
     {
         while(true)
         {
             r.set("商品");
         }
     }
 }
 //定义线程任务（消费者线程）
 class Consumer implements Runnable
 {
     private Resource r;

     Consumer(Resource r)
     {
         this.r=r;
     }

     public void run()
     {
         while(true)
         {
             r.out();
         }
     }
 }

 class ProducerConsumerDemo
 {
     public static void main(String[] args)
     {
         //实例化共享资源
         Resource r = new Resource();
         //实例化线程任务，指定共享资源
         Producer p=new Producer(r);
         Consumer c=new Consumer(r);
         //实例化线程，指定线程任务
         Thread t0=new Thread(p);
         Thread t1=new Thread(p);
         Thread t2=new Thread(c);
         Thread t3=new Thread(c);
         //开启线程，执行线程任务中的run方法
         t0.start();
         t1.start();
         t2.start();
         t3.start();
     }
 }

运行结果：

结果分析：

那么怎么再判断flag呢？while

代码如下：

 class Resource
 {
     private String name;
     private int count=1;
     private boolean flag=false;

     public synchronized void set(String name) // 有两个线程t0 t1
     {
         while(flag)
             try{this.wait();}catch(InterruptedException e){}
         this.name=name+count;
         count++;
         System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
         flag = true;
         notify();
     }

     public synchronized void out() // 有两个线程t2 t3
     {
         while(!flag)
             try{this.wait();}catch(InterruptedException e){}
         System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
         flag = false;
         notify();
     }
 }

结果出现死锁：

结果分析：

通过分析，那能不能每次唤醒只唤醒对方线程（如生产者线程只唤醒消费者线程，消费者线程只唤醒生产者线程），查看Object对象方法中没有，但是有一个notifyAll()方法，实在不行就把所有阻塞线程（相同同步锁的线程）都唤醒。

 class Resource
 {
     private String name;
     private int count=1;
     private boolean flag=false;

     public synchronized void set(String name) // 有两个线程t0 t1
     {
         while(flag)
             try{this.wait();}catch(InterruptedException e){}
         this.name=name+count;
         count++;
         System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
         flag = true;
         notifyAll();
     }

     public synchronized void out() // 有两个线程t2 t3
     {
         while(!flag)
             try{this.wait();}catch(InterruptedException e){}
         System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
         flag = false;
         notifyAll();
     }
 }

结果：

这样就可以了。

总结：

if判断只能判断一次，如果执行等待方法，下次唤醒的线程获取执行权后（唤醒后的线程会从上次等待位置，向下执行）就不能再判断

while判断解决唤醒的线程获取执行权后无法判断

notify：只能唤醒任意一个线程，有可能会唤醒本方线程，while+notify会导致死锁

notifyAll:解决了死锁问题