多线程中Condition的用法

多线程中Condition的用法与Object中wait、notify、notifyAll用法非常的相似
Condition与Lock对象搭配完成等待唤醒机制
首先我们需要创建Condition对象

newCondition();//返回Condition实例

首先我们知道wait、notify使用前提是通过synchronized获取锁对象，而Condition对象也需要在使用前获取锁。此时获取锁是通过Lock的lock()方法获取锁。

Condition能够支持不响应中断，而通过使用Object方式不支持
Condition能够支持多个等待队列（new 多个Condition对象），而Object方式只能支持一个
Condition能够支持超时时间的设置，而Object不支持 

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

public class Test {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition =lock.newCondition();
        T1 t1 = new T1("线程1",lock,condition);
        t1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        T2 t2 = new T2("线程2",lock,condition);
        t2.start();
    }
}
class T1 extends Thread{
    ReentrantLock lock;
    Condition condition;
    public T1(String name,ReentrantLock lock,Condition condition){
        super(name);
        this.lock = lock;
        this.condition = condition;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"尝试获取锁");
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"成功获取锁,进入休眠");
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
           lock.unlock();
        }
        System.out.println(Thread.currentThread().getName()+"成功释放锁");
    }
}

class T2 extends Thread{
    ReentrantLock lock;
    Condition condition;
    public T2(String name,ReentrantLock lock,Condition condition){
        super(name);
        this.lock = lock;
        this.condition = condition;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"尝试获取锁");
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"成功获取锁");
            condition.signal();
            System.out.println(Thread.currentThread().getName()+"准备唤醒锁");
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        } finally{
            System.out.println(Thread.currentThread().getName()+"成功唤醒锁");
            lock.unlock();

        }
    }
}

带参数的方法在超时后会继续进行！
await(long time, TimeUnit unit) 超时之后自动返回
1.超时后自动返回false
2.超时前被唤醒返回true

一个锁支持多个Condition

模拟生产者消费者的问题

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

public class LockQueueDemo {
    ReentrantLock lock = new ReentrantLock();
    LinkedList list = new LinkedList();
    Condition condition1 = lock.newCondition();//生产者条件
    Condition condition2 = lock.newCondition();//消费者条件

    //定义一个方法用于生产者
    public void shengChan(){
        lock.lock();
        try{
            while(list.size() == 1){
                //此时生产者开始等待
                condition1.await();
            }
            System.out.println("生产者开始生产");
            list.add("商品1");
            System.out.println("已经生产好了，可以消费");
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
public void xiaoFei(){
    lock.lock();
    try{
        while(list.size() == 0){
            //消费者开始等待
            condition2.await();
        }
        System.out.println("消费者开始消费");
        list.removeFirst();
        System.out.println("消费完毕，请开始生产");
        condition1.signal();
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        lock.unlock();
    }
}


    public static void main(String[] args) {
        LockQueueDemo lockQueueDemo = new LockQueueDemo();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lockQueueDemo.shengChan();
                }
            }).start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lockQueueDemo.xiaoFei();
                }
            }).start();
        }
}
}

Condition中等待唤醒机制和Object对象中的等待唤醒机制十分的相似，可以类比使用。