线程池的一些面试题

1,为什么要用线程池,优势

(1)降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

(2) 提高响应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。

(3) 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

1.1常用方式

那java中是怎样实现的线程池呢？是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个接口或类，它们都是JUC包下的。 java.util.concurrent.Executors类是Executor的辅助类，类似于java中操作数组的辅助类java.util.Arrays，以及操作集合的java.util.Collections类

1.2:Executors类中的主要三个方法

线程安全的队列:staticQueue queue = new ConcurrentLinkedQueue<String>();

(1) 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中的等待，它创建的线程池corePoolSize和maximnumPoolSize是相等的，它使用的是LinkedBlockingQueue;

源码如下:

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>());

}

(2)Executors#newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行，它将corePoolSize和maximnumPoolSize都设置为1，它也使用的是LinkedBlockingQueue;

源码:

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>()));

}

(3)Executors#newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。，它将corePoolSize设置为0，将maximnumPoolSize设置为Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，当前线程空闲超过60秒，就销毁线程;

源码:

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue<Runnable>());

}

2,线程池的重要参数:

源码:

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler)

参数:

corePoolSize

线程池中的常驻核心线程数，在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。

maximumPoolSize

线程池能够容纳同时执行的最大线程数，此值必须大于等于1。

keepAliveTime

多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。

unit

keepAliveTime的单位。

workQueue

任务队列，被提交但尚未被执行的任务。

threadFactory

表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。

handler

拒绝策略，表示当队列满了，再也塞不下新任务了，同时，工作线程大于等于线程池的最大线程数，无法继续为新任务服务，这时候我们就需要拒绝策略机制合理的处理这个问题，默认会抛异常，那拒绝策略有哪些呢，我们继续往下看。

JDK内置的接口:RejectedExcutionHandle

AbortPolicy（默认）

直接抛出java.util.concurrent.RejectedExecutionException异常阻止系统正常运行，这种方式显然是不友好的。

CallerRunsPolicy

"调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。

DiscardOldestPolicy

抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。

DiscardPolicy

直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种解决方案。

具体选择哪一种的拒绝策略，也是看自己的系统需求了;

3,底层工作原理

(1).在创建了线程池后，等待提交过来的任务请求

(2).当调用execute()方法添加一个请求任务时，线程池会做如下判断

2.1 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务

2.2 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列

2.3 如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务

2.4 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行

(3). 当一个线程完成任务时，它会从队列中取下一个任务来执行

(4). 当一个线程无事可做超过一定的时间（keepAliveTime）时，线程池会判断

4.1 如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉

4.2 所以线程池的所有任务完成后它最终会收缩到corePoolSize的大小

创建线程池时，配置多少线程数是合理的:

(1)CPU密集型:CPU核数+1个线程的线程池(CPU密集任务只有在真正的多核CPU上才可能得到加速)

(2)IO密集型:O密集型时，大部分线程都阻塞，故需要多配置线程数，CPU核数/1-阻塞系数阻塞系数在0.8至0.9之间。例如4核，取个乐观值0.9，可达到40个线程左右

------------------------------------------------------------------------

--------------------------------

阿里巴巴开发手册上:出自于生产时间来说:

1,线程资源必须通过线程池提供,不能够在应用中自行创建线程;

2,线程池不允许使用Executors去创建,而是使用ThreadPoolExecutor的方式,

这样可以明确线程池的规则,规避资源耗尽的风险;

---------------------------

SpringBoot 自定义线程池:

1,application.yml配置:

task:

pool:

corePoolSize:5#设置核心线程数

maxPoolSize:20#设置最大线程数

keepAliveSeconds:300#设置线程活跃时间（秒）

queueCapacity:50#设置队列容量

2,线程池配置属性类:

importorg.springframework.boot.context.properties.ConfigurationProperties;

/**

* 线程池配置属性类

@ConfigurationProperties(prefix ="task.pool")

publicclassTaskThreadPoolConfig{

privateintcorePoolSize;

privateintmaxPoolSize;

privateintkeepAliveSeconds;

privateintqueueCapacity;

...getter and setter methods...

}

3,启动类上加上异步支持:

@EnableAsync

@EnableConfigurationProperties({TaskThreadPoolConfig.class} )// 开启配置属性支持

4,自定义线程池:

/**

* 创建线程池配置类

@Configuration

public class TaskExecutePool {

@Autowired

private TaskThreadPoolConfig config;

/**

* 1.这种形式的线程池配置是需要在使用的方法上面@Async("taskExecutor"),

* 2.如果在使用的方法上面不加该注解那么spring就会使用默认的线程池

* 3.所以如果加@Async注解但是不指定使用的线程池，又想自己定义线程池那么就可以重写spring默认的线程池

* 4.所以第二个方法就是重写默认线程池

* 注意：完全可以把线程池的参数写到配置文件中

@Bean

public Executor taskExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

//核心线程池大小

executor.setCorePoolSize(config.getCorePoolSize());

//最大线程数

executor.setMaxPoolSize(config.getMaxPoolSize());

//队列容量

executor.setQueueCapacity(config.getQueueCapacity());

//活跃时间

executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

//线程名字前缀

executor.setThreadNamePrefix("TaskExecutePool-");

// setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

// CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 等待所有任务结束后再关闭线程池

executor.setWaitForTasksToCompleteOnShutdown(true);

executor.initialize();

return executor;

}

测试:

import io.swagger.annotations.Api;

import io.swagger.annotations.ApiOperation;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;

/**

* @author qijx

@Api(description = "测试控制类11111")

@RestController

@RequestMapping("/threadPoolController1")

public class ThreadPoolController1 {

@Autowired

private ThreadPoolService1 threadPoolService;

@ApiOperation(value = "测试方法")

@ResponseBody

@RequestMapping(value = "/test",method = RequestMethod.GET)

public String threadPoolTest() {

threadPoolService.executeAsync();

return "hello word!";

}

第二种方法:重写springboot线程池:

* 原生(Spring)异步任务线程池装配类，实现AsyncConfigurer重写他的两个方法，这样在使用默认的

* 线程池的时候就会使用自己重写的

@Slf4j

@Configuration

public class NativeAsyncTaskExecutePool implements AsyncConfigurer{

//注入配置类

@Autowired

TaskThreadPoolConfig config;

@Override

public Executor getAsyncExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

//核心线程池大小

executor.setCorePoolSize(config.getCorePoolSize());

//最大线程数

executor.setMaxPoolSize(config.getMaxPoolSize());

//队列容量

executor.setQueueCapacity(config.getQueueCapacity());

//活跃时间

executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

//线程名字前缀

executor.setThreadNamePrefix("NativeAsyncTaskExecutePool-");

// setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

// CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 等待所有任务结束后再关闭线程池

executor.setWaitForTasksToCompleteOnShutdown(true);

executor.initialize();

return executor;

}

/**

* 异步任务中异常处理

* @return

@Override

public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

return new AsyncUncaughtExceptionHandler() {

@Override

public void handleUncaughtException(Throwable arg0, Method arg1, Object... arg2) {

log.error("=========================="+arg0.getMessage()+"=======================", arg0);

log.error("exception method:"+arg1.getName());

}

};

}

测试:

/**

* @author qijx

@Service

public class ThreadPoolService2 {

private static final Logger logger = LoggerFactory.getLogger(ThreadPoolService2.class);

/**

* @Async该注解不需要在指定任何bean

@Async

public void executeAsync() {

logger.info("start executeAsync");

try {

System.out.println("当前运行的线程名称：" + Thread.currentThread().getName());

Thread.sleep(1000);

} catch (Exception e) {

e.printStackTrace();

}

logger.info("end executeAsync");

}

------------------------------------