互联网架构（4）：并发编程--Concurrent.util工具类

4 Concurrent.util工具类详解

（1）CyclicBarrier使用：

假设有一个场景：每一个线程代表一个跑步运动员，当运动员都准备好后，才一起出发，只要有一个人没有准备好，大家都等待。

CyclicBarrier barrier = new CyclicBarrier(int count); count为计数器，每有一个线程调用barrier.await();则计数器减1，当计数器减为0的时候，所有await的线程会同时被唤醒开始执行。

    import java.util.Random;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;

    public class UseCyclicBarrier {

        static class Runner implements Runnable{

            private CyclicBarrier barrier; 
            private String name;

            public Runner(CyclicBarrier barrier, String name) {
                // TODO Auto-generated constructor stub
                this.barrier = barrier;
                this.name = name;
            }

            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    Thread.sleep(1000 * new Random().nextInt(5));
                    System.out.println(this.name + "准备ok！");
                    barrier.await();
                } catch (Exception e) {
                    // TODO: handle exception
                }
                System.out.println(System.currentTimeMillis() + " - " + this.name + " Go!");
            }
        }

        public static void main(String[] args) {
            CyclicBarrier barrier = new CyclicBarrier(3);
            ExecutorService pool = Executors.newFixedThreadPool(3);

            pool.submit(new Thread(new Runner(barrier, "zhangsan")));
            pool.submit(new Thread(new Runner(barrier, "lisi")));
            pool.submit(new Thread(new Runner(barrier, "wangwu")));

            pool.shutdown();
        }

    }

（2）CountDownLacth使用：

他常用于监听某些初始化操作，等初始化执行完毕后，通知主线程继续工作。

CountDownLatch count = new CountDownLatch(int count); count为计数器，没调用一次count.countDown();计数器就会减1，当计数器减为0的时候会唤醒await的线程继续执行。

import java.util.concurrent.CountDownLatch;

public class UseCountDownLacth {

    public static void main(String[] args) {
        final CountDownLatch count = new CountDownLatch(2);

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    System.out.println("进入线程t1，" + "等待其他线程处理完成...");
                    count.await();
                    System.out.println("t1线程继续执行...");
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    System.out.println("进入线程t2，" + "执行t2线程的初始化操作...");
                    Thread.sleep(3 * 1000);
                    System.out.println("t2线程初始化完毕，通知t1线程...");
                    count.countDown();
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    System.out.println("进入线程t3，" + "执行t3线程的初始化操作...");
                    Thread.sleep(4 * 1000);
                    System.out.println("t3线程初始化完毕，通知t1线程...");
                    count.countDown();
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }

}

• 两者的区别：CountDownLacth是一个线程等待，多个线程去发通知，然后一个线程执行。CyclicBarrier是多个线程等待，然后多个线程一起开始执行。

（3）Callable使用：

（4）Future使用：

Future模式非常适用于在处理耗时很长的业务逻辑时进行适用，可以有效的减小系统的响应时间，提高系统的吞吐量

 FutureTask<V> futureTask = new FutureTask<V>( ? extends Callable );
 ExecutorService pool = Executors.newFixedThreadPool(2);
 Future f = pool.submit(futureTask);
 V result = futureTask.get();//执行后的返回结果



import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class UseFuture implements Callable<String>{

    private String para;

    public UseFuture(String para) {
        // TODO Auto-generated constructor stub
        this.para = para;
    }

    @Override
    public String call() throws Exception {
        // TODO Auto-generated method stub
        Thread.sleep(3000);
        String result = this.para + "处理完成";
        return result;
    }

    public static void main(String[] args) throws Exception{
        String queryStr = "query";
        FutureTask<String> futureTask = new FutureTask<String>(new UseFuture(queryStr));
        FutureTask<String> futureTask1 = new FutureTask<String>(new UseFuture(queryStr));
        ExecutorService pool = Executors.newFixedThreadPool(2);
        long start = System.currentTimeMillis();
        Future f = pool.submit(futureTask);
        Future f1 = pool.submit(futureTask1);
        System.out.println("请求完毕.");
//      System.out.println(f.isDone());
//      System.out.println(f.get()); //如果任务执行完成，那么f.get会返回null
//      System.out.println(f.isDone());
        System.out.println(futureTask.get());
        System.out.println("111111111");
        System.out.println(futureTask1.get());
        long end = System.currentTimeMillis() - start;
        System.out.println(end);
        pool.shutdown();
    }

}

（5）Semaphore信号量

• PV（page view）网站的总访问量，页面浏览量或点击量，用户每刷新一次就会被记录一次。
• UV（unique Visitor）访问网站的一台电脑客户端为一个访客。一般来讲，时间上以00:00-24:00之类相同ip的客户端只记录一次
• QPS（query per second）即每秒查询数，qps很大程度上代表了系统业务上的繁忙程度。每次请求的背后，可能对应着多次磁盘I/O，多次网络请求，多个cpu时间片等。我们通过qps可以非常直观的了解当前系统业务情况，一旦当前qps超过所设定的预警阀值，可以考虑增加机器对集群扩容，以免压力过大导致宕机，可以根据前期的压力测试得到估值，在结合后期综合运维情况，估算出阀值。
• RT（response time）即请求的响应时间，这个指标非常关键，直接说明前端用户的体验，因此任何系统设计师都想降低rt时间。

当然还涉及cpu、内存、网络、磁盘等情况，细节的问题很多。

    public static void main(String[] args) {
        final Semaphore semp = new Semaphore(5); //实例化许可门限，相当于阀值
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < 20; i++){
            final int NO = i;
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    try {
                        semp.acquire();//获取许可，如果能够获取则继续执行，否则阻塞等待
                        System.out.println("Accessing: " + NO);
                        Thread.sleep(5 * 1000);
                        semp.release();//释放许可
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }
            };
            exec.execute(run);
        }
        exec.shutdown();
    }

• 容量评估：一般来说通过开发、运维、测试以及业务等相关人员综合处系统的一系列阀值，然后我们根据关键阀值如qps、rt等，对系统进行有效的变更。
  一般来讲，我们进行多轮压力测试以后，可以对系统进行峰值评估，采用所谓的80/20原则，即80%的访问请求将在20%的时间内达到。这样我们可以根据系统对应的PV计算出峰值qps。
  峰值qps=（总PV * 80%） / （60 * 60 * 24 * 20%）
  然后在将总得峰值qps除以单台机器所能承受的最高的qps值，就是所需机器的数量：机器总数 = 总得峰值qps / 压力测试得出的单机极限qps
  当然这只是在一般情况下，如果系统可能存在像天猫双十一那样的促销活动，需要另外去考量。