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，因爲

主線程還沒拿到鎖呢。