Java16-6 Lock锁

解决多生产 多消费的效率问题
使用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();
    }
}