线程池的使用以及拒绝策略

1. ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

2. ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。

3. ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务

4. ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务

核心线程池没满就创建核心线程来执行，满了就放入等待队列里，等待队列没满就加入队列，满了就判断最大线程池有没有满，没满就创建线程来执行（核心线程之外的空闲线程会根据存活时间来销毁），满了就按照拒绝策略来执行，如果是CallerRunsPolicy策略，就是由提交该任务的线程来执行。

package com.xu.redis_springboot.config;

import java.util.Date;

/**
 * @author:
 * @since: 2022-04-11
 */
public class MyRunnable implements Runnable {


    private String command;

    public MyRunnable(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return this.command;
    }
}

package com.xu.redis_springboot.config;

/**
 * @author:
 * @since: 2022-04-11
 */
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {

        private static final int CORE_POOL_SIZE = 5;//核心线程数
        private static final int MAX_POOL_SIZE = 10;//最大线程数
        private static final int QUEUE_CAPACITY = 10;//队列的最大长度
        private static final Long KEEP_ALIVE_TIME = 1L;//空闲线程的存活时间
        public static void main(String[] args) {

            //使用阿里巴巴推荐的创建线程池的方式
            //通过ThreadPoolExecutor构造函数自定义参数创建
            //TimeUnit.SECONDS时间单位是秒
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());



            for (int i = 0; i < 15; i++) {
                //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
                Runnable worker = new MyRunnable("" + i);
                //执行Runnable
                executor.execute(worker);
            }
            //终止线程池
            executor.shutdown();
            while (!executor.isTerminated()) {
            }
            System.out.println("Finished all threads");
            }
}

---

CountDownLatch(int count);

计数器

在线程执行方法的最后加上

countDownLatch.countDown()计数器减1

countDownLatch.await()  让进程处于等待状态，直到计数器减到0为止才启动

---

异步调用

public UserInfo getUserInfo(Long id) throws InterruptedException, ExecutionException {
    final UserInfo userInfo = new UserInfo();
    CompletableFuture userFuture = CompletableFuture.supplyAsync(() -> {
        getRemoteUserAndFill(id, userInfo);
        return Boolean.TRUE;
    }, executor);

    CompletableFuture bonusFuture = CompletableFuture.supplyAsync(() -> {
        getRemoteBonusAndFill(id, userInfo);
        return Boolean.TRUE;
    }, executor);

    CompletableFuture growthFuture = CompletableFuture.supplyAsync(() -> {
        getRemoteGrowthAndFill(id, userInfo);
        return Boolean.TRUE;
    }, executor);
    CompletableFuture.allOf(userFuture, bonusFuture, growthFuture).join();

    userFuture.get();
    bonusFuture.get();
    growthFuture.get();

    return userInfo;
}