java ExecutorService的几种线程池比较_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
java ExecutorService的几种线程池比较
上传于|0|0|文档简介
&&简要记录java ExecutorService的几种线程池比较;
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
你可能喜欢线程池newFixedThreadPool -
- ITeye技术网站
博客分类：
public static
ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
import java.util.R
import java.util.concurrent.ExecutorS
import java.util.concurrent.E
import java.util.concurrent.TimeU
public class ExecutorTest {
public static void main(String args[]) {
Random random = new Random();
//产生一个 ExecutorService 对象，这个对象带有一个大小为 poolSize 的线程池，若任务数量大于 poolSize ，任务会被放在一个 queue 里顺序执行。
ExecutorService executor = Executors.newFixedThreadPool(3);
// 判断可是线程池可以结束
int waitTime = 500;
for (int i = 0; i & 10; i++) {
String name = "线程 " +
int time = random.nextInt(1000);
waitTime +=
Runnable runner = new ExecutorThread(name, time);
System.out.println("增加: " + name + " / " + time);
executor.execute(runner);
Thread.sleep(waitTime);
executor.shutdown();
executor.awaitTermination(waitTime, TimeUnit.MILLISECONDS);
} catch (InterruptedException ignored) {
class ExecutorThread implements Runnable {
private final S
public ExecutorThread(String name, int delay) {
this.name =
this.delay =
public void run() {
System.out.println("启动: " + name);
Thread.sleep(delay);
} catch (InterruptedException ignored) {
System.out.println("完成: " + name);
将poolsize取不同值，得到的结果如下：
由上结果可以看出，线程池最多处理的线程数=poolsize。
需要注意的是
Executors 是一个类，不是
Executor 的复数形式。该类是一个辅助类，此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
此类支持以下各种方法：
o 创建并返回设置有常用配置字符串的 ExecutorService 的方法。
o 创建并返回设置有常用配置字符串的
ScheduledExecutorService 的方法。
o 创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
o 创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
o创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。
提供了以下一些 static 的方法：
callable(Runnable
Runnable 的任务转化成
Callable 的任务
newSingleThreadExecutor:
产生一个 ExecutorService 对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
newCachedThreadPool():
产生一个 ExecutorService 对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
newFixedThreadPool(int
poolSize) ： 产生一个 ExecutorService 对象，这个对象带有一个大小为 poolSize 的线程池，若任务数量大于 poolSize ，任务会被放在一个 queue 里顺序执行。
newSingleThreadScheduledExecutor
：产生一个 ScheduledExecutorService 对象，这个对象的线程池大小为 1 ，若任务多于一个，任务将按先后顺序执行。
newScheduledThreadPool(int
poolSize): 产生一个
ScheduledExecutorService 对象，这个对象的线程池大小为 poolSize ，若任务数量大于 poolSize ，任务会在一个 queue 里等待执行。
修改上面的代码，测试一下newCachedThreadPool，由结果可知：线程池大小按需最大可达10.而newSingleThreadExecutor只有一个线程。结果如下：
浏览: 25851 次
来自: 北京主题信息（必填）
主题描述（最多限制在50个字符）
申请人信息（必填）
申请信息已提交审核，请注意查收邮件，我们会尽快给您反馈。
如有疑问，请联系
CSDN内容运营，关注前端开发、用户体验技术领域，希望携手更多技术专家，共同推进两大领域的向前发展。研发心得、项目实战、前沿技术……，只要是技术干货，十分欢迎您投稿至chenqg#csdn.net。人人都是主编，这里就是你的舞台。曾负责CSDN知识库产品内容运营，致力于为大家提供精华、专业的内容服务。
关注大数据、云计算、人工智能、IoT、移动开发领域
学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码： 我们一起学Java！
最近在改进项目的并发功能，但开发起来磕磕碰碰的。看了好多资料，总算加深了认识。于是打算配合查看源代码，总结并发编程的原理。准备从用得最多的线程池（一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。）开始，围绕创建、执行、关闭认识线程池整个生命周期的实现原理。后续再研究原子变量、并发容器、阻塞队列、同步工具、锁等等主题。java.util.concurrent里的并发工具用起来不难，但不能仅仅会用，我们要read the fucking source code，哈哈。顺便说声，我用的JDK是1.8。Executor框架Executor是一套线程池管理框架，接口里只有一个方法execute，执行Runnable任务。ExecutorService接口扩展了Executor，添加了线程生命周期的管理，提供任务终止、返回任务结果等方法。AbstractExecutorService实现了ExecutorService，提供例如submit方法的默认实现逻辑。然后到今天的主题ThreadPoolExecutor，继承了AbstractExecutorService，提供线程池的具体实现。构造方法下面是ThreadPoolExecutor最普通的构造函数，最多有七个参数。具体代码不贴了，只是一些参数校验和设置的语句。public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue&Runnable& workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
corePoolSize是线程池的目标大小，即是线程池刚刚创建起来，还没有任务要执行时的大小。maximumPoolSize是线程池的最大上限。keepAliveTime是线程的存活时间，当线程池内的线程数量大于corePoolSize，超出存活时间的空闲线程就会被回收。unit就不用说了，剩下的三个参数看后文的分析。预设的定制线程池ThreadPoolExecutor预设了一些已经定制好的线程池，由Executors里的工厂方法创建。下面分析newSingleThreadExecutor、newFixedThreadPool、newCachedThreadPool的创建参数。newFixedThreadPoolpublic static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue&Runnable&());
newFixedThreadPool的corePoolSize和maximumPoolSize都设置为传入的固定数量，keepAliveTim设置为0。线程池创建后，线程数量将会固定不变，适合需要线程很稳定的场合。newSingleThreadExecutorpublic static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue&Runnable&()));
newSingleThreadExecutor是线程数量固定为1的newFixedThreadPool版本，保证池内的任务串行。注意到返回的是FinalizableDelegatedExecutorService，来看看源码：static class FinalizableDelegatedExecutorService
extends DelegatedExecutorService {
FinalizableDelegatedExecutorService(ExecutorService executor) {
super(executor);
protected void finalize() {
super.shutdown();
FinalizableDelegatedExecutorService继承了DelegatedExecutorService，仅仅在gc时增加关闭线程池的操作，再来看看DelegatedExecutorService的源码：static class DelegatedExecutorService extends AbstractExecutorService {
private final ExecutorS
DelegatedExecutorService(ExecutorService executor) { e = }
public void execute(Runnable command) { e.execute(command); }
public void shutdown() { e.shutdown(); }
public List&Runnable& shutdownNow() { return e.shutdownNow(); }
public boolean isShutdown() { return e.isShutdown(); }
public boolean isTerminated() { return e.isTerminated(); }
代码很简单，DelegatedExecutorService包装了ExecutorService，使其只暴露出ExecutorService的方法，因此不能再配置线程池的参数。本来，线程池创建的参数是可以调整的，ThreadPoolExecutor提供了set方法。使用newSingleThreadExecutor目的是生成单线程串行的线程池，如果还能配置线程池大小，那就没意思了。Executors还提供了unconfigurableExecutorService方法，将普通线程池包装成不可配置的线程池。如果不想线程池被不明所以的后人修改，可以调用这个方法。newCachedThreadPoolpublic static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue&Runnable&());
newCachedThreadPool生成一个会缓存的线程池，线程数量可以从0到Integer.MAX_VALUE，超时时间为1分钟。线程池用起来的效果是：如果有空闲线程，会复用线程；如果没有空闲线程，会新建线程；如果线程空闲超过1分钟，将会被回收。newScheduledThreadPool
newScheduledThreadPool将会创建一个可定时执行任务的线程池。这个不打算在本文展开，后续会另开文章细讲。等待队列
newCachedThreadPool的线程上限几乎等同于无限，但系统资源是有限的，任务的处理速度总有可能比不上任务的提交速度。因此，可以为ThreadPoolExecutor提供一个阻塞队列来保存因线程不足而等待的Runnable任务，这就是BlockingQueue。JDK为BlockingQueue提供了几种实现方式，常用的有：ArrayBlockingQueue：数组结构的阻塞队列LinkedBlockingQueue：链表结构的阻塞队列PriorityBlockingQueue：有优先级的阻塞队列SynchronousQueue：不会存储元素的阻塞队列newFixedThreadPool和newSingleThreadExecutor在默认情况下使用一个无界的LinkedBlockingQueue。要注意的是，如果任务一直提交，但线程池又不能及时处理，等待队列将会无限制地加长，系统资源总会有消耗殆尽的一刻。所以，推荐使用有界的等待队列，避免资源耗尽。但解决一个问题，又会带来新问题：队列填满之后，再来新任务，这个时候怎么办？后文会介绍如何处理队列饱和。newCachedThreadPool使用的SynchronousQueue十分有趣，看名称是个队列，但它却不能存储元素。要将一个任务放进队列，必须有另一个线程去接收这个任务，一个进就有一个出，队列不会存储任何东西。因此，SynchronousQueue是一种移交机制，不能算是队列。newCachedThreadPool生成的是一个没有上限的线程池，理论上提交多少任务都可以，使用SynchronousQueue作为等待队列正合适。饱和策略
当有界的等待队列满了之后，就需要用到饱和策略去处理，ThreadPoolExecutor的饱和策略通过传入RejectedExecutionHandler来实现。如果没有为构造函数传入，将会使用默认的defaultHandler。private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
AbortPolicy是默认的实现，直接抛出一个RejectedExecutionException异常，让调用者自己处理。除此之外，还有几种饱和策略，来看一下：public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}DiscardPolicy的rejectedExecution直接是空方法，什么也不干。如果队列满了，后续的任务都抛弃掉。public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}DiscardOldestPolicy会将等待队列里最旧的任务踢走，让新任务得以执行。public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
}最后一种饱和策略是CallerRunsPolicy，它既不抛弃新任务，也不抛弃旧任务，而是直接在当前线程运行这个任务。当前线程一般就是主线程啊，让主线程运行任务，说不定就阻塞了。如果不是想清楚了整套方案，还是少用这种策略为妙。ThreadFactory
每当线程池需要创建一个新线程，都是通过线程工厂获取。如果不为ThreadPoolExecutor设定一个线程工厂，就会使用默认的defaultThreadFactory：public static ThreadFactory defaultThreadFactory() {
return new DefaultThreadFactory();
}作者：极乐科技
链接：https:
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String nameP
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
}平时打印线程池里线程的name时，会输出形如pool-1-thread-1之类的名称，就是在这里设置的。这个默认的线程工厂，创建的线程是普通的非守护线程，如果需要定制，实现ThreadFactory后传给ThreadPoolExecutor即可。不看代码不总结不会知道，光是线程池的创建就可以引出很多学问。别看平时创建线程池是一句代码的事，其实ThreadPoolExecutor提供了很灵活的定制方法。
学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码： 我们一起学Java！java并发（二十）线程池 - 猫头哥（朴海林）_QQ: - ITeye技术网站
博客分类：
基本介绍
线程池（Thread Pool）对于限制应用程序中同一时刻运行的线程数很有用。因为每启动一个新线程都会有相应的性能开销，每个线程都需要给栈分配一些内存等等。
我们可以把并发执行的任务传递给一个线程池，来替代为每个并发执行的任务都启动一个新的线程。只要池里有空闲的线程，任务就会分配给一个线程执行。在线程池的内部，任务被插入一个阻塞队列（Blocking Queue ），线程池里的线程会去取这个队列里的任务。当一个新任务插入队列时，一个空闲线程就会成功的从队列中取出任务并且执行它。
线程池经常应用在多线程服务器上。每个通过网络到达服务器的连接都被包装成一个任务并且传递给线程池。线程池的线程会并发的处理连接上的请求。以后会再深入有关 Java 实现多线程服务器的细节。
Java 5 在 java.util.concurrent 包中自带了内置的线程池，所以你不用非得实现自己的线程池。你可以阅读我写的 java.util.concurrent.ExecutorService 的文章以了解更多有关内置线程池的知识。不过无论如何，知道一点关于线程池实现的知识总是有用的。
这里有一个简单的线程池实现：
package com.chinaso.search.
import java.util.ArrayL
import java.util.L
import java.util.concurrent.ArrayBlockingQ
import java.util.concurrent.BlockingQ
* 线程池类，他是一个容器
* @author piaohailin
public class ThreadPool {
private BlockingQueue&Runnable& taskQueue = // 任务队列
private List&PoolThread& threads = new ArrayList&PoolThread&(); // 执行线程
private boolean isStopped = // 线程池运行状态
* @param noOfThreads
* @param maxNoOfTasks
public ThreadPool(int noOfThreads, int maxNoOfTasks) {
taskQueue = new ArrayBlockingQueue&Runnable&(maxNoOfTasks);
for (int i = 0; i & noOfT i++) {
threads.add(new PoolThread(taskQueue));
for (PoolThread thread : threads) {
thread.start();
* 提交任务
* @param task
public synchronized void execute(Runnable task) {
if (this.isStopped)
throw new IllegalStateException("ThreadPool is stopped");
this.taskQueue.put(task);
} catch (Exception e) {
e.printStackTrace();
* 关闭线程池
public synchronized boolean stop() {
this.isStopped =
for (PoolThread thread : threads) {
thread.interrupt();
return this.isS
package com.chinaso.search.
import java.util.concurrent.BlockingQ
* 线程对象，他运行在线程池中
* @author piaohailin
public class PoolThread extends Thread {
private BlockingQueue&Runnable& taskQueue = // 从线程池传递过来的任务队列引用
private boolean isStopped =// 线程运行状态
public PoolThread(BlockingQueue&Runnable& queue) {
taskQueue =
* 无限循环，阻塞调用
public void run() {
while (!isStopped()) {
Runnable runnable = taskQueue.take();//阻塞方法，如果队列里没有任务，则在此一直等待
runnable.run();
} catch (Exception e) {
// 写日志或者报告异常,
// 但保持线程池运行.
e.printStackTrace();
public synchronized void toStop() {
isStopped =
this.interrupt(); // 打断池中线程的 dequeue() 调用.
public synchronized boolean isStopped() {
return isS
线程池的实现由两部分组成。类 ThreadPool 是线程池的公开接口，而类 PoolThread 用来实现执行任务的子线程。
为了执行一个任务，方法 ThreadPool.execute(Runnable r) 用 Runnable 的实现作为调用参数。在内部，Runnable 对象被放入 阻塞队列 (Blocking Queue)，等待着被子线程取出队列。
一个空闲的 PoolThread 线程会把 Runnable 对象从队列中取出并执行。你可以在 PoolThread.run() 方法里看到这些代码。执行完毕后，PoolThread 进入循环并且尝试从队列中再取出一个任务，直到线程终止。
调用 ThreadPool.stop() 方法可以停止 ThreadPool。在内部，调用 stop 先会标记 isStopped 成员变量（为 true）。然后，线程池的每一个子线程都调用 PoolThread.stop() 方法停止运行。注意，如果线程池的 execute() 在 stop() 之后调用，execute() 方法会抛出 IllegalStateException 异常。
子线程会在完成当前执行的任务后停止。注意 PoolThread.stop() 方法中调用了 this.interrupt()。它确保阻塞在 taskQueue.dequeue() 里的 wait() 调用的线程能够跳出 wait() 调用（校对注：因为执行了中断interrupt，它能够打断这个调用），并且抛出一个 InterruptedException 异常离开 dequeue() 方法。这个异常在 PoolThread.run() 方法中被截获、报告，然后再检查 isStopped 变量。由于 isStopped 的值是 true, 因此 PoolThread.run() 方法退出，子线程终止。
java执行器（Executors）
java.util.concurrent中包括三个Executor接口：
Executor，一个运行新任务的简单接口。
ExecutorService，扩展了Executor接口。添加了一些用来管理执行器生命周期和任务生命周期的方法。
ScheduledExecutorService，扩展了ExecutorService。支持Future和定期执行任务。
通常来说，指向Executor对象的变量应被声明为以上三种接口之一，而不是具体的实现类。
Executor接口
Executor接口只有一个execute方法，用来替代通常创建（启动）线程的方法。例如：r是一个Runnable对象，e是一个Executor对象。
//可以使用
e.execute(r);
(new Thread(r)).start();
但execute方法没有定义具体的实现方式。对于不同的Executor实现，execute方法可能是创建一个新线程并立即启动，但更有可能是使用已有的工作线程运行r，或者将r放入到队列中等待可用的工作线程。（我们将在线程池一节中描述工作线程。）
ExecutorService接口
ExecutorService接口在提供了execute方法的同时，新加了更加通用的submit方法。submit方法除了和execute方法一样可以接受Runnable对象作为参数，还可以接受Callable对象作为参数。使用Callable对象可以能使任务返还执行的结果。通过submit方法返回的Future对象可以读取Callable任务的执行结果，或是管理Callable任务和Runnable任务的状态。
ExecutorService也提供了批量运行Callable任务的方法。最后，ExecutorService还提供了一些关闭执行器的方法。如果需要支持即时关闭，执行器所执行的任务需要正确处理中断。
ScheduledExecutorService接口
ScheduledExecutorService扩展ExecutorService接口并添加了schedule方法。调用schedule方法可以在指定的延时后执行一个Runnable或者Callable任务。ScheduledExecutorService接口还定义了按照指定时间间隔定期执行任务的scheduleAtFixedRate方法和scheduleWithFixedDelay方法。
结果组装CompletionService
CompletionService将Executor和BlockingQueue的功能融合在一起。你可以将Callable任务提交给它来执行，然后使用类似于队列操作的take和poll等方法来获得已经完成的结果，而这些结果会在完成时被封装为Future。ExecutorCompletionService实现了CompletionService，并将计算部分委托给一个Executor。
示例代码
Executor executor = Executors.newCachedThreadPool();
CompletionService&List&String&& completionService = new ExecutorCompletionService&List&String&&(executor);
completionService.submit(new Callable&List&String&&() {
public List&String& call() throws Exception {
List&String& data = new ArrayList&String&();
List&String& result = new ArrayList&String&();
for (int i = 0; i & threadC i++) {
result.addAll(completionService.take().get()); // 取得结果，如果没有返回，则阻塞
任务取消
一般在Executor任务框架里，任务是在线程中执行的。有固定数量的线程从阻塞的任务队列中，获取任务然后执行。任务取消有多种方式：
1.用户请求取消
2.有时间限制的操作
3.应用程序事件
4.错误
5.关闭
java线程池使用
在java.util.concurrent包中多数的执行器实现都使用了由工作线程组成的线程池，工作线程独立于所它所执行的Runnable任务和Callable任务，并且常用来执行多个任务。 使用工作线程可以使创建线程的开销最小化。
在大规模并发应用中，创建大量的Thread对象会占用占用大量系统内存，分配和回收这些对象会产生很大的开销。一种最常见的线程池是固定大小的线程池。这种线程池始终有一定数量的线程在运行，如果一个线程由于某种原因终止运行了，线程池会自动创建一个新的线程来代替它。需要执行的任务通过一个内部队列提交给线程，当没有更多的工作线程可以用来执行任务时，队列保存额外的任务。 使用固定大小的线程池一个很重要的好处是可以实现优雅退化。例如一个Web服务器，每一个HTTP请求都是由一个单独的线程来处理的，如果为每一个HTTP都创建一个新线程，那么当系统的开销超出其能力时，会突然地对所有请求都停止响应。如果限制Web服务器可以创建的线程数量，那么它就不必立即处理所有收到的请求，而是在有能力处理请求时才处理。 Executors类提供了下列一下方法：
newCachedThreadPool方法创建了一个可扩展的线程池。适合用来启动很多短任务的应用程序。将线程池的最大大小设置为Integer.MZX_VALUE。而将基本大小设置为0，超时时间设置为1分钟。
newSingleThreadExecutor方法创建了每次执行一个任务的执行器。
newFixedThreadPool方法将线程池的基本大小和最大大小设置额外icanshuzhong指定的值。而且创建的线程池不会超时。
还有一些创建ScheduledExecutorService执行器的方法。
原始接口使用
* 第一个参数为初始空闲
* 第二个参数为最大线程
* 第三个参数为超过coresize的空闲线程回收等待时间
* 第四个参数是第三个参数的时间单位
* 第五个参数是当超过最大线程数以后，可以放在队列中的线程
* 第六个参数
* 第七个参数是线程池任务队列塞满时候的饱和策略
private static int
corePoolSize
private static int
maximumPoolSize = 3;
private static long
keepAliveTime
private static TimeUnit
= TimeUnit.NANOSECONDS;
private static BlockingQueue&Runnable&
= new ArrayBlockingQueue&Runnable&(5);
private static ThreadFactory
threadFactory
= Executors.defaultThreadFactory();
* AbortPolicy 如果总线成熟超过maximumPoolSize + workQueue ，则跑异常java.util.concurrent.RejectedExecutionException
private static RejectedExecutionHandler handler
= new AbortPolicy();
private static ThreadPoolExecutor
= new ThreadPoolExecutor(
corePoolSize,
maximumPoolSize,
keepAliveTime,
workQueue,
threadFactory,
* 当keepAliveTime=0时
* 只有线程总数&=maximumPoolSize + workQueue时，才会按照maximumPoolSize的多线程数执行
* 否则按照corePoolSize的多线程数执行
* @param args
工厂方法使用
ExecutorService executor = Executors.newFixedThreadPool(10);
spring与线程池
&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"&
spring自带的线程池
&bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"&
&property name="corePoolSize" value="4" /& &!-- 并发线程数,想达到真正的并发效果,最好对应CPU的线程数及核心数 --&
&property name="maxPoolSize" value="10" /& &!-- 最大线程池容量 --&
&property name="queueCapacity" value="500" /& &!-- 超过最大线程池容量后,允许的线程队列数 --&
自定义线程池
&!-- 枚举类型、静态属性声明 --&
&bean id="nanoseconds" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"&
&property name="staticField" value="java.util.concurrent.TimeUnit.NANOSECONDS" /&
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue&Runnable& workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
&bean id="myThreadPool" class="java.util.concurrent.ThreadPoolExecutor"&
&constructor-arg index="0" value="4" /&
&constructor-arg index="1" value="10" /&
&constructor-arg index="2" value="0" /&
&constructor-arg index="3" ref="nanoseconds" /&
&constructor-arg index="4"&
&bean class="java.util.concurrent.ArrayBlockingQueue"&
&constructor-arg value="500" /&
&/constructor-arg&
&constructor-arg index="5"&
&!-- 此bean返回的是 java.util.concurrent.ThreadFactory--&
&bean class="java.util.concurrent.Executors" factory-method="defaultThreadFactory" /&
&/constructor-arg&
&constructor-arg index="6"&
&bean class="java.util.concurrent.ThreadPoolExecutor.AbortPolicy" /&
&/constructor-arg&
给工厂方法传参数
&bean id="exampleBean" class="...ExampleBeanFactory"
scope="prototype"
factory-method="createExampleBean"&
&constructor-arg value="default value"/&
浏览: 1075307 次
来自: 北京
你好，能说一下server.xml增加的配置是怎么影响性能的吗 ...
beyondfengyu 写道如果每个客户进程的时间不同步，时 ...
如果每个客户进程的时间不同步，时间超前的进程是不是更容易得到锁 ...
[i][b][flash=200,200][url][img] ...