多线程-线程间通信-多生产者多消费者问题（JDK1.5后Lock，Condition解决办法及开发中代码范例）

package multithread4;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*同步代码块对于锁的操作是隐式的
 * 
 * jdk1.5以后将同步和锁封装成了对象。
 * 并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作 
 * 
 * 
 * Lock接口：出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成显式锁操作
 * 同时更为灵活，可以一个锁上加上多组监视器。
 * lock():获取锁
 * unlock():释放锁，通常需要定义finally代码块中。
 * 
 * Condition接口：出现替代了Object中的wait notify notifyAll方法。
 *                 将这些监视器方法单独进行了封装，变成Conditon监视器对象。
 *                 可以与任意锁进行组合
 * await();
 * signal();
 * signalAll();
 * 
 */


/*
 * 生产者，消费者。
 * 
 * 多生产者，多消费者的问题。
 * 
 * if判断标记，只有一次，会导致不该运行的线程运行了。出现了数据错误的情况。
 * while判断标记，解决了线程获取执行权后，是否要运行！
 * 
 * notify：只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会产生死锁
 * notifyAll解决了，本方线程一定会唤醒对方线程
 * 
 * 死锁 四个线程都等待没有被唤醒也是一种情况，悬挂
 */

class Resource2{
    private String name;
    private int count = 1;
    private boolean flag = false;
    //创建一个锁对象
    Lock lock = new ReentrantLock();
    //通过已有的锁获取该锁上的监视器对象。
//    Condition con = lock.newCondition();
    
    //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。 用lock condition解决办法
    Condition producer_con = lock.newCondition();
    Condition consumer_con = lock.newCondition();
    
    public void set(String name) {
        lock.lock();
        try {
            /*if*/ while (flag) {
                try {
//                    lock.wait();
//                    con.await();
                    producer_con.await();
                } catch (InterruptedException e) {
                    
                }
            }
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);
            flag = true;
//            notify();
//            notifyAll();
//            con.signalAll();
            consumer_con.signal();
        } finally {
            lock.unlock();
        }

    }
    public void out() {
        lock.lock();
        try {
            /*if*/ while (!flag) {
                try {
//                    con.await();
                    consumer_con.await();
                } catch (InterruptedException e) {
                    
                }
            }
            System.out.println(Thread.currentThread().getName()+"..消费者......"+this.name);
            flag = false;
//            notify();
//            notifyAll();//为了解决死锁 将其余三个都唤醒
//            con.signalAll();
            producer_con.signal();
        } finally {
            lock.unlock();
        }

}

class Producer implements Runnable{
    private Resource2 r;
    public Producer(Resource2 r) {
        this.r = r;
    }
    public void run() {
        while(true) {
            r.set("烤鸭");
        }
    }
}
class Consumer implements Runnable{
    private Resource2 r;
    public Consumer(Resource2 r) {
        this.r = r;
    }
    public void run() {
        while(true) {
            r.out();
        }
    }
}
public class ProducerConsumerDemo2 {

    public static void main(String[] args) {
        
        Resource2 r = new Resource2();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }

}