学习笔记之线程池

最新推荐文章于 2024-08-09 15:32:53 发布

Hello, I'm Tina

最新推荐文章于 2024-08-09 15:32:53 发布

阅读量193

点赞数 1

分类专栏：学习笔记

学习笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

摘抄自：https://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484608&idx=1&sn=cf5d9f47cbdac1751565ee3448804de6&chksm=fba6ecc3ccd165d51426a04825d9ac35e16061ee81a9d3d7b85f526755938ad88e714f0dc74d&scene=0#rd

使用线程池的目的：
线程是稀缺资源，不能频繁的创建。
解耦作用；线程创建于执行完全分开，方便维护
应当将其放入一个池子中，可以给其他任务进行复用。

常见的创建线程池方式：
Executors.newCachedThreadPool()：无限线程池。阻塞队列使用的是SynchronousQueue。在没有任务执行时，当线程的空闲时间超过keepAliveTime（60秒），则工作线程将会终止被回收，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销。

Executors.newFixedThreadPool(nThreads)：创建固定大小的线程池。阻塞队列使用的是LinkedBlockingQueue，大小为整数最大值。

Executors.newSingleThreadExecutor()：创建单个线程的线程池。阻塞队列使用的是LinkedBlockingQueue，若有多余的任务提交到线程池中，则会被暂存到阻塞队列，待空闲时再去执行。按照先入先出的顺序执行任务。

Executors.newScheduledThreadPool()：定时线程池，该线程池可用于周期性地去执行任务，通常用于周期性的同步数据。

线程池的原理：
核心的思想就是把宝贵的资源放到一个池子中；每次使用都从里面获取，用完之后又放回池子供其他人使用。
利用 ThreadPoolExecutor 类实现的。
核心参数的作用：
corePoolSize 为线程池的基本大小。
maximumPoolSize 为线程池最大线程大小。
keepAliveTime 和 unit 则是线程空闲后的存活时间。
workQueue 用于存放任务的阻塞队列。
handler 当队列和最大线程池都满了之后的饱和策略。

核心逻辑就是 execute() 函数
RUNNING 自然是运行状态，指可以接受任务执行队列里的任务
SHUTDOWN 指调用了 shutdown() 方法，不再接受新任务了，但是队列里的任务得执行完毕。
STOP 指调用了 shutdownNow() 方法，不再接受新任务，同时抛弃阻塞队列里的所有任务并中断所有正在执行任务。
TIDYING 所有任务都执行完毕，在调用 shutdown()/shutdownNow() 中都会尝试更新为这个状态。
TERMINATED 终止状态，当执行 terminated() 后会更新为这个状态。

如何配置线程：
IO 密集型任务：由于线程并不是一直在运行，所以可以尽可能的多配置线程，比如 CPU 个数 * 2
CPU 密集型任务（大量复杂的运算）应当分配较少的线程，比如 CPU 个数相当的大小。

关闭线程池：
shutdown() 执行后停止接受新任务，会把队列的任务执行完毕。
shutdownNow() 也是停止接受新任务，但会中断所有的任务，将线程池状态变为 stop。

Spring boot中使用线程池：
1. 配置
@Configuration
public class TreadPoolConfig {

    /**
     * 消费队列线程
     * @return
     */
    @Bean(value = "consumerQueueThreadPool")
    public ExecutorService buildConsumerQueueThreadPool(){
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("consumer-queue-thread-%d").build();

ExecutorService pool = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue(5),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy());

return pool ;
}

}

2. 使用
@Resource(name = "consumerQueueThreadPool")
private ExecutorService consumerQueueThreadPool;

    @Override
    public void execute() {
        //消费队列
        for (int i = 0; i < 5; i++) {
            consumerQueueThreadPool.execute(new ConsumerQueueThread());
        }
    }

3. 监控：
1）利用 actuator 组件来做线程池的监控；
2）继承线程池扩展其中的几个函数来自定义监控逻辑，可以在线程执行前、后、终止状态执行自定义逻辑：beforeExecute()，afterExecute()， terminated()

4. 线程池隔离：
如果我们很多业务都依赖于同一个线程池,当其中一个业务因为各种不可控的原因消耗了所有的线程，导致线程池全部占满。通常的做法是按照业务进行划分。

Hystrix隔离：
原理：利用一个 Map 来存放不同业务对应的线程池。获取任务任务结果支持同步阻塞和异步非阻塞方式，可自行选择。
注：自定义的 Command 并不是一个单例，每次执行需要 new 一个实例，不然会报 This instance can only be executed once. Please instantiate a new instance. 异常。

/**
* Function:订单服务
* @since JDK 1.8
*/
public class CommandOrder extends HystrixCommand<String> {

private final static Logger LOGGER = LoggerFactory.getLogger(CommandOrder.class);

private String orderName;

public CommandOrder(String orderName) {

        super(Setter.withGroupKey(
                //服务分组
                HystrixCommandGroupKey.Factory.asKey("OrderGroup"))
                //线程分组
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("OrderPool"))

                //线程池配置
                .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
                        .withCoreSize(10)
                        .withKeepAliveTimeMinutes(5)
                        .withMaxQueueSize(10)
                        .withQueueSizeRejectionThreshold(10000))

                .andCommandPropertiesDefaults(
                        HystrixCommandProperties.Setter()
                                .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD))
        )
        ;
        this.orderName = orderName;
    }

@Override
public String run() throws Exception {

LOGGER.info("orderName=[{}]", orderName);

        TimeUnit.MILLISECONDS.sleep(100);
        return "OrderName=" + orderName;
    }
}

/**
* Function:用户服务
* @since JDK 1.8
*/
public class CommandUser extends HystrixCommand<String> {

private final static Logger LOGGER = LoggerFactory.getLogger(CommandUser.class);

private String userName;

public CommandUser(String userName) {

        super(Setter.withGroupKey(
                //服务分组
                HystrixCommandGroupKey.Factory.asKey("UserGroup"))
                //线程分组
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("UserPool"))

                //线程池隔离
                .andCommandPropertiesDefaults(
                        HystrixCommandProperties.Setter()
                                .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD))
        )
        ;
        this.userName = userName;
    }

@Override
public String run() throws Exception {

LOGGER.info("userName=[{}]", userName);

        TimeUnit.MILLISECONDS.sleep(100);
        return "userName=" + userName;
    }
}

运行：
public static void main(String[] args) throws Exception {
CommandOrder commandPhone = new CommandOrder("手机");
CommandOrder command = new CommandOrder("电视");

        //阻塞方式执行
        String execute = commandPhone.execute();
        LOGGER.info("execute=[{}]", execute);

        //异步非阻塞方式
        Future queue = command.queue();
        String value = queue.get(200, TimeUnit.MILLISECONDS);
        LOGGER.info("value=[{}]", value);

        CommandUser commandUser = new CommandUser("张三");
        String name = commandUser.execute();
        LOGGER.info("name=[{}]", name);
    }