JAVA并发编程之倒计数器CountDownLatch

CountDownLatch 的使用场景：在主线程中开启多线程去并行执行任务，并且主线程需要等待所有子线程执行完毕后汇总返回结果。

我把源码中的英文注释全部删除，写上自己的注释。就剩下 70 行不到的代码，很简单了。

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class CountDownLatch {

    // 自定义一个属性，继承    抽象队列同步器

    private static final class Sync extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {

            setState(count);

        }

        int getCount() {

            return getState();

        }

        @Override

        protected int tryAcquireShared(int acquires) {

            return (getState() == 0) ? 1 : -1;

        }

        @Override

        protected boolean tryReleaseShared(int releases) {

            for (;;) {

                int c = getState();

                if (c == 0) {

                    return false;

                }

                int nextc = c-1;

                if (compareAndSetState(c, nextc)) {

                    return nextc == 0;

                }

            }

        }

    }

    //定义私有属性，该类继承 抽象队列同步器

    private final java.util.concurrent.CountDownLatch.Sync sync;

    // 构造方法，传入数字，用于倒计数

    public CountDownLatch(int count) {

        if (count < 0) {

            throw new IllegalArgumentException("count < 0");

        }

        this.sync = new java.util.concurrent.CountDownLatch.Sync(count);

    }

    // 阻塞当前线程，直到count=0才唤醒线程

    public void await() throws InterruptedException {

        sync.acquireSharedInterruptibly(1);

    }

    // 阻塞当前线程，直到count=0才唤醒线程。

    // 设置定时时间到了，也会唤醒线程。

    public boolean await(long timeout, TimeUnit unit)

            throws InterruptedException {

        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));

    }

    //count 减 1

    public void countDown() {

        sync.releaseShared(1);

    }

    //获取 count

    public long getCount() {

        return sync.getCount();

    }

    //toString方法，获取字符串

    public String toString() {

        return super.toString() + "[Count = " + sync.getCount() + "]";

    }

}

我用这个CountDownLatch来实现多线程执行任务，合并结果返回。

//创建线程池

        ExecutorService pool = Executors.newCachedThreadPool();

        //定义集合存储结果

        List<Object> values = new ArrayList<>();

        //定义倒计数器

        CountDownLatch count = new CountDownLatch(2);

        //线程池执行任务1

        pool.submit(new Runnable() {

            @Override

            public void run() {

                try {

                    //线程池进行计算1，得到结果1。

                    String value1 = "结果1";

                    //把结果加入共享变量中。

                    values.add(value1);

                } catch (Exception e) {

                    e.printStackTrace();

                }finally {

                    //finally 中保证一定会执行 减1

                    //计数器减 1

                    count.countDown();

                }

            }

        });

        //线程池执行任务2

        pool.submit(new Runnable() {

            @Override

            public void run() {

                try {

                    //线程池进行计算2，得到结果2。

                    String value2 = "结果2";

                    //把结果加入共享变量中。

                    values.add(value2);

                } catch (Exception e) {

                    e.printStackTrace();

                }finally {

                    //finally 中保证一定会执行 减1

                    //计数器减 1

                    count.countDown();

                }

            }

        });

        //线程阻塞等待

        count.await();

        //返回多线程执行的结果。

        return values;

　　多线程并发编程，就是这么简单！不用Callable，也能获取到线程池的返回值哦。

巴特西

JAVA并发编程之倒计数器CountDownLatch

最新文章

热门文章