JavaSE笔记7.7-多线程-jdk5.0生产者消费者升级版

JDK1.5中提供了多线程升级解决方案

• 将同步Synchronized替换成显式的Lock操作（以前的加锁/解锁都是隐藏的，默认的，现在变成显式的）：lock()/unlock()
• 将Object中的wait()/notify()/notifyAll()替换成Condition对象的await()/signal()/signalAll()
• 该Condition对象可以由Lock锁进行获取：new Condition()
• 一个Lock可以对应多个Condition，实现了本方只唤醒对方的操作

1. 按照新特性重写以前的代码

package Test1;
import java.util.concurrent.locks.*;

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

    //利用多态，ReentrantLock是接口Lock的已知实现类
    private Lock lock=new ReentrantLock();
    //创建一个新Condition绑定到该Lock
    private Condition condition=lock.newCondition();

    //await()方法，抛出异常，而不是内部try/catch处理
    public void set(String name)throws InterruptedException
    {
        //每一个线程进去都会主动上锁，不让其他线程进去
        lock.lock();
        try{
            //循环判断线程状态
            while(flag)
                condition.await();//会抛出异常
            this.name=name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
            flag=true;
            //唤醒线程
            condition.signalAll();
        }
        //释放锁的动作一定要执行，要主动开锁
        finally {
            lock.unlock();
        }
    }

    //await()方法，抛出异常，而不是内部try/catch处理
    public void out()throws InterruptedException
    {
        //每一个线程进去都会主动上锁，不让其他线程进去
        lock.lock();
        try{
            //循环判断线程状态
            while(!flag)
                condition.await();//会抛出异常
            System.out.println(Thread.currentThread().getName()+"...消费者..........."+this.name);
            flag=false;
            //唤醒线程
            condition.signalAll();
        }
        //释放锁的动作一定要执行，要主动开锁
        finally {
            lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Res r;
    Producer(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            try{
                //这个函数有异常声明，要进行try/catch处理
                r.set("+商品+");
            }
            catch (InterruptedException e){

            }

        }
    }
}
class Consumer implements Runnable
{
    private Res r;
    Consumer(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            //这个函数有异常声明，要进行try/catch处理
            try{
                r.out();
            }
            catch (InterruptedException e){

            }
        }
    }
}
class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        Res r=new Res();
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        Thread t1=new Thread(p);
        Thread t2=new Thread(p);
        Thread t3=new Thread(c);
        Thread t4=new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

2. 利用新特性，实现只唤醒对方不唤醒本方

package Test1;
import java.util.concurrent.locks.*;

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

    //利用多态，ReentrantLock是接口Lock的已知实现类
    private Lock lock=new ReentrantLock();
    //控制生产者的await()和signalALl()
    private Condition condition_pro=lock.newCondition();
    //控制消费者的await()和signalALl()
    private Condition condition_con=lock.newCondition();

    //await()方法，抛出异常，而不是内部try/catch处理
    public void set(String name)throws InterruptedException
    {
        //每一个线程进去都会主动上锁，不让其他线程进去
        lock.lock();
        try{
            //循环判断线程状态
            while(flag)
                condition_pro.await();//生产者等待
            this.name=name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
            flag=true;
            //消费者唤醒
            condition_con.signalAll();
        }
        //释放锁的动作一定要执行，要主动开锁
        finally {
            lock.unlock();
        }
    }

    //await()方法，抛出异常，而不是内部try/catch处理
    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.signalAll();
        }
        //释放锁的动作一定要执行，要主动开锁
        finally {
            lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Res r;
    Producer(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            try{
                //这个函数有异常声明，要进行try/catch处理
                r.set("+商品+");
            }
            catch (InterruptedException e){

            }

        }
    }
}
class Consumer implements Runnable
{
    private Res r;
    Consumer(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            //这个函数有异常声明，要进行try/catch处理
            try{
                r.out();
            }
            catch (InterruptedException e){

            }
        }
    }
}
class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        Res r=new Res();
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        Thread t1=new Thread(p);
        Thread t2=new Thread(p);
        Thread t3=new Thread(c);
        Thread t4=new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}