经常使用Concurrent.util包工具类——高并发

时间 2019-11-09

标签经常使用 concurrent.util concurrent util 工具并发栏目 Java 繁體版

原文原文链接

一 Concurrent.util经常使用类：

1. CyclicBarrier：假设有场景：每一个线程表明一个跑步运动员，当运动员都准备好后，才一块儿出发只要有一我的没有准备好，你们都等待。

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
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) {
            super();
            this.barrier = barrier;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000 * (new Random()).nextInt(5));
                System.out.println(name + "准备OK");
                barrier.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(name + "Go!");
        }
    }
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3);
        ExecutorService pool = Executors.newFixedThreadPool(3);
        pool.execute(new Runner(barrier, "b1"));
        pool.execute(new Runner(barrier, "b2"));
        pool.execute(new Runner(barrier, "b3"));
        pool.shutdown();
    }

}

运行结果：
b3准备OK
b2准备OK
b1准备OK
b2Go!
b1Go!
b3Go!java

2. CountDownLacth：常常用于监听某些初始化操做，等初始化执行完毕后，通知主线程继续工做

import java.util.concurrent.CountDownLatch;

public class UseCountDownLatch {

    public static void main(String[] args) {
        final CountDownLatch cDownLatch = new CountDownLatch(2);
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                System.out.println("进入线程t1，等待其余线程处理完成...");
                try {
                    cDownLatch.await();
                    //当CountDownLatch构造函数的参数减为0时，该线程才继续执行
                    System.out.println("t1线程继续执行...");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "t1");
        
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                System.out.println("t2线程执行初始化操做...");
                try {
                    Thread.sleep(3000);
                    System.out.println("t2线程初始化操做完成，通知t1线程继续...");
                    cDownLatch.countDown();
                    //CountDownLatch构造函数的参数-1
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "t2");
        Thread t3 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                System.out.println("t3线程执行初始化操做...");
                try {
                    Thread.sleep(4000);
                    System.out.println("t3线程初始化操做完成，通知t1线程继续...");
                    cDownLatch.countDown();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "t3");
        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果：
进入线程t1，等待其余线程处理完成...
t2线程执行初始化操做...
t3线程执行初始化操做...
t2线程初始化操做完成，通知t1线程继续...
t3线程初始化操做完成，通知t1线程继续...
t1线程继续执行...数据库

区别：CyclicBarrier全部线程都阻塞；CountDownLatch只有一个(主)线程阻塞等待

3. Future和Callable：该模式很是适合在处理很耗时的业务逻辑时进行使用，能够有效的减小系统的响应时间，提升系统的吞吐量

public class UseFuture implements Callable<String>{
    private String para;

    public UseFuture(String para) {
        super();
        this.para = para;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        String querystr = "query";
        //构造FutureTask，而且传入须要真正进行业务处理的类，该类实现了Callable接口
        FutureTask<String> future = new FutureTask<>(new UseFuture(querystr));
        FutureTask<String> future2 = new FutureTask<>(new UseFuture(querystr));
        //建立一个固定线程数量的线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //这里提交任务的future，则开启线程执行RealData的call()
        Future f = pool.submit(future);
        Future f2 = pool.submit(future2);
        //submit和execute的区别：submit能够实现calabale接口的对象；submit有返回值
        System.out.println("请求完毕");
//      while(true) {
            //f.get()判断RealData是否执行完毕
//          if(f.get() == null){
//              System.out.println("---------------");
                //future.get()获取ReadData
//              System.out.println("数据：" + future.get());
//              break;
//          }
//      }
        try {
            //处理其余实际业务逻辑
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("数据：" + future.get());
        System.out.println("数据：" + future2.get());
        //并行处理，一共等待3秒
        pool.shutdown();
    }

    @Override
    public String call() throws Exception {
        //模拟执行耗时
        Thread.sleep(3000);
        String result = this.para + "处理完成";
        return result;
    }

}

运行结果：
请求完毕
数据：query处理完成
数据：query处理完成服务器

4. Semaphore信号量

Semaphore信号量很是适合高并发访问，新系统在上线以前，要对系统的访问量进行评估，固然这个值确定不是随便拍拍脑壳就能想出来的，是通过以往的经验、数据、历年的访问量、以及推广粒力度进行的一个合理的评估，固然评估标准不能太大也不能过小，太大的话投入的资源达不到实际效果，浪费资源，过小的话，某个时间点一个峰值的访问量上来直接能够压垮系统。
相关概念：网络

PV(Page View)：网站的总访问量，页面浏览量或点击量，用户每刷新一次就会被记录一次
UV(Unlque Visitor)：访问网站的一台电脑客户端为一个访客，通常来说，时间上以00:00-24:00以内相同IP的客户端只记录一次
QPS(Query Per Second)：每秒查询数，qps很大程度上表明了系统业务的繁忙程度，每次请求的背后，可能对应着屡次磁盘IO，屡次网络请求，多个cpu时间片等。咱们经过qps能够很是直观的了解当前系统业务状况，一旦当前qps超过所设定的预警阀值，能够考虑增长机器对集群扩容，以避免压力过大致使宕机，能够根据前期的压力测试获得估值，再结合后期综合运维状况，结算出阀值。
RT(Response Time)：请求的响应时间，这个指标很是关键，直接说明前期用户的体验，所以任何系统设计师都想下降rt时间。
固然还涉及到cpu、内存、网络、磁盘等状况，更细节的问题不少，如select、update、delete/ps等数据库层面的统计。

应对高并发环境：

网络层面
服务层面：多台ng服务器作分流负载均衡
Java业务上进行模块化划分