Lock多线程

/*
在java.util.concurrent.locks 软件包中提供相应的解决方案
Lock接口,比同步更厉害,有更多操作:
            lock();获取锁
            unlock();释放锁
      提供一个更加面向对象的锁,在该锁中提供了更多的显式的锁操作.

 已经将旧锁换成新锁,那么锁上的监视器方法(wait,notify,notifyAll)也应该替换成新锁的监视器方法.
 原有的监视器方法封装到了一个Condition对象中.
 想要获取监视器方法,需要先获取Condition对象.

 Condition对象的出现其实就是替代了Object中的监视器方法。
 await();
 signal();
 signalAll();


{
     Lock lock = new ReentrantLock();

     所有的监视器方法封装到Condition对象中.
     Condition con = lock.newCondition();//获取lock上的监视器方法

     lock.lock();//获取锁
        con.await();//wait()
        con.signal();//notify();
     lock.unlock();//释放锁
}




可以在一个锁上加多个监视器对象,解决效率问题
 */


import java.util.concurrent.locks.*;

//1.描述资源。属性：名称和编号。行为：对名称赋值，获取
class Resource{
    private String name;
    private int count = 1;

    //定义一个锁对象.
    private Lock lock = new ReentrantLock();
    //获取锁上的Condition对象;为了解决本方唤醒对方的问题,可以一个锁上创建两个监视器对象.
    private Condition produce = lock.newCondition();//生产者监视器对象
    private Condition consume = lock.newCondition();//消费者监视器对象

    //定义标记
    private boolean flag = false;

    //1.提供设置的方法。
    public void set(String name)  {
        //获取锁
        lock.lock();
        try {

            /*if*/
            while (flag)   //多生产多消费,if改为while判断标记
                try {
                    produce.await();
                } catch (InterruptedException e) {
                }
            this.name = name + count;
            count++;

            //打印生产了哪个商品
            System.out.println(Thread.currentThread().getName() + "---生产者---" + this.name);

            //将标记改为true
            flag = true;
            //唤醒消费者。
            consume.signal();
        }finally {
            lock.unlock();
        }
    }

    public void out() {
        lock.lock();
        try {
            /*if*/
            while (!flag)
                try {
                    consume.await();
                } catch (InterruptedException e) {
                }

            System.out.println(Thread.currentThread().getName() + "---消费者---" + this.name);
            //将标记改为false
            flag = false;
            //唤醒生产者
            produce.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

//2.描述生产者
class Producer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中。
    Producer(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        while (true){
            r.set("面包");
        }

    }
}

//3.描述消费者
class Consumer implements Runnable{
    private Resource r;
    //消费者一初始化就要有资源，需要将资源传递到构造函数中。
    Consumer(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        while (true){
            r.out();
        }
    }
}


public class ThreadDemo {
    public static void main(String[] args) {
        //1.创建资源对象
        Resource r = new Resource();

        //2.创建线程任务
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        //3.创建线程
        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();
    }

}