重温java知识（三十九、JUC并发编程之五：线程锁之Conditon）

在JUC中允许用户自己进行锁对象的创建，而此种锁对象可以通过Condition接口进行描述，Condition提供了与Object类中类似的线程控制方法，同时由用户自己来决定使用的锁。例如，在之前使用读/写锁的时候使用的是两个锁，而Condition可以直接创造开发者自己的锁【即可以创建更多的锁来进行控制。】

Condition接口实现的是锁的控制，如果要想获取此接口实例，则可以以靠Lock接口中提供的newCondition()方法完成。

1、Condition基本使用的例子：

package com.mydemo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class JUCDemo {

    public static String msg = null;    // 信息保存

    public static void main(String[] args) {

        // 获取Lock接口实例
        Lock lock = new ReentrantLock();

        // 获得一个写入锁
        Condition condition = lock.newCondition();

        // 获取锁
        lock.lock();

        try {
            new Thread(
                    ()->{
                        // 获取锁
                        lock.lock();

                        try {

                            System.out.println("【Thread-线程处理】" + Thread.currentThread().getName() + "   正在处理数据");

                            // 进行数据处理
                            msg = "test-condition";

                            // 唤醒其他等待线程
                            condition.signal();

                        }catch (Exception e){

                        }finally {
                            lock.unlock();  // 释放锁
                        }
                    }, "数据处理的线程"
            ).start();

            // 主线程等待
            condition.await();

            System.out.println("*******************主线程执行处理，msg = " + msg);
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();  // 释放锁
        }
    }
}

运行结果：
【Thread-线程处理】数据处理的线程   正在处理数据
*******************主线程执行处理，msg = test-condition

Condition强大的地方在于：能够精细的控制多线程的休眠与唤醒。
对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。例如，现在要实现一个多线程并发读、写的缓冲操作，
当项缓冲区写入数据后可以唤醒“读线程”；
当数据从缓冲区读取出来后，可以唤醒“写线程”；
当缓冲区已经写满数据后，则可以将“写线程”设置为等待状态；当缓冲区为空时，可以将“读线程”设置为等待状态。
此类操作如果使用Object类中提供的方法（wait()、notify()、notifyAll()操作）是无法明确地进行“”或“”的，而使用Condition就可以明确地唤醒指定的线程。

2、使用Condition实现数据缓存操作的例子：

package com.mydemo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class JUCDemo {

    public static void main(String[] args) {

        // 实例化数据缓冲区
        DataBuffer dataBuffer = new DataBuffer();

        // 循环创建线程
        for(int i = 0; i < 10; i++){
            // 匿名内部类使用
            final int temData = i;

            new Thread(()->{
                try {
                    Thread.sleep(1);         // 模拟网络延迟
                    dataBuffer.put(temData);        // 保存数据
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "PUT线程-").start();

            new Thread(()->{
                try {
                    Thread.sleep(100);      // 模拟延迟
                    System.out.println("【{" + Thread.currentThread().getName() +
                            "}消费数据】" + dataBuffer.get());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "GET线程-").start();
        }
    }
}

class DataBuffer{

    private static final int MAX_LENGTH = 5;                        // 保存元素最大个
    private Lock lock = new ReentrantLock();                        // 实例化Lock
    private final Condition writeCondition = lock.newCondition();   // 设置写Condition
    private final Condition readCondition = lock.newCondition();    // 设置读Condition
    private final Object data[] = new Object[MAX_LENGTH];           // 数据存储空间
    private int writeIndex = 0;                                     // 数据写索引
    private int readIndex = 0;                                      // 数据读索引
    private int count = 0;                                          // 保存元素个数

    /**
     * 写入数据
     * @param o
     */
    public void put(Object o){
        // 获取锁
        this.lock.lock();

        try {
            // 已达到最大缓存个数
            if(this.count == MAX_LENGTH){
                // 保存线程等待
                this.writeCondition.await();
            }
            // 保存数据，修改指针
            this.data[this.writeIndex++] = o;

            // 已保存上线
            if(this.writeIndex == MAX_LENGTH){
                // 重置保存索引脚标
                this.writeIndex = 0;
            }
            // 修改元素保存个数
            this.count++;

            // 唤醒消费线程
            this.readCondition.signal();

            System.out.println("【写入缓存-put()】" + Thread.currentThread().getName() + "、写入数据：" + o);
        }catch (Exception e){

        }finally {
            // 释放锁
            this.lock.unlock();
        }
    }

    /**
     * 读取数据【消费数据】
     * @return
     */
    public Object get(){
        // 获取锁
        this.lock.lock();

        try {
            // 没有数据
            if(this.count == 0){
                // 消费线程等待
                this.readCondition.await();
            }

            // 取出索引数据
            Object takeData = this.data[this.readIndex++];

            // 数据索引达到上限
            if(this.readIndex == MAX_LENGTH){
                // 重置索引
                this.readIndex = 0;
            }

            // 消费后，保存个数要减去1
            this.count--;

            // 消费后，唤醒保存线程
            this.writeCondition.signal();

            // 返回数据
            return takeData;
        }catch (Exception e){
            return null;
        }finally {
            this.lock.unlock();
        }
    }
}