Java 线程池在springboot环境中的使用

1、配置线程池

package com.example.demo.core.thread;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.*;

/**
 *   ArrayBlockingQueue：          由数组结构组成的有界阻塞队列。

 　　LinkedBlockingQueue：         由链表结构组成的有界阻塞队列。

 　　PriorityBlockingQueue：       支持优先级排序的无界阻塞队列。

 　　DealyQueue：                  使用优先级队列实现的无界阻塞队列。

 　　SynchronousQueue：            不存储元素的阻塞队列。

 　　LinkedTransferQueue：         由链表结构组成的无界阻塞队列。

 　　LinkedBlockingDeque：         由链表结构组成的双向阻塞队列。
 */
@Configuration
public class ThreadPoolConfig {

    private static final int MAX_POOL_SIZE = 200;
    private static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 2 + 1;
    private static final String THREAD_NAME = "consumer-queue-thread-%d";

    /**
     * 消费队列线程池
     * @return
     */
    @Bean(value = "consumerQueueThreadPool")
    public ExecutorService buildConsumerQueueThreadPool() {

        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat(THREAD_NAME).build();

        /**
         * 1. CallerRunsPolicy ：    这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。

           2. AbortPolicy ：         对拒绝任务抛弃处理，并且抛出异常。

           3. DiscardPolicy ：       对拒绝任务直接无声抛弃，没有异常信息。

           4. DiscardOldestPolicy ： 对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。
         */
        ExecutorService threadPool = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                0L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(MAX_POOL_SIZE),
                threadFactory,
                new ThreadPoolExecutor.AbortPolicy());

        /*ExecutorService pool = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                0L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                threadFactory);*/

        return threadPool;
    }
}

2、调用方式

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.concurrent.ExecutorService;

@Controller
@RequestMapping("/consumer")
public class ConsumerController {


    @Resource(name = "consumerQueueThreadPool")
    private ExecutorService service;

    @GetMapping("/sync/test")
    @ResponseBody
    public String syncFunc() {
        for(int i = 0; i < 3; i++) {
            service.execute(() -> {
                System.out.println("当前正在执行线程:" + Thread.currentThread().getName());
            });
        }
        return "xxx";
    }

}

3、pom文件中需要引入guava的依赖

<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>24.1-jre</version>
</dependency>

推荐一个公众号

号主为一线大厂架构师，CSDN博客专家，博客访问量突破一千万。主要分享Java、golang架构，源码，分布式，高并发等技术，用大厂程序员的视角来探讨技术进阶、面试指南、职业规划等。15W技术人的选择！