线程间通信--生产者消费者 升级版JDK5

import java.util.concurrent.locks.*;



/*
1.新的解锁，上锁操作，据说是jdk5.0升级版，以前的枷锁，解锁都是隐藏的，默认的，现在变成显式

2.新的异常处理方式   这次增多了一个上锁就不是内部处理等待异常了，主动抛？

3.再增，两个什么生产者，消费者都是对这个类的数据进行同时的读和取出处理，不是像之前那样，直接都一个就没了，我又读又写，又读又写。。。读读写写
然后再对读和写进行多线程加速！---进而处理一系列的线程问题

4.无论是上锁解锁，冻结唤醒机制，都用到了很显式的那种方式，很好用，爱不释手，逻辑思维清晰
*/











class ProducerConsumerDemo2
{
    public static void main(String[] args)
    {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized
    lock
    unlock
    newCondition()

Condition：替代了Object wait notify notifyAll
    await();
    signal();
    signalAll();
*/
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
            //  t1    t2
    private Lock lock = new ReentrantLock();                          /*多态建立对象，用于上锁*/

    private Condition condition_pro = lock.newCondition();          /*后面是返回condition的对象，后面用到里面的冻结方法*/
    private Condition condition_con = lock.newCondition();



    public  void set(String name)throws InterruptedException        /*没有写catch，证明不是内部try catch ，那么抛异常，因为不是接口，必须抛*/
    {                                                                /*throws的特殊性，可以不用catch*/
        lock.lock();                                                /*每一个线程进去都会主动上锁，不让其他人进去*/
        try
        {
            while(flag)
                condition_pro.await();//t1,t2                                /*冻结是会抛异常的，要try，而上次是runable接口，不能抛，这次要抛了*/
            this.name = name+"--"+count++;

            System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
            flag = true;
            condition_con.signal();
        }
        finally
        {
            lock.unlock();//释放锁的动作一定要执行。                        /*不像以前的，直接默认开锁，这里必须要主动开，也是释放资源的动作*/
        }
    }


    //  t3   t4  
    public  void out()throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)
                condition_con.await();                                     /*那个线程进来这里，就肯定调用这个对象的冻结方法，那么就属于这个对象了，也可以说，进入这栋门赋予的，也就是奖励*/
            System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
            flag = false;
            condition_pro.signal();                                        /*给属于这个对象的其中一个线程解锁，逻辑思路超清晰*/
        }
        finally
        {
            lock.unlock();
        }
        
    }
}

class Producer implements Runnable
{
    private Resource res;

    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.set("+商品+");               /*这个函数有异常声明，那么必须try catch格式要全面*/
            }
            catch (InterruptedException e)             /*不处理*/
            {
            }
            
        }
    }
}

class Consumer implements Runnable
{
    private Resource res;

    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.out();
            }
            catch (InterruptedException e)
            {
            }
        }
    }
}