Condition

Condition对于重入锁的作用，相当于object.wait  object.notify 对于synchronized

的作用。也是判断对一个锁是否可操作的条件。

常用接口：

void await() throws InterruptedException;

void awaitUninterruptibly();

long awaitNanos(long nanosTimeout) throws InterruptedException;

boolean await(long time, TimeUnit unit) throws InterruptedException;

boolean awaitUntil(Date deadline) throws InterruptedException;

void signal();

void signalAll();

前面的await方法类似于Object.wait,后面的signal，signalAll类似于Object.notify  notifyAll

 

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

/**
 * @Author:minglu
 * @Description:
 * @Date: 2018/11/26
 */
public class ConditionDemo implements Runnable{
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();
    @Override
    public void run() {
        System.out.println("Thread start!");
        try {
            lock.lock();
            System.out.println("Thread will await!");
            //线程1挂起
            condition.await();
            System.out.println("Thread is running!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if(lock.isHeldByCurrentThread())
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ConditionDemo conditionDemo = new ConditionDemo();
        Thread thread1 = new Thread(conditionDemo);
        thread1.start();
        System.out.println("main Thread will sleep 2000 ms!");
        Thread.sleep(2000);
        //通知线程1继续执行，必须先获取锁，不然会报IllegalMonitorStateException，即当前线程还没锁不能操作。
        lock.lock();
        condition.signal();
        lock.unlock();
        System.out.println("main Thread has signal !");

    }
}

上述例子输出结果：

main Thread will sleep 2000 ms!
Thread start!
Thread will await!
main Thread has signal !
Thread is running!

注意，主线程中准备使用condition.signal之前必须加锁，唤醒后释放锁，不然会报IllegalMonitorStateException，因为

主线程还没拿到锁呢。