目录
1、池介绍
自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的对象池、Integer的共享池、连接数据库的连接池、Struts1.3的对象池等等,池的最终目的都是节约资源,以更小的开销做更多的事情,从而提高性能。
2、线程池创建
我们的web项目都是部署在服务器上,浏览器端的每一个request就是一个线程,那么服务器需要并发的处理多个请求,就需要线程池技术,下面来看一下Java并发包下如何创建线程池。
单个线程 ------》多个线程的线程池-------- 〉无限个线程的线程池
1. 创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程
// 创建单个线程的线程池,如果当前线程在执行任务时突然中断,则会创建一个新的线程替代它继续执行任务
ExecutorService threadPool = Executors.newSingleThreadExecutor();
2. 创建一个可重用固定线程集合的线程池,以共享的无界队列方式来运行这些线程
// 可以容纳3个线程的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);
3. 创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们
// 线程池的大小会根据执行的任务数动态分配
ExecutorService threadPool = Executors.newCachedThreadPool();
4. 创建一个可安排在给定延迟后运行命令或者定期地执行的线程池
// 效果类似于Timer定时器
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);
3、线程池使用场景
每种线程池都有不同的使用场景,下面看一下这四种线程池使用起来有什么不同。
1. FixedThreadPool
public class ThreadPoolTest {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
for(int i = 1; i < 6; i++) {
final int taskID = i;
threadPool.execute(new Runnable() {
@Override
public void run() {
for(int i = 1; i < 5; i++) {
try {
Thread.sleep(20);// 为了测试出效果,让每次任务执行都需要一定时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第" + taskID + "个任务的第" + i + "次执行");
}
}
});
}
threadPool.shutdown();// 任务执行完毕,关闭线程池
}
}
第1个任务的第1次执行
第2个任务的第1次执行
第3个任务的第1次执行
第2个任务的第2次执行
第1个任务的第2次执行
第3个任务的第2次执行
第3个任务的第3次执行
第1个任务的第3次执行
第2个任务的第3次执行
第1个任务的第4次执行
第3个任务的第4次执行
第2个任务的第4次执行
第5个任务的第1次执行
第4个任务的第1次执行
第5个任务的第2次执行
第4个任务的第2次执行
第5个任务的第3次执行
第4个任务的第3次执行
第5个任务的第4次执行
第4个任务的第4次执行
说明:
上段代码中,创建了一个固定大小的线程池,容量为3。然后循环执行了5个任务,由输出结果可以看到,前3个任务首先执行完,然后空闲下来的线程去执行第4和5个任务。
在FixedThreadPool中,有一个固定大小的池,如果当前需要执行的任务超过了池大小,那么多于的任务等待状态,直到有空闲下来的线程执行任务,而当执行的任务小于池大小,空闲的线程也不会去销毁。
2、CachedThreadPool
public class ThreadPoolTest {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newCachedThreadPool();
for (int i = 1; i < 5; i++) {
final int taskId = i;
threadPool.execute(new Runnable() {
@Override
public void run() {
for (int j = 1; j < 5; j++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第" + taskId + "个任务" + "第" + j + "次执行");
}
}
});
}
threadPool.shutdown();
}
}
第4个任务第1次执行
第3个任务第1次执行
第1个任务第1次执行
第2个任务第1次执行
第4个任务第2次执行
第2个任务第2次执行
第1个任务第2次执行
第3个任务第2次执行
第4个任务第3次执行
第3个任务第3次执行
第1个任务第3次执行
第2个任务第3次执行
第4个任务第4次执行
第1个任务第4次执行
第3个任务第4次执行
第2个任务第4次执行
说明:
可见,4个任务是交替执行的,CachedThreadPool会创建一个缓存区,将初始化的线程缓存起来,如果线程有可用的,就使用之前创建好的线程,如果没有可用的,就新创建线程,终止并且从缓存中移除已有60秒未被使用的线程。
3、SingleThreadExecutor
public class ThreadPoolTest {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
for (int i = 1; i < 5; i++) {
final int taskId = i;
threadPool.execute(new Runnable() {
@Override
public void run() {
for (int j = 1; j < 5; j++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第" + taskId + "个任务" + "第" + j + "次执行");
}
}
});
}
threadPool.shutdown();
}
}
第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个任务是交替执行的,CachedThreadPool会创建一个缓存区,将初始化的线程缓存起来,如果线程有可用的,就使用之前创建好的线程,如果没有可用的,就新创建线程,终止并且从缓存中移除已有60秒未被使用的线程。
4、ScheduledThreadPool
public class ThreadPoolTest {
public static void main(String[] args) {
ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1);
// 5秒后执行任务
schedulePool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("5秒后执行一次任务");
}
}, 5, TimeUnit.SECONDS);
// 5秒后执行任务,以后每2秒执行一次
schedulePool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("5s后执行第一次,以后每2s执行一次");
}
}, 5, 2, TimeUnit.SECONDS);
}
}
爆炸
5s后执行,每2s执行一次
5s后执行,每2s执行一次
说明:
ScheduledThreadPool可以定时的或延时的执行任务。
下一篇:Callable/Future/FutureTask
原文链接:https://blog.csdn.net/ghsau/article/details/7443324