并发工具类

(一)CountDownLatch

  CountDownLatch 的作用和 Thread.join() 方法类似,可用于一组线程和另外一组线程的协作。例如,主线程在做一项工作之前需要一系列的准备工作,只有这些准备工作都完成,主线程才能继续它的工作。这些准备工作彼此独立,所以可以并发执行以提高速度。在这个场景下就可以使用 CountDownLatch 协调线程之间的调度了。在直接创建线程的年代(Java 5.0 之前),我们可以使用 Thread.join()。

  join用于让当前执行线程等待join线程执行结束。其实现原理是不停检查join线程是否存活,如果join线程存活则让当前线程永远wait,代码片段如下,wait(0)表示永远等待下去。

  

    public final synchronized void join(long millis) throws InterruptedException {
        
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        }
    }

  在 JUC 出现后,因为线程池中的线程不能直接被引用,所以就必须使用 CountDownLatch 了:

  CountDownLatch的构造函数接收一个int类型的参数作为计数器,如果你想等待N个点完成,这里就传入N。当我们调用一次CountDownLatch的countDown方法时,N就会减1,CountDownLatch的await会阻塞当前线程,直到N变成零。由于countDown方法可以用在任何地方,所以这里说的N个点,可以是N个线程,也可以是1个线程里的N个执行步骤。用在多个线程时,你只需要把这个CountDownLatch的引用传递到线程里。

  注意:计数器必须大于等于0,只是等于0时候,计数器就是零,调用await方法时不会阻塞当前线程。CountDownLatch不可能重新初始化或者修改CountDownLatch对象的内部计数器的值。一个线程调用countDown方法 happen-before另外一个线程调用await方法。【hb(a,b)】(那么a及之前的写操作在另一个线程  t1进行了 b操作时都对  t1可见,t1对应主线程

示例

    @Test
    public void safeCounterTest() throws Exception {
        
        SafeCounter counter = new SafeCounter();
        //启动五个线程开始计数
        CountDownLatch countDownLatch = new CountDownLatch(5);
        MultiThreadTest.multiThreadRun(()->{
            for (int i = 0; i < 5; i++){
                System.out.println(Thread.currentThread().getName()+": "+counter.counter()) ;
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {

                }
            }
            countDownLatch.countDown();
        },5);
        countDownLatch.await();
    }

  源码:

public class CountDownLatch {
    /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.
     *基于AQS
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

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

        int getCount() {
            return getState();
        }

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

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

    /**
     * Constructs a {@code CountDownLatch} initialized with the given count.
     *
     * @param count the number of times {@link #countDown} must be invoked
     *        before threads can pass through {@link #await}
     * @throws IllegalArgumentException if {@code count} is negative
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
}

  (2)CyclicBarrier

  CyclicBarrier 的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties),其参数表示屏障拦截的线程数量,每个线程调用await方法告诉CyclicBarrier我已经到达了屏障,然后当前线程被阻塞。CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction),用于在线程到达屏障时,优先执行barrierAction,方便处理更复杂的业务场景。CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景,比如如果计算发生错误,可以重置计数器,并让线程们重新执行一次。

    @Test
    public void safeCounterTest() throws Exception {

        SafeCounter counter = new SafeCounter();
        //启动五个线程开始计数
        CountDownLatch countDownLatch = new CountDownLatch(5);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6,
                ()->{
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {

                    }
                    System.out.println(Thread.currentThread().getName() + ": " + "action");});
        MultiThreadTest.multiThreadRun(() -> {
            for (int i = 0; i < 1; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + "before");
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {

                }
                System.out.println(Thread.currentThread().getName() + ": " + "after");
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {

                }
            }
        }, 5);
        cyclicBarrier.await();
    }

  

  执行顺序为before -> action ->  after,需要注意的是action仅执行一次。

(三)Semaphore 控制并发线程数

提供了三个个核心方法

semaphore.acquire();
semaphore.release();

tryAcquire();非阻塞执行

summary:

Semaphore 和 CountDownLatch内部都是基于AQS内部类实现,CyclicBarrier内部直接基于ReentrantLock实现。

 

posted @ 2017-12-27 21:23  heapStark  阅读(183)  评论(0编辑  收藏  举报