本文可作为传智播客《张孝祥-Java多线程与并发库高级应用》视频的学习记录。
为什么需要并发池
之前写并发的时候
new Thread(new Runnable(){
public void run{
//....
}
}).start();
没有什么问题呀,为什么需要并发池呢?
我们拿tomcat来举个例子。每次我们对服务器做一个请求,tomcat就得分出一个线程来处理我们的事。那么是不是,我们每次发一个请求,tomcat就像上面那样启动一个线程,等到run方法执行完了,这个线程也就死了。如果真是这样,来100个请求,tomcat就得产生100个线程,然后100个线程都死了,下一个请求一来,tomcat还得再创建一个线程。(创建一个线程还是有时间花费的。)
真是情况是这样的,tomcat就像酒店里的一个领班,她手底下有10个服务员,每次来一个顾客,就从那10个服务员里找一个人来和顾客交流。等服务员和顾客交流完了,那个服务再回到他们原来10个人呆的地方,等待她自己的下一位顾客。如果酒店里同时涌进来15个顾客。那么就是10个服务员同时出动,当然还有5个顾客没有人招待,怎么办?等着呗,等前面某位服务员忙完了,再来招呼那5个被阻塞的顾客。
那10个服务员就可以理解为一个"服务池"。
这样说,线程池存在的必要性大家应该都懂了吧。
java5之后的线程池
java5后的线程池主要就是指
java.util.concurrent Interface ExecutorService
它一般使用
java.util.concurrent Class Executors 这个类来产生。
我们看看不同的产生方式。
1
ExecutorService threadPool = Executors.newFixedThreadPool(3);
这种线程池里,只有3个线程。
2
ExecutorService threadPool = Executors.newCachedThreadPool();
线程池里的线程的数量会根据任务数而动态分配。
3
ExecutorService threadPool = Executors.newSingleThreadExecutor();
线程池里只有一个线程,如果当前执行任务的线程中断了,池子会自己创建一个新线程替代它。
4
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool();
创建一个可安排在给定延迟后运行命令或者定期地执行的线程池。
newFixedThreadPool
package thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolTest2 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
for (int i = 1; i <= 5; i++) {
final int task = i;
threadPool.execute(new Runnable() {
@Override
public void run() {
for (int j = 1; j <= 5; j++) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ " is looping of " + j + " for task of "
+ task);
}
}
});
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("all of 10 tasks have committed! ");
//这里是关闭所有线程 有可能上面的任务还没有执行完,
//因此上面让主线程睡2秒 保证任务执行完毕
threadPool.shutdownNow();
}
}
看看结果
pool-1-thread-1 is looping of 1 for task of 1
pool-1-thread-2 is looping of 1 for task of 2
pool-1-thread-3 is looping of 1 for task of 3
pool-1-thread-3 is looping of 2 for task of 3
pool-1-thread-2 is looping of 2 for task of 2
pool-1-thread-1 is looping of 2 for task of 1
pool-1-thread-1 is looping of 3 for task of 1
pool-1-thread-2 is looping of 3 for task of 2
pool-1-thread-3 is looping of 3 for task of 3
pool-1-thread-3 is looping of 4 for task of 3
pool-1-thread-2 is looping of 4 for task of 2
pool-1-thread-1 is looping of 4 for task of 1
pool-1-thread-1 is looping of 5 for task of 1
pool-1-thread-2 is looping of 5 for task of 2
pool-1-thread-3 is looping of 5 for task of 3
pool-1-thread-1 is looping of 1 for task of 4
pool-1-thread-2 is looping of 1 for task of 5
pool-1-thread-1 is looping of 2 for task of 4
pool-1-thread-2 is looping of 2 for task of 5
pool-1-thread-2 is looping of 3 for task of 5
pool-1-thread-1 is looping of 3 for task of 4
pool-1-thread-1 is looping of 4 for task of 4
pool-1-thread-2 is looping of 4 for task of 5
pool-1-thread-2 is looping of 5 for task of 5
pool-1-thread-1 is looping of 5 for task of 4
all of 10 tasks have committed!
是task of1 2 3 运行完毕后4 5才出来的。为什么?因为池子里只有三个线程。
newCachedThreadPool
我们把产生线程池的代码换成如下:
ExecutorService threadPool = Executors.newCachedThreadPool();
结果
pool-1-thread-1 is looping of 1 for task of 1
pool-1-thread-2 is looping of 1 for task of 2
pool-1-thread-3 is looping of 1 for task of 3
pool-1-thread-4 is looping of 1 for task of 4
pool-1-thread-5 is looping of 1 for task of 5
pool-1-thread-5 is looping of 2 for task of 5
pool-1-thread-4 is looping of 2 for task of 4
pool-1-thread-3 is looping of 2 for task of 3
pool-1-thread-2 is looping of 2 for task of 2
pool-1-thread-1 is looping of 2 for task of 1
pool-1-thread-1 is looping of 3 for task of 1
pool-1-thread-2 is looping of 3 for task of 2
pool-1-thread-3 is looping of 3 for task of 3
pool-1-thread-4 is looping of 3 for task of 4
pool-1-thread-5 is looping of 3 for task of 5
pool-1-thread-5 is looping of 4 for task of 5
pool-1-thread-4 is looping of 4 for task of 4
pool-1-thread-3 is looping of 4 for task of 3
pool-1-thread-2 is looping of 4 for task of 2
pool-1-thread-1 is looping of 4 for task of 1
pool-1-thread-5 is looping of 5 for task of 5
pool-1-thread-4 is looping of 5 for task of 4
pool-1-thread-3 is looping of 5 for task of 3
pool-1-thread-2 is looping of 5 for task of 2
pool-1-thread-1 is looping of 5 for task of 1
all of 10 tasks have committed!
看到了吧 5个任务都启动了。因为线程池里动态给加线程的。
newSingleThreadExecutor
我们把产生线程池的代码换成如下:
ExecutorService threadPool = Executors.newSingleThreadExecutor();
pool-1-thread-1 is looping of 1 for task of 1
pool-1-thread-1 is looping of 2 for task of 1
pool-1-thread-1 is looping of 3 for task of 1
pool-1-thread-1 is looping of 4 for task of 1
pool-1-thread-1 is looping of 5 for task of 1
pool-1-thread-1 is looping of 1 for task of 2
pool-1-thread-1 is looping of 2 for task of 2
pool-1-thread-1 is looping of 3 for task of 2
pool-1-thread-1 is looping of 4 for task of 2
pool-1-thread-1 is looping of 5 for task of 2
pool-1-thread-1 is looping of 1 for task of 3
pool-1-thread-1 is looping of 2 for task of 3
pool-1-thread-1 is looping of 3 for task of 3
pool-1-thread-1 is looping of 4 for task of 3
pool-1-thread-1 is looping of 5 for task of 3
pool-1-thread-1 is looping of 1 for task of 4
pool-1-thread-1 is looping of 2 for task of 4
pool-1-thread-1 is looping of 3 for task of 4
pool-1-thread-1 is looping of 4 for task of 4
pool-1-thread-1 is looping of 5 for task of 4
pool-1-thread-1 is looping of 1 for task of 5
pool-1-thread-1 is looping of 2 for task of 5
pool-1-thread-1 is looping of 3 for task of 5
pool-1-thread-1 is looping of 4 for task of 5
pool-1-thread-1 is looping of 5 for task of 5
all of 10 tasks have committed!
里面只有一个线程,自然看上去就是顺序执行了。
另外关于这个"如果当前执行任务的线程中断了,池子会自己创建一个新线程替代它"
我还不知道具体的例子。
newScheduledThreadPool
ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1);
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolTest {
public static void main(String[] args) {
ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1);
// 5秒后执行任务
schedulePool.schedule(new Runnable() {
public void run() {
System.out.println("爆炸");
}
}, 5, TimeUnit.SECONDS);
// 5秒后执行任务，以后每2秒执行一次
schedulePool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("爆炸");
}
}, 5, 2, TimeUnit.SECONDS);
try {
Thread.sleep(10*1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
schedulePool.shutdown();
}
}
第四个例子参见
http://blog.csdn.net/dlf123321/article/details/42741743
传统定时器