之前使用synchronized实现生产者与消费者，虽然可行，也没有错误，但是最终唤醒全部线程的做法会牺牲程序的性能，造成无谓的浪费，在JDK1.5版本之前，对锁的操作时隐式的，只能使用synchronized实现同步锁的效果：
// 以synchronized代码块为例
synchronized (对象) {// 此时获取锁
// 要执行的任务
} // 此时释放锁
之所以说是隐式，是因为如果对此内容不够了解的话，仅从以上代码根本看不出锁的体现，但从JDK1.5版本开始，就可以对锁进行显式的操作，增加了一个Lock接口，实际上是将锁进行了面向对象，Lock接口实现提供了比synchronized方法和语句可获得的更广泛的锁定操作。
1、使用Lock修改示例代码
此处仅使用Lock替代同步代码块，其余部分不变：
1.使用Lock接口子类ReentrantLock创建一把锁
2.把之前写在同步代码块中的内容写在lock()方法和unlock()方法之间
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//描述产品
class Product {
private String name;
private int count;
private boolean flag;
// 创建一把锁
private Lock lock = new ReentrantLock();
// 生产产品的功能
public void produce(String name) {
lock.lock();// 获取锁
try{
while (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = count + "个" + name;
System.out.println(Thread.currentThread().getName() + "生产了" + this.name);
count++;
flag = true;
notifyAll();
}
/*
* 为了保证线程正常运行
* unlock()方法一定要执行
* 因此将该方法放入finally块中
* 但是finally块不能单独使用
* 因此使用try块予以配合
*/
finally{
lock.unlock();// 释放锁
}
}
// 消费产品的功能
public void consume() {
// 使用同一把锁
lock.lock();
try{
while (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "消费了" + this.name);
flag = false;
notifyAll();
}
finally{
lock.unlock();
}
}
}
此时结果如下：
结果很明显，出现了IllegalMonitorStateException（无效的监视器状态异常），发生该异常的原因也很简单，归根到底就是wait()方法与notifyAll()方法。之前讲过，这些方法一定要用在同步当中，并且由对象，也就是锁来调用，当对象是this时可以省略不写，而现在用Lock接口代替了synchronized，因此也就意味着没有同步方法，自然也就无法使用这些方法了，那么如何解决这个问题呢？
2、使用Condition接口实现等待唤醒
JDK1.5版本对唤醒等待方法也进行了面向对象，即Condition接口，该接口将Object类中的监视器方法（wait()、notify()和 notifyAll()）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用。其中，Lock替代了synchronized方法和语句的使用，Condition替代了 Object 监视器方法的使用。Condition的实例实质上被绑定到一个锁上。要为特定Lock实例获得Condition实例，可使用Lock接口中的newCondition()方法，示例代码如下：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//描述产品
class Product {
private String name;
private int count;
private boolean flag;
private Lock lock = new ReentrantLock();
// 得到与锁绑定的condition对象
private Condition con = lock.newCondition();
// 生产产品的功能
public void produce(String name) {
lock.lock();
try{
while (flag) {
try {
/*
* 虽然是用condition对象调用await()方法
* 但由于condition对象已经于lock锁绑定
* 因此实际上依然是让持有特定锁的线程进入等待
*/
con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = count + "个" + name;
System.out.println(Thread.currentThread().getName() + "生产了" + this.name);
count++;
flag = true;
// 同理用condition对象唤醒所有持有lock锁的线程
con.signalAll();;
}
finally{
lock.unlock();
}
}
// 消费产品的功能
public void consume() {
// 使用同一把锁
lock.lock();
try{
while (!flag) {
try {
con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "消费了" + this.name);
flag = false;
con.signalAll();;
}
finally{
lock.unlock();
}
}
}
此时结果如下：
虽然目前使用Lock接口以及Condition接口实现了生产者与消费者，但依然是唤醒全部线程，程序性能并没有提升，此时就可以使用Lock接口与Condition接口的灵活性来避免这个问题。
3、JDK1.5版本后的多线程程序
在JDK1.5版本之前，只能使用synchronized方法实现同步，但synchronized方法的局限性是，wait()方法、notify()方法都必须放在synchronized代码块内部，且操作锁上线程的方法与锁都是绑定在一起的，但是JDK1.5版本之后可以使用Lock接口直接创建一把锁，而这把锁可以使用newCondition()方法创建多个Condition对象，每一个对象都可以单独实现await()、signa()等方法，但实际上这些Condition对象仍然使用的是同一把锁，因此就实现了单独控制线程而不需要统一唤醒，从而提升了程序的性能，示例代码如下：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//描述产品
class Product {
private String name;
private int count;
private boolean flag;
private Lock lock = new ReentrantLock();
// 得到与锁绑定的condition对象，控制生产线程的等待与唤醒
private Condition con1 = lock.newCondition();
// 得到与锁绑定的condition对象，控制消费线程的等待与唤醒
private Condition con2 = lock.newCondition();
// 生产产品的功能
public void produce(String name) {
lock.lock();
try{
while (flag) {
try {
// 生产线程con1进入等待
con1.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = count + "个" + name;
System.out.println(Thread.currentThread().getName() + "生产了" + this.name);
count++;
flag = true;
// 唤醒消费线程con2
con2.signal();;
}
finally{
lock.unlock();
}
}
// 消费产品的功能
public void consume() {
lock.lock();
try{
while (!flag) {
try {
// 消费线程con2进入等待
con2.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "消费了" + this.name);
flag = false;
// 唤醒生产线程con1
con1.signal();;
}
finally{
lock.unlock();
}
}
}
//生产任务
class Producer implements Runnable {
private Product pro;
public Producer(Product pro) {
this.pro = pro;
}
public void run() {
while (true) {
pro.produce("笔记本");
}
}
}
//消费任务
class Consumer implements Runnable {
private Product pro;
public Consumer(Product pro) {
this.pro = pro;
}
public void run() {
while (true) {
pro.consume();
}
}
}
public class Demo1 {
public static void main(String[] args) {
Product pro = new Product();
Producer producer = new Producer(pro);
Consumer consumer = new Consumer(pro);
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer);
t0.start();
t1.start();
t2.start();
t3.start();
}
}
之所以con1和con2就可以控制生产线程与消费线程，是因为线程T0、T1执行的就是producer方法，在执行该方法的con1.await();代码时，T0或T1线程就会等待，因此也就保证con1与生产线程实现了绑定，此时con2唤醒的只能是T2或T3线程，同理，消费线程也是如此，实现了程序性能的提升。
4、使用Lock接口与Condition接口实现生产者与消费者的完整示例代码
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//描述产品
class Clothes {
// 产品名称
private String name;
// 产品价格
private double price;
// 存放产品的容器
private Clothes[] arr = new Clothes[100];
// 创建生产使用的下标
private int propointer;
// 创建消费使用的下标
private int conpointer;
// 创建一把锁
private Lock lock = new ReentrantLock();
// 得到与锁绑定的condition对象，控制生产线程的等待与唤醒
private Condition pro = lock.newCondition();
// 得到与锁绑定的condition对象，控制消费线程的等待与唤醒
private Condition con = lock.newCondition();
// 记录产品数量
private int count;
// 生成无参的构造方法
public Clothes() {
}
// 生成带参的构造方法
public Clothes(String name, double price) {
this.name = name;
this.price = price;
}
// 生产产品的功能
public void produce() {
lock.lock();
try {
/*
* 先判断是否可以生成
* 当容器满时不生产
* 即产品数量与容器容量相同
*/
while (count == arr.length) {
try {
// 生产线程pro进入等待
pro.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 将生产的衣服存入容器
arr[propointer] = new Clothes("衬衣", 9.15);
System.out.println(Thread.currentThread().getName() + "生产了" + arr[propointer] + "，此为第" + count + "件");
// 生产后数量加一
count++;
/*
* 判断生产下标
* 如果下标加一之后与容量相同
* 说明容器已满 下标清零
*/
if (++propointer == arr.length) {
propointer = 0;
}
// 唤醒消费线程con
con.signal();
;
} finally {
lock.unlock();
}
}
/*
* 因为输出arr[propointer]
* 实际上Clothes类型的对象
* 输出对象默认调用其toString方法
* 因此还需要重写该方法
*/
public String toString() {
return "价格为" + price + "英镑的" + name;
}
// 消费产品的功能
public void consume() {
lock.lock();
try {
/*
* 先判断是否可以消费
* 当产品数量为0时
* 不能消费
*/
while (count == 0) {
try {
// 消费线程con进入等待
con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 消费一件产品
Clothes clothes = arr[conpointer];
System.out.println(Thread.currentThread().getName() + "消费了" + clothes);
// 产品总量减一
count--;
/*
* 判断消费下标
* 如果下标加一之后与容量相同
* 说明已取到最后一件产品
* 下标清零
*/
if (++conpointer == arr.length) {
conpointer = 0;
}
// 唤醒生产线程pro
pro.signal();
;
} finally {
lock.unlock();
}
}
}
// 生产任务
class Producer implements Runnable {
private Clothes clo;
public Producer(Clothes clo) {
this.clo = clo;
}
public void run() {
while (true) {
clo.produce();
}
}
}
// 消费任务
class Consumer implements Runnable {
private Clothes clo;
public Consumer(Clothes clo) {
this.clo = clo;
}
public void run() {
while (true) {
clo.consume();
}
}
}
public class Demo2 {
public static void main(String[] args) {
Clothes clo = new Clothes();
Producer producer = new Producer(clo);
Consumer consumer = new Consumer(clo);
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer);
t0.start();
t1.start();
t2.start();
t3.start();
}
}
此时结果如下：
版权声明：欢迎转载，欢迎扩散，但转载时请标明作者以及原文出处，谢谢合作！ ↓↓↓
