java生产者消费者流程图_Java基础学习——多线程（线程间通信-生产者消费者代码示例）...

JDK 1.5提供了多线程升级方案

将同步synchronized替换成了显示的Lock操作。可以实现唤醒、冻结指定的线程。

Lock接口

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

线程间通信Condition接口

Condition可以替代传统的线程间通信，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()。该对象可以通过Lock锁进行获取。

传统线程的通信方式，Condition都可以实现。

注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

ReentrantLock类

Java.util.concurrent.lock 中的Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。

ReentrantLock 类实现了Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。(换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。)

用法示例：

private Lock lock = new ReentrantLock();//定义多态ReentrantLock类对象

private Condition cond_pro = lock.newCondition();//Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用Lock对象的newCondition()方法。

private Condition cond_con = lock.newCondition();//一个lock可以有多个相关的condition

首先创建一个ReentrantLock类的多态对象，即建立一把锁。然后将这把锁与两个Condition对象关联。

实例：

import java.util.concurrent.locks.*;

class ProducerConsumerDemo

{

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();

}

}

class Resource

{

private String name;

private int count = 1;

private boolean flag = false;

private Lock lock = new ReentrantLock();//定义一个实现Lock接口的ReentrantLock类对象

private Condition cond_pro = lock.newCondition();//Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用Lock对象的newCondition()方法。

private Condition cond_con = lock.newCondition();//一个lock可以有多个相关的condition

public void set(String name) throws InterruptedException//生产方法

//注意这里抛出await()方法异常声明，交给调用者处理

{

lock.lock(); //手动加同步锁

try

{

while (flag) //if→while 此时若生产完一个以后唤醒了另一个生产者，则再次判断，避免了两个生产者同时生产

cond_pro.await(); //冻结生产方法

this.name = name+"____"+count++;

System.out.println(Thread.currentThread().getName()+"_______"+"生产者"+this.name);

flag = true;

cond_con.signal(); //唤醒消费方法，利用了condition的signal()指定唤醒对象

}

finally //

{

lock.unlock();

}

}

public void out()throws InterruptedException

{

lock.lock();

try

{

while (!flag)

cond_con.await();

System.out.println(Thread.currentThread().getName()+"______"+"消费者"+this.name);

flag = false;

cond_pro.signal();

}

finally //释放锁必须得到执行

{

lock.unlock();

}

}

}

class Consumer implements Runnable

{

private Resource res;

public Consumer(Resource res)

{

this.res = res;

}

public void run()

{

while (true)

{

try //由于out()方法抛出了异常声明，这里必须捕获。

{

res.out();

}

catch (InterruptedException e)

{

}

}

}

}

class Producer implements Runnable

{

private Resource res;

public Producer(Resource res)

{

this.res = res;

}

public void run()

{

while (true)

{

try

{

res.set("+商品+");

}

catch (InterruptedException e)

{

}

}

}

}

执行上述代码，观察结果：

可以看到，多个线程同时生产、消费，由于指定唤醒互异线程，因此并不会引起错误。