显示条件

显示条件

用法

锁用于解决竞态条件问题，条件是线程间的协作机制。显示锁与synchronized 相对应，而显示条件与wait/notify 相对应。wait/notify与synchronized 配合使用，显示条件与显示锁配合使用。

创建条件变量需要通过显示锁，Lock接口定义了创建方法

Condition  newCondition();

Condition 表示条件变量，是一个接口，它的定义为：

public interface Condition{
   void await() throws InterruptedException;
   
   void awaitUninterruptibly();
   
   long awaitNanos(long nanosTimeout) throws InterruptedException;
   
   boolean await(long time, TimeUnit unit) throws InterruptedException;
   
   boolean awaitUnitl(Date deadline) throws InterruptedException;
   
   void signal();
   
   void signalAll();

}

await 对应于Object的wait，signal对应于notify,signalAll 对应于notifyAll,语义也是一样的。

这些await 方法都是响应中断的，如果发生中断，会抛出InterruptedException,但中断标志位会被清除。

void awaitUninterruptibly(); 它不响应中断的等待方法，该方法不好意由于中断结束，但当它返回时，如果没有锁，会抛出异常IllegalMonitorStateException。

调用await 方法进入等待队列后，会释放锁，释放CPU，当其他线程将它唤醒后，或等待超时后，或发生中断异常后，它都需要重新获取锁，获取后，才会从await 方法中退出。

使用显示条件进行协作的示例：

package com.claa.javabasic.Thread;

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

/**
 * @Author: claa
 * @Date: 2020/04/25 10:06
 * @Description: 使用显示条件进行协作的示例
 */
public class WaitThreadPlus extends  Thread{
    private volatile  boolean fire =false;

    private Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    @Override
    public void run() {
        try {
            lock.lock();

            try {
                while (!fire) {
                    condition.await();
                }

            } finally {
                lock.unlock();
            }
            System.out.println("fired");
        } catch (InterruptedException e) {
            Thread.interrupted();
        }
    }

    public  void fire(){
        lock.lock();
        try{
            this.fire = true;
            condition.signal();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException{
        WaitThreadPlus waitThread = new WaitThreadPlus();

        waitThread.start();

        Thread.sleep(1000);

        System.out.println("fire");

        waitThread.fire();
    }
}

使用显示条件实现的阻塞队列：

定义两个等待条件：不满(notFull)、不空(notEmpty)。在put 方法中，如果队列满，则在notFull 上等待；

在take方法中，如果队列为空，则在notEmpty 上等待。

     private Queue<E> queue = null;

      private int  limit;

      private Lock lock = new ReentrantLock();

      private Condition notFull = lock.newCondition();

      private Condition notEmpty = lock.newCondition();

      public MyBlockingQueuePlus(int limit){
          this.limit = limit;

          queue = new ArrayDeque<>(limit);
      }

      public  void put(E e) throws  InterruptedException{
          lock.lockInterruptibly();

          try{
              while(queue.size() == limit){
                  notFull.await();
              }
              queue.add(e);
              notEmpty.signal();

          }finally {
              lock.unlock();
          }
      }

      public E take() throws InterruptedException{
          lock.lockInterruptibly();;

          try{
              while(queue.isEmpty()){
                  notEmpty.await();
              }

              E e = queue.poll();
              notFull.signal();
              return e;
          }finally {
              lock.unlock();
          }
      }

实现原理

Condition 最终返回的的是ReentrantLock 内部类的sync 的newCondition 方法

public final void await() throws InterruptedException {
    
    // 如果等待前中断标志位已被设置，直接抛出异常
            if (Thread.interrupted())
                throw new InterruptedException();
    //1. 为当前线程创建节点，加入条件等待队列
            Node node = addConditionWaiter();
   // 2.释放持有的锁 
            int savedState = fullyRelease(node);
            int interruptMode = 0;
   //3.放弃cpu，进行等待，直到被中断或isOnSyncQueue 变为true ,isOnSyncQueue 变为true,表示节点被其他线程从条件等待队列移到了外部的锁等待队列，等待的条件已满足
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
    // 4.重新获取锁
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
   // 5.处理中断，抛出异常或设置中断标志位 
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

 public final void signal() {
     // 验证当前线程持有锁
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
     // 唤醒等待队列中第一个线程
     Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

小结

显示条件的用法和实现原理，与显示锁配合使用，与wait/notify 相比，可以支持多个条件队列，代码更为易读，效率更高，使用时注意不要将signal/signalAll 误写成notify/notifyAll。

参考文章

java编程的逻辑基础(马俊昌)