Java多线程3-线程池、Callable和Future-优快云博客

本文详细介绍了Java中四种线程池的创建与使用方法：FixedThreadPool、CachedThreadPool、SingleThreadExecutor和ScheduledThreadPool，并通过示例代码展示了它们的不同应用场景。此外还讲解了Callable和Future的配合使用，帮助开发者更好地理解并利用线程池提升程序性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程池

java.util.concurrent，在Java开发中，我们接触到了好多池的技术，String类的对象池、Integer的共享池、连接数据库的连接池、Struts1.3的对象池等等，池的最终目的都是节约资源，以更小的开销做更多的事情，从而提高性能。

我们的web项目都是部署在服务器上，浏览器端的每一个request就是一个线程，那么服务器需要并发的处理多个请求，就需要线程池技术，下面来看一下Java并发包下如何创建线程池。

1.创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。

[java]view plaincopyprint? 
     
   
 ExecutorServicethreadPool=Executors.newFixedThreadPool(3); 
 //创建可以容纳3个线程的线程池 

2.创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

[java]view plaincopyprint? 
     
   
 ExecutorServicethreadPool=Executors.newCachedThreadPool(); 
 //线程池的大小会根据执行的任务数动态分配 

3.创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

[java]view plaincopyprint? 
     
   
 ExecutorServicethreadPool=Executors.newSingleThreadExecutor(); 
 <prename="code"class="java"> 
 //创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务 

4. 创建一个可安排在给定延迟后运行命令或者定期地执行的线程池。

[java]view plaincopyprint? 
     
   
 ScheduledExecutorServicethreadPool=Executors.newScheduledThreadPool(3); 
 //效果类似于Timer定时器 

每种线程池都有不同的使用场景，下面看一下这四种线程池使用起来有什么不同。

1. FixedThreadPool

[java]view plaincopyprint? 
     
   
 importjava.util.concurrent.ExecutorService; 
 importjava.util.concurrent.Executors; 
 publicclassThreadPoolTest{ 
 publicstaticvoidmain(String[]args){ 
 ExecutorServicethreadPool=Executors.newFixedThreadPool(3); 
 for(inti=1;i<5;i++){ 
 finalinttaskID=i; 
 threadPool.execute(newRunnable(){ 
 publicvoidrun(){ 
 for(inti=1;i<5;i++){ 
 try{ 
 Thread.sleep(20);//为了测试出效果，让每次任务执行都需要一定时间 
 }catch(InterruptedExceptione){ 
 e.printStackTrace(); 
 } 
 System.out.println("第"+taskID+"次任务的第"+i+"次执行"); 
 } 
 } 
 }); 
 } 
 threadPool.shutdown();//任务执行完毕，关闭线程池 
 } 
 } 

输出结果：

[java]view plaincopyprint? 
     
   
 第1次任务的第1次执行 
 第2次任务的第1次执行 
 第3次任务的第1次执行 
 第2次任务的第2次执行 
 第3次任务的第2次执行 
 第1次任务的第2次执行 
 第3次任务的第3次执行 
 第1次任务的第3次执行 
 第2次任务的第3次执行 
 第3次任务的第4次执行 
 第2次任务的第4次执行 
 第1次任务的第4次执行 
 第4次任务的第1次执行 
 第4次任务的第2次执行 
 第4次任务的第3次执行 
 第4次任务的第4次执行 

上段代码中，创建了一个固定大小的线程池，容量为3，然后循环执行了4个任务，由输出结果可以看到，前3个任务首先执行完，然后空闲下来的线程去执行第4个任务，在FixedThreadPool中，有一个固定大小的池，如果当前需要执行的任务超过了池大小，那么多于的任务等待状态，直到有空闲下来的线程执行任务，而当执行的任务小于池大小，空闲的线程也不会去销毁。
2. CachedThreadPool

上段代码其它地方不变，将newFixedThreadPool方法换成newCachedThreadPool方法。

输出结果：

[java]view plaincopyprint? 
     
   
 第3次任务的第1次执行 
 第4次任务的第1次执行 
 第1次任务的第1次执行 
 第2次任务的第1次执行 
 第4次任务的第2次执行 
 第3次任务的第2次执行 
 第2次任务的第2次执行 
 第1次任务的第2次执行 
 第2次任务的第3次执行 
 第3次任务的第3次执行 
 第1次任务的第3次执行 
 第4次任务的第3次执行 
 第2次任务的第4次执行 
 第4次任务的第4次执行 
 第3次任务的第4次执行 
 第1次任务的第4次执行 

可见，4个任务是交替执行的，CachedThreadPool会创建一个缓存区，将初始化的线程缓存起来，如果线程有可用的，就使用之前创建好的线程，如果没有可用的，就新创建线程，终止并且从缓存中移除已有60秒未被使用的线程。

3. SingleThreadExecutor 上段代码其它地方不变，将newFixedThreadPool方法换成newSingleThreadExecutor方法。输出结果：

[java]view plaincopyprint? 
     
   
 第1次任务的第1次执行 
 第1次任务的第2次执行 
 第1次任务的第3次执行 
 第1次任务的第4次执行 
 第2次任务的第1次执行 
 第2次任务的第2次执行 
 第2次任务的第3次执行 
 第2次任务的第4次执行 
 第3次任务的第1次执行 
 第3次任务的第2次执行 
 第3次任务的第3次执行 
 第3次任务的第4次执行 
 第4次任务的第1次执行 
 第4次任务的第2次执行 
 第4次任务的第3次执行 
 第4次任务的第4次执行 

4个任务是顺序执行的，SingleThreadExecutor得到的是一个单个的线程，这个线程会保证你的任务执行完成，如果当前线程意外终止，会创建一个新线程继续执行任务，这和我们直接创建线程不同，也和newFixedThreadPool(1)不同。

4.ScheduledThreadPool

[java]view plaincopyprint? 
     
   
 importjava.util.concurrent.ScheduledExecutorService; 
 importjava.util.concurrent.TimeUnit; 
 publicclassThreadPoolTest{ 
 publicstaticvoidmain(String[]args){ 
 ScheduledExecutorServiceschedulePool=Executors.newScheduledThreadPool(1); 
 //5秒后执行任务 
 schedulePool.schedule(newRunnable(){ 
 publicvoidrun(){ 
 System.out.println("爆炸"); 
 } 
 },5,TimeUnit.SECONDS); 
 //5秒后执行任务，以后每2秒执行一次 
 schedulePool.scheduleAtFixedRate(newRunnable(){ 
 @Override 
 publicvoidrun(){ 
 System.out.println("爆炸"); 
 } 
 },5,2,TimeUnit.SECONDS); 
 } 
 } 

ScheduledThreadPool是一个固定大小的线程池，与FixedThreadPool类似，执行的任务是定时执行。

Java的并发包很强大，上面所说只是入门，下面是Callable和Future，它俩很有意思的，一个产生结果，一个拿到结果。

Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值，下面来看一个简单的例子：

[java] view plain copy print ?

publicclassCallableAndFuture{
publicstaticvoidmain(String[]args){
Callable<Integer>callable=newCallable<Integer>(){
publicIntegercall()throwsException{
returnnewRandom().nextInt(100);
}
};
FutureTask<Integer>future=newFutureTask<Integer>(callable);
newThread(future).start();
try{
Thread.sleep(5000);//可能做一些事情
System.out.println(future.get());
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}
}
}

FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值，那么这个组合的使用有什么好处呢？假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到，岂不美哉！这里有一个Future模式的介绍：http://caterpillar.onlyfun.net/Gossip/DesignPattern/FuturePattern.htm。

下面来看另一种方式使用Callable和Future，通过ExecutorService的submit方法执行Callable，并返回Future，代码如下：

[java] view plain copy print ?

publicclassCallableAndFuture{
publicstaticvoidmain(String[]args){
ExecutorServicethreadPool=Executors.newSingleThreadExecutor();
Future<Integer>future=threadPool.submit(newCallable<Integer>(){
publicIntegercall()throwsException{
returnnewRandom().nextInt(100);
}
});
try{
Thread.sleep(5000);//可能做一些事情
System.out.println(future.get());
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}
}
}

代码是不是简化了很多，ExecutorService继承自Executor，它的目的是为我们管理Thread对象，从而简化并发编程，Executor使我们无需显示的去管理线程的生命周期，是JDK 5之后启动任务的首选方式。

执行多个带返回值的任务，并取得多个返回值，代码如下：

[java] view plain copy print ?

publicclassCallableAndFuture{
publicstaticvoidmain(String[]args){
ExecutorServicethreadPool=Executors.newCachedThreadPool();
CompletionService<Integer>cs=newExecutorCompletionService<Integer>(threadPool);
for(inti=1;i<5;i++){
finalinttaskID=i;
cs.submit(newCallable<Integer>(){
publicIntegercall()throwsException{
returntaskID;
}
});
}
//可能做一些事情
for(inti=1;i<5;i++){
try{
System.out.println(cs.take().get());
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}
}
}
}