高并发

一、什么是高并发

高并发（high concurrency）是互联网分布式系统架构设计中必须考虑的因素之一。
它通常是指：通过设计保证系统能够同时并行处理很多请求

二、高并发带来的问题

服务端：

• 某一时间片刻系统流量异常高，系统濒临阈值
• 服务器cpu、内存爆满、磁盘IO繁忙
• 系统雪崩
  如果一个请求要经历三个服务，A->B->C，当C系统扛不住，挂掉了，那么B系统就一直阻塞着，当达到一定的线程数量之后，B系统就会挂掉，同理A系统越积越多，A系统也会挂掉。

三、并发解决方案--四大法宝

• 缓存
• 异步
• 并发编程
• 分布式

四、自定义futuretask类

package com.tinner.demo.custom;

import java.util.concurrent.*;

/**
 * @Classname TinnerFutureTask
 * @Description
 * 对于FutureTask来说，其实完成了两件事情：
 *  1、执行业务逻辑
 *  2、把请求方法阻塞，获取结果
 * @Date 2020/6/5 4:48 下午
 * @Created by tinner
 */
public class TinnerFutureTask<v> implements Runnable, Future<v> {

    //封装业务逻辑
    private Callable<v> callable;

    //用来接收结果
    v result = null;

    public TinnerFutureTask(Callable<v> callable){
        this.callable = callable;
    }
    //执行业务逻辑
    @Override
    public void run() {
        try {
            result = callable.call();

            synchronized (this){
                this.notifyAll();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //取结果
    @Override
    public v get() throws InterruptedException, ExecutionException {
        if (result != null){
            return result;
        }
        //等待
        synchronized (this){
            //底层用的park和unpark
            this.wait();
        }
        return result;
    }

    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        return false;
    }

    @Override
    public boolean isCancelled() {
        return false;
    }

    @Override
    public boolean isDone() {
        return false;
    }



    @Override
    public v get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        return null;
    }
}

对于FutureTask来说，其实完成了两件事情：

• 1、执行业务逻辑
• 2、把请求方法阻塞，获取结果

五、接口异步请求

    @RequestMapping("/infoByAsync")
    public Callable<JSONObject> getUserInfoAsync(){

        System.out.println("主线程开始。。。。。" + Thread.currentThread() + "======" + System.currentTimeMillis());
        Callable<JSONObject> callable = () -> {
            System.out.println("子线程开始。。。。。" + Thread.currentThread() + "======" + System.currentTimeMillis());
            JSONObject userInfo = userThreadService.getUserInfo();
            System.out.println("子线程结束。。。。。" + Thread.currentThread() + "======" + System.currentTimeMillis());
            return userInfo;
        };
        System.out.println("主线程结束。。。。。" + Thread.currentThread() + "======" + System.currentTimeMillis());
        return  callable;
    }

结果打印：

接口异步请求

可以看到tomcat的主线程瞬间就被释放了，然后将请求交给子线程去处理，异步地返回对应的结果，这样对于高并发处理的请求时，可以节省更多的资源去处理更多的请求。而不是让某些请求在那边阻塞着

image.png