线程协作与并发流程控制&AQS

什么是控制并发流程

控制并发流程的工具类,作用就是帮助我们更容易地让线程之间合作,让线程之间相互配合,来满足业务逻辑。比如让线程A等待线程B执行完后再执行等合作策略。

控制并发流程的工具类:

  • Semaphore

    信号量,可以通过控制“许可证”的数量,来保证线程之间的配合。

    线程只有在拿到“许可证”后才能继续运行。相比于其他的同步器,更加灵活。

  • CyclicBarrier

    线程会等待,直到足够多线程达到了事先规定的数目。一旦达到了触发条件,就可以进行下一步的动作。

    适用于线程之间相互等待处理结果就绪的场景。

  • Phaser

    和CyclicBarrier类似,但是计数可变。

    Java7加入的。

  • CountDownLatch

    和CyclicBarrier类似,数量递减到0时,触发动作。

    不可重复使用。

  • Exchanger

    让两个线程再合适时交换对象。

    适用场景:当两个线程工作在同一个类的不同实例上时,用于交换数据。

  • Condition

    可以控制线程“等待”和“唤醒”。

    是Object.wait()的升级版。

 

CountDownLatch倒计时门闩

  • 作用

    并发流程控制工具,倒数门闩,“拼团购物,人满发货”。倒数结束之前,一直处于等待状态,直到倒计时结束了,次线程才继续工作。

  • 两种典型用法

    CountDownLatch(int count)是仅有的一个的构造函数,参数count为需要倒数的数值。

    调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行。

    countDown()方法将count值减1,直到为0时,等待的线程会被唤醒。

    用法一:一个线程等待多个线程都执行完毕,再继续自己的工作。一等多

    用法二:多个线程等待某一个线程的信号,同时开始执行。多等一

    扩展用法:多个线程等多个线程执行完后,再同时执行。多等多

    注意点:CountDownLatch是不能重用的,如果需要重新计数,可以考虑使用CyclicBarrier或者创建新的CountDownLatch实例。

     

Semaphore信号量

模拟了操作系统中的信号量功能,可以用来限制或者管理数量有限的资源的使用情况。信号量的作用是维护一个“许可证”的计数,线程可以“获取”许可证,那信号量剩余的许可证就减一,线程也可以“释放”一个许可证,那信号量剩余的许可证就加一,当信号量所拥有的许可证数量为0,那么下一个还想获取许可证的线程就需要等待,直到另外的线程释放了许可证。

  • 使用流程:

    1. 初始化Semaphore并指定许可证数量。

    2. 在需要前在代码前加acquire()或者acquireUninterrptibly()方法。

    3. 任务结束后,调用release()来释放许可证。

  • 主要方法:

    • new Semaphore(int permit,boolean fair):这里设置是否使用公平策略,如果传入true,那么Semaphore会把之前等待的线程放入FIFO的队列里,以便当有了新的许可证,可以分发给之前等了最长时间的线程。

    • acquire():可以响应中断的获取。可以传入参数表示获取多少许可证,但是也要记得归还

    • acquireUninterrptibly():不能响应中断的获取。

    • tryAcquire():看看现在有没有空闲的许可证返回布尔值,如果有就去获取,如果没有也没关系,不必陷入阻塞,可以去做其它的事情。

    • tryAcquire(timeout):和tryAcquire()一样,但是多了一个超时时间。

    • release():不能忘记归还许可证,可以传入参数。

  • 特殊用法

    • 一次获取或者释放多个许可证

      比如TaskA会调用很消耗资源的method1(),而TaskB调用的是不太消耗资源的额method2(),假设我们一共有5个许可证。那么我们就可以要求TaskA获取5个许可证才能执行,而TaskB只需要获取一个许可证就能执行,这样就避免了A和B同时运行的情况,可以根据自己的需求合理分配资源

  • 注意点

    • 获取释放的许可证数量必须一致,否则比如每次都获取2个但是只释放1个甚至不释放,随着时间的推移,到最后许可证书数量不够用,会导致程序卡死。虽然信号量并不对是否和获取的数量做规定,但是这是编程规范,否则容易出错。

    • 注意在初始化Semaphore的时候设置公平性,一般设置为true会更合理。

    • 并不是必须由获取许可证的线程释放那个许可证,事实上,获取和释放许可证对线程并无要求,也许是A获取了,然后由B释放,只要逻辑合理即可。可以跨线程、跨线程池

    • 信号量的作用,除了控制临界区最多同时有N个线程访问以外,另一个作用是可以实现“条件等待”,例如线程1需要在线程2完成准备工作后才能开始工作,那么线程1acquire(),而线程2完成任务后release(),这样的话,相当于是轻量级的CountdownLatch

 

Condition接口(条件对象)

  • 作用

    当线程1需要等待某个条件的时候,就去执行condition.await()方法,一旦执行了await()方法,线程就进入阻塞状态。

    然后通常会有另外一个线程,假设是线程2,去执行响应的条件,直到这个条件达成的时候,线程2就会去执行condition.signal()方法,这时JVM就会从阻塞的线程中找,找到那些等待该condition的线程,当线程1收到可执行信号的时候,它的线程状态会变成Runable可执行状态。

    signalAll()和signal()的区别:

    signalAll()会唤醒所有正在等待的线程。

    signal()是公平的,只会唤醒那个等待时间最长的线程。

  • 使用

    • 普通用法

    • 使用Condition实现生产者消费者模式

      public class ConditionDemo {

         private int queueSize = 10;
         private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
         private Lock lock = new ReentrantLock();
         private Condition notFull = lock.newCondition();
         private Condition notEmpty = lock.newCondition();

         public static void main(String[] args) {
             ConditionDemo2 conditionDemo2 = new ConditionDemo2();
             Producer producer = conditionDemo2.new Producer();
             Consumer consumer = conditionDemo2.new Consumer();
             producer.start();
             consumer.start();
        }

         class Consumer extends Thread {

             @Override
             public void run() {
                 consume();
            }

             private void consume() {
                 while (true) {
                     lock.lock();
                     try {
                         while (queue.size() == 0) {
                             System.out.println("队列空,等待数据");
                             try {
                                 notEmpty.await();
                            } catch (InterruptedException e) {
                                 e.printStackTrace();
                            }
                        }
                         queue.poll();
                         notFull.signalAll();
                         System.out.println("从队列里取走了一个数据,队列剩余" + queue.size() + "个元素");
                    } finally {
                         lock.unlock();
                    }
                }
            }
        }

         class Producer extends Thread {

             @Override
             public void run() {
                 produce();
            }

             private void produce() {
                 while (true) {
                     lock.lock();
                     try {
                         while (queue.size() == queueSize) {
                             System.out.println("队列满,等待有空余");
                             try {
                                 notFull.await();
                            } catch (InterruptedException e) {
                                 e.printStackTrace();
                            }
                        }
                         queue.offer(1);
                         notEmpty.signalAll();
                         System.out.println("向队列插入了一个元素,队列剩余空间" + (queueSize - queue.size()));
                    } finally {
                         lock.unlock();
                    }
                }
            }
        }

      }
  • 注意点

    实际上,如果说Lock用来代替synchronized,那么Condition就是用来代替相对应的Object.wait/notify的,所以在用法和性质上,几乎都一样。

    await方法会自动释放持有的Lock锁,和Object.wait一样,不需要手动去释放锁。

    调用await的时候,必须持有锁,否则会抛出异常,和Object.wait一样。

 

CyclicBarrier循环栅栏

  • CyclicBarrier循环栅栏和CountdownLatch很类似,都能阻塞一组线程。

    当有大量线程相互配合,分别计算不同任务,并且需要最后统一汇总的时候,可以使用CyclicBarrier。CyclicBarrier可以构造一个集结点,当某个线程执行完毕以后,它就会到集结点等待,直到所有线程都到了集结点,那么该栅栏就被撤销,所有线程再统一出发,继续执行剩下的任务。

  • CyclicBarrier和CountdownLatch的区别

    作用不同:CyclicBarrier要等固定数量的线程都到达了栅栏位置才能继续执行,而CountdownLatch只需要等待数字到0,也就是CountdownLatch用于事件,而CyclicBarrier是用于线程的。

    可重用性不同:CountdownLatch在倒数到0并出发门闩打开后就不能重复使用了,除非是创建新的实例;而CyclicBarrier就可以重复使用。

AQS

 

关于AQS

AQS在并发包当中的应用非常多,设计思路很巧妙,是非常值得探究和总结的一个知识点。

 

为什么需要AQS

  • 锁和协作类的共同点:闸门。比如ReentrantLock和Semaphore就有很多的相似点,例如lock&acquire、tryLock&tryAcquire,支持中断与不支持中断的方法等等。不仅是ReentrantLock和Semaphore,包括CountDownLatch、ReentrantReadWriteLock都有这样的类似的协作(或者说是同步)功能,其实他们底层都是用了一个共同的基类,这就是AQS

  • 因为那些协作类有很多工作都是类似的,所以如果能够提取出一个工具类,那么就可以直接用,对于ReentrantLock和Semaphore而言就可以屏蔽很多细节,只关注它们自己的“业务逻辑”就可以了。

  • 和AQS的关系

    Semaphore内部有一个Sync类,Sync类继承了AQS;

    CountDownLatch也是一样的;

    等等,很多,只要利用了AQS,都是类似形式。

 

AQS的作用

  • 比喻:面试过程中无论群面还是单面,安排就坐、叫好、先来后到等HR的工作就是AQS做的工作,面试官不会关心两个面试者是不是号码相互冲突了,也不会去管面试者是否需要一个地方坐着休息,这些都是交给HR去做了。

    Semaphore:单面,一个人面完了,后一个人才能进来继续面试。CountDownLatch:群面,等待10人到齐。Semaphore、CountDownLatch等同步工具类,要做的就是写下自己“要人”的规则,比如是“出一个,进一个”,或者说是“凑齐10人,一起面试”。剩下的招呼面试者的杂活交给AQS来做。

  • 如果没有AQS

    • 就需要每个协作工具自己实现:同步状态的原子性管理、线程的阻塞与接触阻塞、队列的管理。

    • 在并发场景下,自己正确且高效地实现这些内容,都是相当有难度的,所以我们使用AQS来帮助搞定这些杂活,而使用的时候只用关注业务逻辑就行了。

  • 总结:

    AQS是一个用于构建锁、同步器、协作工具类的工具类(框架)。有了AQS以后,更多的协作工具,都可以很方便地被写出来。因为AQS解决了大量的细节问题,比如等待线程用先进先出的队列操作,以及一些标准来判断这些线程是等待还是不应等待,以及处理一些竞争问题,解决开销提高吞吐量等等。AQS的设计充分考虑了这些使用场景以及性能问题,所以使用AQS的并发工具类也同时拥有了这些优势。

    有了AQS,构建线程协作类就容易多了。

 

AQS的重要性以及地位

AbstractQueuedSynchronizer是Doug Lea写的,从JDK1.5加入的一个基于FIFO等待队列实现的一个用于实现同步器的基础框架。

 

AQS内部原理解析

  • AQS最核心的三个部分:

    • state

      state的具体含义,会根据具体实现类的不同而不同,比如在Semaphore里,它表示“剩余的许可证数量”,而在CountDownLatch里,它表示“还需要倒数的数量”。

      state是volatile修饰的,会被并发修改,所以修改state的方法都需要保证线程安全,比如getState、setState以及compareAndSetState操作来读取和更新这个状态。这些方法都依赖于juc.atomic包的支持。

    • 控制线程抢锁和配合的FIFO队列

      这个队列用来存放"等待的线程”, AQS就是 "排队管理器”,当多个线程争用同一把锁时,必须有排队机制将那些没能拿到锁的线程串在一起。当锁释放时,锁管理器就会挑选个合适的线程来占有这个刚刚释放的锁。

      AQS会维护一个等待的线程队列,把线程都放到这个队列里,这是一个双向形式的队列

    • 期望协作工具类去实现的获取/释放等重要方法

      这里的获取和释放方法,是利用AQS的协作工具类里最重要的方法,是由协作类自己去实现的,并且含义各不相同。

      获取方法:获取操作会依赖state变量,经常会阻塞(比如获取不到锁的时候)。在Semaphore中 ,获取就是acquire方法,作用是获取一个许可证;而在CountDownLatch里面, 获取就是await方法,作用是“等待,直到倒数结束”。

      释放方法:释放操作不会阻塞。在Semaphore中,释放就是release方法,作用是释放一个许可证。CountDownLatch里面,释放就是countDown方法,作用是“倒数1个数”。

       

应用实例、源码解析

  • AQS用法

    第一步:写一个类,想好协作的逻辑,实现获取/释放方法。

    第二步:内部写一个Sync类继承AbstractQueuedSynchronizer

    第三步:根据是否独占来重写tryAcquire/tryRelease或者tryAcquireShared (int acquires)和tryReleaseShared(intreleases)等方法,在之前写的获取/释放方法中调用AQS的acquire/release或者Shared方法。

  • AQS在CountDownLatch的应用

    • 构造函数

    • getCount

    • countDown

    • await

    //java10
    public class CountDownLatch {
       //构造方法
       public CountDownLatch(int count) {
           if (count < 0) throw new IllegalArgumentException("count < 0");
           //创建Sync实例
           this.sync = new Sync(count);
      }
       
       //间接调用sync.getCount()方法
       //最终得到的是state的值
       public long getCount() {
           return sync.getCount();
      }
       
       //AQS的releaseShared当中会去调用Sync的tryReleaseShared方法,CAS减少state的数值
       //一旦state为0,tryReleaseShared会返回true
       //根据这个条件的成立,如唤醒队列当中的线程。
       public void countDown() {
           sync.releaseShared(1);
      }
       
       //await会去调用AQS的acquireSharedInterruptibly方法,进而调用Sync的tryAcquireShared方法,
       //只要state数值减少到0了已经,tryAcquireShared方法就会返回1,如果state是其他值就返回-1
       //所以如果state不为0,就进入队列,进入阻塞状态
       //state为0,就正常获得锁,而不需要等待了
       public void await() throws InterruptedException {
           sync.acquireSharedInterruptibly(1);
      }
       
       /**
        * Synchronization control For CountDownLatch.
        * Uses AQS state to represent count.
        */
       private static final class Sync extends AbstractQueuedSynchronizer {
           private static final long serialVersionUID = 4982264981922014374L;

           Sync(int count) {
               //设置state值
               setState(count);
          }

           int getCount() {
               return getState();
          }
           
           public void await() throws InterruptedException {
           sync.acquireSharedInterruptibly(1);
      }
           public void countDown() {
           sync.releaseShared(1);
      }

           protected int tryAcquireShared(int acquires) {
               return (getState() == 0) ? 1 : -1;
          }

           protected boolean tryReleaseShared(int releases) {
               // Decrement count; signal when transition to zero
               //这里用一个循环在做CAS的自旋
               for (;;) {
                   int c = getState();
                   if (c == 0)
                       return false;
                   int nextc = c - 1;
                   if (compareAndSetState(c, nextc))
                       return nextc == 0;
              }
          }
      }
       
       //省略。。。
    }


    public abstract class AbstractQueuedSynchronizer
       extends AbstractOwnableSynchronizer
       implements java.io.Serializable {
       
       protected final int getState() {
           return state;
      }
     
       
       public final void acquireSharedInterruptibly(int arg)
               throws InterruptedException {
           if (Thread.interrupted())
               throw new InterruptedException();
           //tryAcquireShared在sync当中实现了
           if (tryAcquireShared(arg) < 0)
               //让当前线程进入等待队列,并且阻塞
               doAcquireSharedInterruptibly(arg);
           //如果不小于0就是正常获得锁,不需要等待了。
      }
       
       private void doAcquireSharedInterruptibly(int arg)
           throws InterruptedException {
           //首先把当前线程包装成一个Node结点
           final Node node = addWaiter(Node.SHARED);
           try {
               for (;;) {
                   final Node p = node.predecessor();
                   if (p == head) {
                       int r = tryAcquireShared(arg);
                       if (r >= 0) {
                           setHeadAndPropagate(node, r);
                           p.next = null; // help GC
                           return;
                      }
                  }
                   //阻塞是在这里做的
                   //parkAndCheckInterrupt
                   if (shouldParkAfterFailedAcquire(p, node) &&
                       parkAndCheckInterrupt())
                       throw new InterruptedException();
              }
          } catch (Throwable t) {
               cancelAcquire(node);
               throw t;
          }
      }
       
       private final boolean parkAndCheckInterrupt() {
           //最终会调用Usafe的park方法
           //就是把当前线程挂起
           LockSupport.park(this);
           return Thread.interrupted();
      }
       
       public final boolean releaseShared(int arg) {
           //tryReleaseShared在Sync中实现了
           if (tryReleaseShared(arg)) {
               //这个方法在tryReleaseShared返回true的情况下会把阻塞的线程全部唤醒,也就是count从1减到0的时候闸门打开
               doReleaseShared();
               return true;
          }
           return false;
      }
       

       
       //省略。。。
    }
    • AQS在CountDownLatch的总结

      调用CountDownLatch的await方法时,便会尝试获取"共享锁”,不过一开始是获取不到该锁的,于是线程被阻塞。而“共享锁”可获取到的条件,就是"锁计数器”的值为0。而"锁计数器”的初始值为count ,每当一个线程调用该CountDownLatch对象的countDown()方法时,才将"锁计数器”-1。 count个线程调用countDown()之后,“锁计数器”才为0,而前面提到的等待获取共享锁的线程才能继续运行。

  • AQS在Semaphore的应用

    在Semaphore中,state表示许可证的剩余数量。

    看tryAcquire方法 ,判断nonfairTryAcquireShared大于等于 0的话,代表成功。这里会先检查剩余许可证数量够不够这次需要的 ,用减法来计算,如果直接不够,那就返回负数,表示失败;如果够了,就用自旋加compareAndSetState来改变state状态,直到改变成功就返回正数;或者是期间如果被其他人修改了导致剩余数量不够了, 那也返回负数代表获取失败。

    //java10
    public class Semaphore implements java.io.Serializable {
       
       public void acquire(int permits) throws InterruptedException {
           if (permits < 0) throw new IllegalArgumentException();
           sync.acquireSharedInterruptibly(permits);
      }
       
       //Sync
       abstract static class Sync extends AbstractQueuedSynchronizer {
           private static final long serialVersionUID = 1192457210091910933L;

           Sync(int permits) {
               setState(permits);
          }

           final int getPermits() {
               return getState();
          }

           final int nonfairTryAcquireShared(int acquires) {
               for (;;) {
                   int available = getState();
                   int remaining = available - acquires;
                   if (remaining < 0 ||
                       compareAndSetState(available, remaining))
                       return remaining;
              }
          }

           protected final boolean tryReleaseShared(int releases) {
               for (;;) {
                   int current = getState();
                   int next = current + releases;
                   if (next < current) // overflow
                       throw new Error("Maximum permit count exceeded");
                   if (compareAndSetState(current, next))
                       return true;
              }
          }

           final void reducePermits(int reductions) {
               for (;;) {
                   int current = getState();
                   int next = current - reductions;
                   if (next > current) // underflow
                       throw new Error("Permit count underflow");
                   if (compareAndSetState(current, next))
                       return;
              }
          }

           final int drainPermits() {
               for (;;) {
                   int current = getState();
                   if (current == 0 || compareAndSetState(current, 0))
                       return current;
              }
          }
      }
       
       
       //非公平
       static final class NonfairSync extends Sync {
           private static final long serialVersionUID = -2694183684443567898L;

           NonfairSync(int permits) {
               super(permits);
          }

           protected int tryAcquireShared(int acquires) {
               return nonfairTryAcquireShared(acquires);
               //nonfairTryAcquireShared在Sync当中
          }
      }
       
       //省略。。。
    }


    public abstract class AbstractQueuedSynchronizer
       extends AbstractOwnableSynchronizer
       implements java.io.Serializable {
       
       public final void acquireSharedInterruptibly(int arg)
               throws InterruptedException {
           if (Thread.interrupted())
               throw new InterruptedException();
           //tryAcquireShared在Semaphore中根据公平不公平有两种实现
           if (tryAcquireShared(arg) < 0)
               //放入等待队列
               doAcquireSharedInterruptibly(arg);
      }
       
       //省略。。。
    }
  • AQS在ReentrantLock的应用

    分析释放锁的方法tryRelease:由于是可重入的,所以state代表重入的次数,每次释放锁,先判断是不是当前持有锁的线程释放的,如果不是就抛异常;如果是的话,重入次数就减一。如果减到了0 ,就说明完全释放了,于是free就是true,并且把state设置为0。

    加锁的方法:回去判断当前state是不是等于0,也会去判断当前线程是不是持有锁的线程,如果都不是,代表目前拿不到这把锁,就放到队列中去,并在以后合适的时机唤醒。

    public class ReentrantLock implements Lock, java.io.Serializable {
       abstract static class Sync extends AbstractQueuedSynchronizer {
           private static final long serialVersionUID = -5179523762034025860L;
           
           //释放锁
           public void unlock() {
           sync.release(1);//调用AQS的release方法
      }
           
           //加锁
           public void lock() {
           sync.acquire(1);
      }

           /**
            * Performs non-fair tryLock. tryAcquire is implemented in
            * subclasses, but both need nonfair try for trylock method.
            */
           @ReservedStackAccess
           final boolean nonfairTryAcquire(int acquires) {
               final Thread current = Thread.currentThread();
               int c = getState();
               if (c == 0) {
                   if (compareAndSetState(0, acquires)) {
                       setExclusiveOwnerThread(current);
                       return true;
                  }
              }
               else if (current == getExclusiveOwnerThread()) {
                   int nextc = c + acquires;
                   if (nextc < 0) // overflow
                       throw new Error("Maximum lock count exceeded");
                   setState(nextc);
                   return true;
              }
               return false;
          }

           @ReservedStackAccess
           protected final boolean tryRelease(int releases) {
               //state是已经重入的次数
               int c = getState() - releases;
               //判断当前线程是否持有锁,只有持有锁才能解锁,否则抛出异常
               if (Thread.currentThread() != getExclusiveOwnerThread())
                   throw new IllegalMonitorStateException();
               boolean free = false;
               //只有当state为0的时候才释放锁
               if (c == 0) {
                   //让当前这把锁恢复自由状态,不被任何线程持有
                   free = true;
                   setExclusiveOwnerThread(null);
              }
               setState(c);
               return free;
          }

           protected final boolean isHeldExclusively() {
               // While we must in general read state before owner,
               // we don't need to do so to check if current thread is owner
               return getExclusiveOwnerThread() == Thread.currentThread();
          }

           final ConditionObject newCondition() {
               return new ConditionObject();
          }

           // Methods relayed from outer class

           final Thread getOwner() {
               return getState() == 0 ? null : getExclusiveOwnerThread();
          }

           final int getHoldCount() {
               return isHeldExclusively() ? getState() : 0;
          }

           final boolean isLocked() {
               return getState() != 0;
          }

           /**
            * Reconstitutes the instance from a stream (that is, deserializes it).
            */
           private void readObject(java.io.ObjectInputStream s)
               throws java.io.IOException, ClassNotFoundException {
               s.defaultReadObject();
               setState(0); // reset to unlocked state
          }
      }

       //省略。。。
    }

    public abstract class AbstractQueuedSynchronizer
       extends AbstractOwnableSynchronizer
       implements java.io.Serializable {
       
       public final boolean release(int arg) {
           //如果tryRelease返回true,代表这把锁已经被真正释放掉了
           //就会从等待结点中唤醒,去获取锁
           if (tryRelease(arg)) {
               Node h = head;
               if (h != null && h.waitStatus != 0)
                   unparkSuccessor(h);
               return true;
          }
           return false;
      }
       
       //省略。。。
    }

     

 

使用AQS实现一个自己的Latch门闩

简易版CountDownLatch,一次性门闩。

 

参考资料

从ReentrantLock的实现看AQS的原理及应用

打通Java任督二脉一并发数据结构的基石

一行一行源码分析清楚AbstractQueuedSynchronizer

Java并发之AQS详解

英文论文的中文翻译

原文地址:https://www.cnblogs.com/chen-ying/p/11885776.html