解决多生产 多消费的效率问题
使用Lock接口来解决
调用接口需要覆盖所有的抽象方法 所以一般情况下我们使用它已经实现的Lock子类
这里我们使用ReentrantLock类来创建对象
一个可重入互斥Lock具有与使用synchronized方法和语句访问的隐式监视锁相同的基本行为和语义，但具有扩展功能。
Lock lock=new ReentrantLock();//多态
private ReentrantLock lock=new ReentrantLock();
多态不能调用子类特有的方法
可以使用方法lock(); 获取锁unlock();释放锁
但因为同步synchronized中出现异常会自动释放锁 而Lock类对象方法不行
所以配合try{}finally{}使用
实例：
Lock lock...
lock.lock();
try{
code
}
finally
{
lock.unlock();
}
Lock锁中与监视器是分开的 监视器condition类对象 需要和Lock绑定才能使用，一个Lock锁上可以绑定多个condition
要在Lock类上获取绑定的condition监视器需要使用lock.newCondition();方法
例如
final Condition notFull = lock.newCondition();
Conditon监视器中有await();signal();signalALL();分别对应synchronized中wait();notify();notifyALL();方法
因为在Lock锁中和obj类中方法不同的事 Lock方法中锁和监视器是分开的
所以运行一个锁中对应多个监视器
就可以对应的等待和唤醒操作
obj中想实现多个监视器需要多个锁
obj中多个锁嵌套使用容易出现死锁情况
最终实例
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//描述资源
class Bread{
private String name;
private int count=0;
private boolean flog;//默认为false
// private ReentrantLock lock=new ReentrantLock();
Lock lock=new ReentrantLock();//多态//创建Lock中的子类对象实例
Condition producer_con=lock.newCondition();//创建生产者监视器
Condition consumer_con=lock.newCondition();//创建消费者监视器
public Bread(String name) {
this.name = name;
}
//生产方法
public void produce(){
try {
lock.lock();
while (flog) {//如果为true有面包储存 则会进入wait等待因为默认为false则结果为
//false所以进入else
try {
producer_con.await();//有面包让生产者线程等待
}
catch (InterruptedException e){}
}
//生产面包
count++;
System.out.println(Thread.currentThread().getName()+"生产"+name+"数量"+count);
flog=true;
consumer_con.signal();//激活其中一个消费者线程
}
finally {
lock.unlock();//手动释放锁
}
}
//销售方法
public void sale(){
try {
lock.lock();
while (!flog){//如果没有储存的面包则结果为true进入wait等待
try {
consumer_con.await();
}catch (InterruptedException e){}
}
//如果为else则会售出这个面包
System.out.println(Thread.currentThread().getName()+"销售"+name+"数量"+count);
flog=false;//将库存改为没有
producer_con.signal();//激活窗口1线程
}
finally {
lock.unlock();
}
}
}
//生产窗口
class Producer implements Runnable{
private Bread bread;
//从外界引入同一对象
public Producer(Bread bread) {
this.bread = bread;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
bread.produce();
}
}
}
//销售窗口
class ConSumer implements Runnable{
private Bread bread;
//从外界引入同一对象
public ConSumer(Bread bread) {
this.bread = bread;
}
@Override
public void run() {
for (int j = 0; j < 20; j++) {
bread.sale();
}
}
}
public class Producer_ConSumerDemo {
public static void main(String[] args) {
Bread bread=new Bread("面包");
Producer producer=new Producer(bread);
ConSumer conSumer=new ConSumer(bread);
Thread t0=new Thread(producer,"窗口1");
Thread t1=new Thread(producer,"窗口2");
Thread t2=new Thread(conSumer,"窗口3");
Thread t3=new Thread(conSumer,"窗口4");
t0.start();
t1.start();
t2.start();
t3.start();
}
}
