线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。
用线程池来管理的好处是,可以保证系统稳定运行,适用与有大量线程,高工作量的情景下使用,假如要展示1000张图片如果创建1000个线程去加载,保证系统会死掉。用线程池就可以避免这个问题,可以用5个线程轮流执行,5个一组,执行完的线程不直接回收而是等待下次执行,这样对系统的开销就可以减小不少。
===============================Executor的译文部分==================================
Executor是Java工具类,执行提交给它的Runnable任务。该接口提供了一种基于任务运行机制的任务提交方法,包括线程使用详细信息,时序等等。Executor通常用于替代创建多线程。例如:你可能会使用以下方式来代替创建线程集合中的线程newThread(new(RunnableTask())).start()。
Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
...
尽管如此,Executor接口没有明确要求执行过程是异步的。举个最简单的例子,一个Executor可以在调用者的线程中运行提交的任务。
class DirectExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}
更典型的是,任务也可以运行在其他的线程而不是调用者线程。以下代码就是在Executor中生成新的线程。
class ThreadPerTaskExecutor implements Executor {
public void execute(Runnable r) {
new Thread(r).start();
}
}
很多Executor的实现按照任务的实现方式和时间来分类,下面的代码将提交的任务序列化给第二个Executor,阐述了一个组合的Executor。
class SerialExecutor implements Executor {
final Queue tasks = new ArrayDeque();
final Executor executor;
Runnable active; SerialExecutor(Executor executor) {
this.executor = executor; public synchronized void execute(final Runnable r) {
tasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (active == null) {
scheduleNext();
}
} protected synchronized void scheduleNext() {
if ((active = tasks.poll()) != null) {
executor.execute(active);
}
}
}}
以上代码简答讲就是执行一个SerialExecutor
时,先执行
Runnable
的
run()
,然后再从
Tasks
任务堆栈中找到当前激活的任务并执行。
在这个
package
包中实现的
Executor
实现了
ExecutorService
,它是个扩展接口。
而
threadPoolExecutor
类提供了一个扩展的线程池实现。
Executors
类给这些
Executors
提供了方便的工程方法。
内存一致性效果
:在提交一个
Runnable
对象给
Executor
执行之前,线程中的行为可能先在另一个线程中发生。
===============================Executor的译文部分==================================
Java里面线程池的*接口是Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
根据线程池的执行策略,
Executor
的
execute()
可能在新线程中执行,或者在线程池中的某个线程中执行,也可能是在调用者线程中执行。
ExecutorService
在
Executor
的基础上增加了两个核心方法:
1
、
Future<?>submit(Runnable task)
2、<T>Future<T> submit(Callable<T> task)
差异点:这两个方法都可以向线程池提交任务,区别在于Runnable执行完run()有返回值,而Callable执行完call()后有返回值。
共同点:
submit
都返回
Future
对象,
Future
对象可以阻塞线程直到运行完毕,也可以取消任务执行和检测任务是否执行完毕。
在
executors
类里面提供了一些静态工厂,生成一些常用的线程池:
1
、
newSingleThreadExecutor:
创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
2
、
newFixedThreadPool:创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。
3
、
newCachedThreadPool:创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(
60
秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说
JVM
)能够创建的最大线程大小。
4
、
newScheduledThreadPool:创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
5
、
newSingleThreadExecutor:创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。
下面再介绍下
ThreadPoolExecutor
类,以便对线程池有进一步认识:
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
corePoolSize
:线程池维护线程的最少数量
maximumPoolSize
:线程池维护线程的最大数量
keepAliveTime
:线程池维护线程所允许的空闲时间
unit
:线程池维护线程所允许的空闲时间的单位
workQueue
:线程池所使用的缓冲队列
handler
:线程池对拒绝任务的处理策略
当一个任务通过
execute(Runnable)
方法欲添加到线程池时:
1
、
如果此时线程池中的数量小于corePoolSize
,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
2、如果此时线程池中的数量等于
corePoolSize
,但是缓冲队列
workQueue
未满,那么任务被放入缓冲队列。
3、如果此时线程池中的数量大于
corePoolSize
,缓冲队列
workQueue
满,并且线程池中的数量小于
maximumPoolSize
,建新的线程来处理被添加的任务。
4、如果此时线程池中的数量大于
corePoolSize
,缓冲队列
workQueue
满,并且线程池中的数量等于
maximumPoolSize
,那么通过
handler
所指定的策略来处理此任务。
也就是说,处理任务的优先级为:
核心线程
corePoolSize
、任务队列
workQueue
、最大线程
maximumPoolSize
,如果三者都满了,使用
handler
处理被拒绝的任务。
简单的例子:
ThreadPoolTestMain
.java
package threadpool.test; import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit; public class ThreadPoolTestMain {
private static final int CORE_POOL_SIZE = 2;
private static final int MAX_POOL_SIZE = 4;
private static final int KEEP_ACTIVE_TIME = 3;
private static final int TASK_NUM = 10;
private static final int PRODUCE_SLEEP_TIME = 10; static public void main(String[] args) {
// 构造一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAX_POOL_SIZE,
KEEP_ACTIVE_TIME,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy()); for (int i = 1; i < TASK_NUM; i++) {
String name = "Task" + i;
try {
System.out.println("ThreadPoolTestMain: put a task: " + name);
threadPool.execute(new ThreadPoolTask(name));
Thread.sleep(20);
} catch (Exception err) {
err.printStackTrace();
}
}
}
}
ThreadPoolTask
.java
package threadpool.test; public class ThreadPoolTask implements Runnable {
private String mTaskName;
private static int CONSUME_SLEEP_TIME = 2000; public ThreadPoolTask(String name) {
mTaskName = name;
} @Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName());
System.out.println("ThreadPoolTask :" + mTaskName); try {
Thread.sleep(CONSUME_SLEEP_TIME);
} catch (Exception err) {
err.printStackTrace();
}
} }
执行结果:
ThreadPoolTestMain:put a task: Task1
pool-1-thread-1
ThreadPoolTask:Task1
ThreadPoolTestMain:put a task: Task2
pool-1-thread-2
ThreadPoolTask:Task2
ThreadPoolTestMain:put a task: Task3
ThreadPoolTestMain:put a task: Task4
ThreadPoolTestMain:put a task: Task5
ThreadPoolTestMain:put a task: Task6
pool-1-thread-3
ThreadPoolTask:Task6
ThreadPoolTestMain:put a task: Task7
pool-1-thread-4
ThreadPoolTask:Task7
ThreadPoolTestMain:put a task: Task8
ThreadPoolTestMain:put a task: Task9
pool-1-thread-1
ThreadPoolTask:Task5
pool-1-thread-2
ThreadPoolTask:Task8
pool-1-thread-3
ThreadPoolTask:Task9