Java线程之1.5版新特性多生产者多消费者（四）

在Java1.5以前的版本中，因为监视器是来自于Object，为了线程的互斥访问，用的synchronized方法或者模块

• 在synchronized中，“锁”的操作是隐式的，而且每一个锁里只能有一组wait-notify或是wait-notifyAll方法，这样的弊端在于
  等待和唤醒的缓冲线程里不仅包括了生产者也包括了消费者，这样就不能指定唤醒进程，要么唤醒了全部进程，影响了效率，要么休眠了所有进程，发生死锁

Java从1.5版本开始支持新的”锁“，体现的面向对象的特点，将锁封装起来

• Lock实例可以通过Condition挂载多个监视器
  Condition c1 = lock.newCondition();
  Condition c2 = lock.newCondition();
  Condition中的await(),signal() ,signalAll() 来替换对应Object对象锁的方法

这样就可以实现一个锁，而指定唤醒对方进程，避免死锁，提高执行效率

java.util.concurrent.locks 为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。

java.util.concurrent.locks
接口 Lock
所有已知实现类：
ReentrantLock,ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock

• 关于ReentrantLock
  一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

其实就是synchronized的隐形锁换成了Lock中的显示锁及显示操作

void method(){{    synchronized (obj)//对象锁        {            //code...        }}

改了形式

Lock lock = new ReentrantLock();//void method(){    try    {        lock.lock();//显示获取锁        code...throw Exception();//因为可能发生中断异常，所以把管闭锁的动作放到finally中    }    finally    {        lock.unlock();    }

eg:

mport java.util.concurrent.locks.*;class Resource{    String name;    private int count = 1;    String id ;    private boolean flag = false;//初始默认没有产品    //创建锁    Lock lock = new ReentrantLock();    //通过已有的锁创建两个监视，分别监视生产者和消费者    Condition cp = lock.newCondition();//生产者监视器    Condition cc = lock.newCondition();//消费者监视器    public  void producer(String name)    {        try        {            lock.lock();            while(flag)            try{cp.await();} catch (InterruptedException ex){}//生产者等待            this.name = name;            id = name + count++;            System.out.println(Thread.currentThread().getName()+"--->生产："+id);            flag = true;            cc.signal();//唤醒消费者        }        finally         {            lock.unlock();        }    }    public void consumer()    {        try        {            lock.lock();            while(!flag)            try{cc.await();} catch (InterruptedException ex){}//消费者等待           System.out.println(Thread.currentThread().getName()+"--------->消费"+id);           flag = false;           cp.signal();//唤醒生产者        }        finally         {            lock.unlock();        }    }}class Producer implements Runnable{    Resource r;    Producer(Resource r)    {        this.r = r;    }    public void run()    {        while(true)        {            r.producer("包子");        }    }}class Consumer implements Runnable{    Resource r;    Consumer(Resource r)    {        this.r = r;    }    public void run()    {        while (true)        {            r.consumer();        }    }}class ThreadPC3{    public static void main(String[] args)     {        //创建资源        Resource r = new Resource();        //创建线程任务        Producer p0 = new Producer(r);        Producer p1 = new Producer(r);        Consumer c0 = new Consumer(r);        Consumer c1 = new Consumer(r);        //创建线程        Thread tp0 = new Thread(p0);        Thread tp1 = new Thread(p1);        Thread tc0 = new Thread(c0);        Thread tc1 = new Thread(c1);        //开启线程        tp0.start();        tp1.start();        tc0.start();        tc1.start();    }}

这个是API中的例子：

这个不用自己实现，已经封装的

class BoundedBuffer {   final Lock lock = new ReentrantLock();   final Condition notFull  = lock.newCondition();    final Condition notEmpty = lock.newCondition();    final Object[] items = new Object[100];   int putptr, takeptr, count;   public void put(Object x) throws InterruptedException {     lock.lock();     try {       while (count == items.length)          notFull.await();       items[putptr] = x;        if (++putptr == items.length) putptr = 0;       ++count;       notEmpty.signal();     } finally {       lock.unlock();     }   }   public Object take() throws InterruptedException {     lock.lock();     try {       while (count == 0)          notEmpty.await();       Object x = items[takeptr];        if (++takeptr == items.length) takeptr = 0;       --count;       notFull.signal();       return x;     } finally {       lock.unlock();     }   }  }