两个线程一个生产者个一个消费者
需求情景
两个线程，一个负责生产，一个负责消费，生产者生产一个，消费者消费一个
涉及问题
同步问题：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用标记或加锁机制
wait() / nofity() 方法是基类object的两个方法，也就意味着所有java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。
wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。
notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。
代码实现(共三个类和一个main方法的测试类)
resource.java /** * created by yuandl on 2016-10-11./** * 资源 */ public class resource { /*资源序号*/ private int number = 0; /*资源标记*/ private boolean flag = false; /** * 生产资源 */ public synchronized void create() { if (flag) {//先判断标记是否已经生产了，如果已经生产，等待消费; try { wait();//让生产线程等待 } catch (interruptedexception e) { e.printstacktrace(); } } number++;//生产一个 system.out.println(thread.currentthread().getname() + "生产者------------" + number); flag = true;//将资源标记为已经生产 notify();//唤醒在等待操作资源的线程(队列) } /** * 消费资源 */ public synchronized void destroy() { if (!flag) { try { wait(); } catch (interruptedexception e) { e.printstacktrace(); } } system.out.println(thread.currentthread().getname() + "消费者****" + number); flag = false; notify(); } 　}
producer.java　
/** * created by yuandl on 2016-10-11. * /** * 生产者 */ public class producer implements runnable { private resource resource; public producer(resource resource) { this.resource = resource; } @override public void run() { while (true) { try { thread.sleep(10); } catch (interruptedexception e) { e.printstacktrace(); } resource.create(); } } }
consumer.java
　/** * 消费者 */ public class consumer implements runnable { private resource resource; public consumer(resource resource) { this.resource = resource; } @override public void run() { while (true) { try { thread.sleep(10); } catch (interruptedexception e) { e.printstacktrace(); } resource.destroy(); } } }
producerconsumertest.java
/** * created by yuandl on 2016-10-11. */ public class producerconsumertest { public static void main(string args[]) { resource resource = new resource(); new thread(new producer(resource)).start();//生产者线程 new thread(new consumer(resource)).start();//消费者线程 } }
打印结果
thread-0生产者------------1 　thread-1消费者****1 thread-0生产者------------2 thread-1消费者****2 thread-0生产者------------3 thread-1消费者****3 thread-0生产者------------4 thread-1消费者****4 thread-0生产者------------5 thread-1消费者****5 thread-0生产者------------6 thread-1消费者****6 thread-0生产者------------7 thread-1消费者****7 thread-0生产者------------8 thread-1消费者****8 thread-0生产者------------9 thread-1消费者****9 thread-0生产者------------10 thread-1消费者****10
以上打印结果可以看出没有任何问题
多个线程，多个生产者和多个消费者的问题
需求情景
四个线程，两个个负责生产，两个个负责消费，生产者生产一个，消费者消费一个
涉及问题
notifyall()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的所有线程发出可执行的通知，同时放弃锁，使自己处于等待状态。
再次测试代码
producerconsumertest.java /** * created by yuandl on 2016-10-11. */ public class producerconsumertest { public static void main(string args[]) { resource resource = new resource(); new thread(new consumer(resource)).start();//生产者线程 new thread(new consumer(resource)).start();//生产者线程 new thread(new producer(resource)).start();//消费者线程 new thread(new producer(resource)).start();//消费者线程 } }
运行结果
thread-0生产者------------100 thread-3消费者****100 thread-0生产者------------101 thread-3消费者****101 thread-2消费者****101 thread-1生产者------------102 thread-3消费者****102 thread-0生产者------------103 thread-2消费者****103 thread-1生产者------------104 thread-3消费者****104 thread-1生产者------------105 thread-0生产者------------106 thread-2消费者****106 thread-1生产者------------107 thread-3消费者****107 thread-0生产者------------108 thread-2消费者****108 thread-0生产者------------109 thread-2消费者****109 thread-1生产者------------110 thread-3消费者****110
通过以上打印结果发现问题
101生产了一次，消费了两次
105生产了，而没有消费
原因分析
当两个线程同时操作生产者生产或者消费者消费时，如果有生产者或者的两个线程都wait()时，再次notify(),由于其中一个线程已经改变了标记而另外一个线程再次往下直接执行的时候没有判断标记而导致的。
if判断标记，只有一次，会导致不该运行的线程运行了。出现了数据错误的情况。
解决方案
while判断标记，解决了线程获取执行权后，是否要运行!也就是每次wait()后再notify()时先再次判断标记
代码改进(resource中的if->while)
resource.java
/** * created by yuandl on 2016-10-11./** * 资源 */ public class resource { /*资源序号*/ private int number = 0; /*资源标记*/ private boolean flag = false; /** * 生产资源 */ public synchronized void create() { while (flag) {//先判断标记是否已经生产了，如果已经生产，等待消费; try { wait();//让生产线程等待 } catch (interruptedexception e) { e.printstacktrace(); } } number++;//生产一个 system.out.println(thread.currentthread().getname() + "生产者------------" + number); flag = true;//将资源标记为已经生产 notify();//唤醒在等待操作资源的线程(队列) } /** * 消费资源 */ public synchronized void destroy() { while (!flag) { try { wait(); } catch (interruptedexception e) { e.printstacktrace(); } } system.out.println(thread.currentthread().getname() + "消费者****" + number); flag = false; notify(); } }
再次发现问题
打印到某个值比如生产完74，程序运行卡死了，好像锁死了一样。
原因分析
notify:只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致”死锁”。
解决方案
notifyall解决了本方线程一定会唤醒对方线程的问题。
最后代码改进(resource中的notify()->notifyall())
resource.java
/** * created by yuandl on 2016-10-11./** * 资源 */ public class resource { /*资源序号*/ private int number = 0; /*资源标记*/ private boolean flag = false; /** * 生产资源 */ public synchronized void create() { while (flag) {//先判断标记是否已经生产了，如果已经生产，等待消费; try { wait();//让生产线程等待 } catch (interruptedexception e) { e.printstacktrace(); } } number++;//生产一个 system.out.println(thread.currentthread().getname() + "生产者------------" + number); flag = true;//将资源标记为已经生产 notifyall();//唤醒在等待操作资源的线程(队列) } /** * 消费资源 */ public synchronized void destroy() { while (!flag) { try { wait(); } catch (interruptedexception e) { e.printstacktrace(); } } system.out.println(thread.currentthread().getname() + "消费者****" + number); flag = false; notifyall(); } }
运行结果
thread-0生产者------------412 thread-2消费者****412 thread-0生产者------------413 thread-3消费者****413 thread-1生产者------------414 thread-2消费者****414 thread-1生产者------------415 thread-2消费者****415 thread-0生产者------------416 thread-3消费者****416 thread-1生产者------------417 thread-3消费者****417 thread-0生产者------------418 thread-2消费者****418 thread-0生产者------------419 thread-3消费者****419 thread-1生产者------------420 thread-2消费者****420
以上就大功告成了，没有任何问题