并发-Java中的锁（四）---LockSupport工具，Condition

LockSupport工具

• 当需要阻塞或唤醒一个线程的时候，都会使用LockSupport工具类来完成相应工作
• 定义了一组公共静态方法，提供了最基本的线程阻塞和唤醒功能
• 定义了一组以park开头的方法用来阻塞当前线程，unpark方法来唤醒一个被阻塞线程
  • void park()：阻塞当前线程，如果调用unpark（Thread thread） 方法或者当前线程被中断，才能从park（）方法返回
  • void parkNanos(long nanos)：阻塞当前线程，最长不超过nanos纳秒，返回条件在park的基础上超时返回
  • void parkUntil(long deadline)：阻塞当前线程，直到deadline时间
  • void unpark(Thread thread)：唤醒处于阻塞状态的线程thread

//不需要在锁块中
    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "----come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + "----被唤醒");
        }, "A");
        a.start();
        Thread b = new Thread(() -> {
            LockSupport.unpark(a);
            System.out.println(Thread.currentThread().getName() + "\t" + "----唤醒动作");
        }, "B");
        b.start();
    }

Condition接口

• 任意一个java对象都拥有一组监视器方法，包括wait()，wait(long timeout),notify(),notifyAll(),这些方法与synchronized关键字配合实现等待/通知模式
• Condition接口提供了类似object监视器方法，与lock配合可以实现等待/通知模式

Condition接口示例

• Condition依赖lock对象创建出来，Condition定义了等待通知两种类型方法，线程调用这些方法时，需要提前获取到Condition对象关联的锁

• 调用await方法，当前线程会释放锁并在此等待，其他线程调用Condition对象的signal方法，通知当前线程后，当前线程从await方法返回，并在返回之前已经获取了锁

• import java.util.concurrent.locks.Condition;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  
  public class ConditionUseCase {
      Lock lock = new ReentrantLock();
      Condition condition = lock.newCondition();
  
      public void conditionWait() throws InterruptedException{
          lock.lock();
          try {
              condition.await();
          }finally {
              lock.unlock();
          }
      }
      public void conditionSignal() throws InterruptedException{
          lock.lock();
          try {
              condition.signal();
          }finally {
              lock.unlock();
          }
      }
  }
  

condition定义的部分方法

• void await（）：当前线程进入等待状态直到被通知signal或中断，当前线程将进入运行状态且从await方法返回的情况包括：其他线程调用该condition的signal或signalAll方法，而当前线程被选中唤醒

  • 其他线程调用interrupt方法中断当前线程

  • 如果当前等待线程从await方法返回，那么表明该线程已经获取了condition对象锁对应的锁

  • void awaitUninterruptibly：当前线程进入等待状态直到被通知，该方法对中断不敏感

  • long awaitNanos（long nanosTimeout）：当前线程进入等待状态直到被通知，中断，或者超时，返回值表示剩余时间。如果在nanosTimeout纳秒之前被唤醒，那么返回值就是实际耗时，如果返回值是0或者负数，那么可以认定已经超时

  • boolean awaitUntil（Date deadline）当前线程进入等待状态直到被通知，中断或到某个时间，如果没有到指定时间就被通知，方法返回true，否则，表示到了指定时间，方法返回false

  • void signal（）唤醒一个等待在condition上的线程，该线程从等待方法返回前必须获得与condition相关联的锁

  • void signalAl()l 唤醒所有等待在condition上的线程，该线程从等待方法返回的线程必须获得与condition相关联的锁

  • 示例：通过有界队列了解Condition使用方式，有界队列是一种特殊的队列，当队列为空时，队列的获取操作将会阻塞获取线程，直到队列中有新增元素，当队列已满时，队列的插入操作将会在阻塞插入线程，直到队列出现空位。

    • 首先获取锁，保证数组修改的可见性和排他性。
    • 当数组数量等于数组长度时，表示数组已满，则调用notFull.await(),当前线程随之释放锁并进入等待状态
    • 如果数组数量不等于数组长度，表示数组未满，则添加元素到数组中，同时通知等待在notEmpty上的线程，数组中已经有新元素可以获取
    • 在添加和删除方法中使用while循环而非if判断，目的是防止过早或意外通知，只有条件符合才能退出循环

  • public class BoundedQueue {
    
        private Object[] items;
        //添加的下标，删除的下标和数组当前的数量
        private int addIndex,removeIndex,count;
        private Lock lock = new ReentrantLock();
        private Condition notEmpty = lock.newCondition();
        private Condition notFull = lock.newCondition();
        public BoundedQueue(int size){
            items = new Object[size];
        }
        //添加一个元素，如果数组满，则添加线程进入等待状态，直到有空位
        public void add(T t) throws InterruptedException{
            lock.lock();
            try {
                while (count == items.length){
                    notFull.await();
                }
                items[addIndex] = t;
                if (++addIndex == items.length){
                    addIndex = 0;
                }
                ++count;
                notEmpty.signal();
            }finally {
                lock.unlock();
            }
        }
        //由于头部删除一个元素，如果数组为空，则删除线程进入等待状态，直到有新添加元素
        @SuppressWarnings("unchecked")
        public T remove() throws InterruptedException{
            lock.lock();
            try {
                while (count == 0){
                    notEmpty.await();
                }
                Object x = items[removeIndex];
                if(++removeIndex == items.length){
                    removeIndex = 0;
                }
                --count;
                notFull.signal();
                return (T)x;
            }finally {
                lock.unlock();
            }
        }
    
    }
    

condition实现分析

每个condition对象包含一个队列（等待队列），该队列是condition对象实现等待/通知功能的关键。

• 等待队列
  • 一个FIFO队列，condition拥有首节点和尾节点
  • 当前线程调用Condition.await（）方法，该线程释放锁，将会以当前线程构造节点，并将节点从尾部加入等待队列。
  • 调用await方法的线程必定是获取了锁的线程，即该过程是由锁来保证线程安全的。
• 等待
  • 调用await方法，会使当前线程进入等待队列并释放锁，同时线程状态变成等待状态。
  • 从队列的角度看：调用await方法相当于同步队列的首节点（获取了锁的节点）移动到condition等待队列中
  • 当等待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态，如果不是通过其他线程调用condition.signal方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException
• 通知
  • 调用signal方法将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中。
  • 当前线程必须是获取了锁的线程，然后获取等待队列的首节点，将其移动到同步队列并使用LockSupport唤醒节点中的线程
  • 调用同步器的enq（Node node）方法，等待队列中的头节点线程安全地移动到同步队列。当节点移动到同步队列后，当前线程在使用LockSupport唤醒该节点的线程
  • 被唤醒后的线程，将从await方法中的while循环中退出（isOnSyncQueue(Node node)）方法返回true，节点已经在同步队列中，进而调用同步器的acquireQueued方法加入到获取同步状态的竞争中。
  • 成功获取同步状态（锁）之后，被唤醒的线程将从先前调用的await方法返回，此时线程已经成功获取了锁
  • signalAll方法相当于对等待队列中的每个节点均执行一次signal方法，效果就是将等待队列中所有节点全部移动到同步队列中，并唤醒每个节点的线程。