「java线程池面试讲解」java线程池写法
今天给各位分享java线程池面试讲解的知识，其中也会对java线程池写法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
java常用的几种线程池实例讲解
下面给你介绍4种线程池：
1、newCachedThreadPool：
底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器
2、newFixedThreadPool：
底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueueRunnable() 无解阻塞队列
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多
3、newSingleThreadExecutor
底层：FinalizableDelegatedExecutorService包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueueRunnable() 无解阻塞队列
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景
4、NewScheduledThreadPool:
底层：创建ScheduledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；workQueue为：new DelayedWorkQueue() 一个按超时时间升序排序的队列
通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构
适用：周期性执行任务的场景
最后给你说一下线程池任务执行流程：
当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
当workQueue已满，且maximumPoolSizecorePoolSize时，新提交任务会创建新线程执行任务
当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理
当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
线程池的一些面试题
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 ConcurrentLinkedQueueString();
(1) 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中的等待，它创建的线程池corePoolSize和maximnumPoolSize是相等的，它使用的是LinkedBlockingQueue;
源码如下:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueueRunnable());
}
(2)Executors#newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行，它将corePoolSize和maximnumPoolSize都设置为1，它也使用的是LinkedBlockingQueue;
源码:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueueRunnable()));
}
(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 SynchronousQueueRunnable());
}
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");
}
}
------------------------------------
面试题：线程池有几种实现方式，线程池的七大参数有哪些？
在Java编码的过程中，我们经常会创建一个线程来提高程序的执行效率，虽然这样实现起来很方便，但是会有一个问题：如果并发的线程数多，并且每个线程都是执行一个时间很短的任务就结束了，这样会造成频繁的创建和销毁线程从而导致降低系统的效率。
那么问题来了，有没有办法可用复用创建好的线程呢，也就是线程执行完一个任务后，不被销毁，继续执行其他的任务？
在Java可以通过线程池来实现这样的效果。
下面从三个方面和大家一起来探讨一下Java线程池相关的内容。
1.Java中的ThreadPoolExecutor类。
2.Java中4种线程池的使用。
3.Java线程池常用参数如何设置。
一、Java中的ThreadPoolExecutor类
A.ThreadPoolExecutor的重要参数
1.corePoolSize：核心线程数
核心线程会一直存活，及时没有任务需要执行。
当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理。
设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭。
2.queueCapacity：任务队列容量（阻塞队列）
当核心线程数达到最大时，新任务会放在队列中排队等待执行。
3.maxPoolSize：最大线程数
当线程数=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务。
当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常。
4.keepAliveTime：线程空闲时间
当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize。
如果allowCoreThreadTimeout=true，则会直到线程数量=0。
5.allowCoreThreadTimeout：允许核心线程超时
6.rejectedExecutionHandler：任务拒绝处理器。
B.ThreadPoolExecutor执行过程
1.当线程数小于核心线程数时，创建线程。
2.当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
3.当线程数大于等于核心线程数，且任务队列已满。(1)若线程数小于最大线程数，创建线程。(2)若线程数等于最大线程数，抛出异常，拒绝任务。
二、Java中4种线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
java线程池面试讲解的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java线程池写法、java线程池面试讲解的信息别忘了在本站进行查找喔。