并发编程之Condition -- 08

妖狐艹你老母 2022-03-25 07:08 278阅读 0赞

### 文章目录 ###

*   *   *   *  1.Condition使用案例
             *  2.Condition.wait 方法
             *  3.Condition.signal 方法
             *  4.总结

任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括wait()、notify()以及notifyAll()方法，这些方法与synchronized同步关键字配合，可以实现等待/通知模式JUC包提供了Condition来对锁进行精准控制，Condition提供了类似Object的监视器方法，和Lock配合可以实现等待和通知模式,让某些线程一起等待某个条件（condition），只有满足条件时，线程才会被唤醒。

Condition是通过Lock类的newCondition方法建立的

#### 1.Condition使用案例 ####

**ConditionWait**

public class ConditionWait implements  Runnable{ 
      private Lock lock;
      private Condition condition;
      public ConditionWait(Lock lock, Condition condition){ 
        this.lock=lock;
        this.condition=condition;
      }
      @Override
      public void run() { 
        System.out.println("begin -ConditionDemoWait");
        try { 
          lock.lock();
          condition.await();
          System.out.println("end - ConditionDemoWait");
        } catch (InterruptedException e) { 
          e.printStackTrace();
        }finally { 
          lock.unlock();
        }
      }
    }

**ConditionSignal**

public class ConditionSignal implements  Runnable{ 
      private Lock lock;
      private Condition condition;
      public ConditionSignal(Lock lock, Condition condition){ 
        this.lock=lock;
        this.condition=condition;
      }
      @Override
      public void run() { 
        System.out.println("begin -ConditionDemoSignal");
        try { 
          lock.lock();
          condition.signal();
          System.out.println("end - ConditionDemoSignal");
        }finally { 
        lock.unlock();
        }
      }
    }

测试类

public class Test { 
    
    	public static void main(String[] args) throws InterruptedException { 
    		Lock lock = new ReentrantLock();
    		Condition condition = lock.newCondition();
    		Thread signal = new  Thread(new ConditionSignal(Lock,conditon) )
    		Thread wait= new  Thread(new ConditionWait(Lock,conditon) )
    		sinal.start();
    		wait.start();//这样就可以达到synchronized，notify,wait达到相同的效果
    	}
    
    }

通过这个案例简单实现了wait和notify的功能，当调用await方法后，当前线程会释放锁并等待，而其他线程调用condition对象的signal或者signalAll方法通知并被阻塞的线程，然后自己执行unlock释放锁，被唤醒的线程获得之前的锁继续执行，最后释放锁。  
所以，condition中两个最重要的方法，一个是await，一个是signal方法

*  await:把当前线程阻塞挂起
 *  signal:唤醒阻塞的线程

#### 2.Condition.wait 方法 ####

调用Condition的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从await()方法返回时，当前线程一定获取了Condition相关联的锁

public final void await() throws InterruptedException { 
       if (Thread.interrupted())
       		 throw new InterruptedException();
       		 
       Node node = addConditionWaiter(); //创建一个新的节点，节点状态为condition，采用的数据结构仍然是链表
       int savedState = fullyRelease(node); //释放当前的锁，得到锁的状态，并唤醒AQS队列中的一个线程
       int interruptMode = 0;
       
      	//如果当前节点没有在同步队列上，即还没有被signal，则将当前线程阻塞
    	//isOnSyncQueue 判断当前 node 状态,如果是 CONDITION 状态,或者不在队列上了,就继续阻塞,还在队列上且不是 CONDITION 状态了,就结束循环和阻塞
    	while (!isOnSyncQueue(node)) { //第一次判断的是false，因为前面已经释放锁了
        	LockSupport.park(this); // 第一次总是 park 自己,开始阻塞等待
    		// 线程判断自己在等待过程中是否被中断了,如果没有中断,则再次循环,会在 isOnSyncQueue 中判断自己是否在队列上.
       		if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
          	break;
        }
        
    	// 当这个线程醒来,会尝试拿锁, 当 acquireQueued 返回 false 就是拿到锁了.
        // interruptMode != THROW_IE -> 表示这个线程没有成功将 node 入队,但 signal 执行了 enq 方法让其入队了.
    	// 将这个变量设置成 REINTERRUPT.
       if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
       		 interruptMode = REINTERRUPT;
    	// 如果 node 的下一个等待者不是 null, 则进行清理,清理 Condition 队列上的节点.
    
    	// 如果是 null ,就没有什么好清理的了.
       if (node.nextWaiter != null) // clean up if cancelled 
    		unlinkCancelledWaiters();
    		
    	// 如果线程被中断了,需要抛出异常.或者什么都不做
       if (interruptMode != 0)
       	   reportInterruptAfterWait(interruptMode);
    }

#### 3.Condition.signal 方法 ####

调用Condition的signal()方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中

public final void signal() { 
      if (!isHeldExclusively()) //先判断当前线程是否获得了锁
        throw new IllegalMonitorStateException();
      Node first = firstWaiter; // 拿到 Condition 队列上第一个节点
      if (first != null)
        doSignal(first);
    }

private void doSignal(Node first) { 
      do { 
        if ( (firstWaiter = first.nextWaiter) == null)// 如果第一个节点的下一个节点是 null,那么, 最后一个节点也是 null.
          lastWaiter = null; // 将 next 节点设置成 null
        first.nextWaiter = null;
     } while (!transferForSignal(first) &&
          (first = firstWaiter) != null);
    }

该方法先是 CAS 修改了节点状态，如果成功，就将这个节点放到 AQS 队列中，然后唤醒这个节点上的线程。此时，那个节点就会在 await 方法中苏醒

final boolean transferForSignal(Node node) { 
      if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
      Node p = enq(node);
      int ws = p.waitStatus;
    	// 如果上一个节点的状态被取消了, 或者尝试设置上一个节点的状态为 SIGNAL 失败了(SIGNAL 表示: 他的next 节点需要停止阻塞),
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread); // 唤醒输入节点上的线程.
      return true;
    }

#### 4.总结 ####

使用Condition的话,这里相当于出现了两个队列，一个是AQS中争抢锁的一个队列，另外一个是等待队列。

**wait方法过程**：  
 如果线程A先获取的了锁，然后执行到了condition.wait方法时，此时就会把当前线程添加到等待队列中，然后释放当前所持有的锁，让其他线程获取锁，LockSupport.park方法，使当前队列处于睡眠状态。

**signal方法过程：**  
 此时另外一个线程B获取到了锁，然后执行到了condition.singal方法时，此时会去等待队列中把第一个等待队列的节点添加到AQS队列上，然后使用LockSupport.unpark唤醒当前这个新加到AQS的节点。后续这个加到AQS队列的节点会按照FIFO再获取锁。

实际上这里的Lock,Condition线程通信和 sysnchronize notify, wait再JVM层面的原理一模一样，都是通过两个队列实现。