java5后的并发池

本文可作为传智播客《张孝祥-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

传统定时器

参考资料

http://blog.csdn.net/ghsau/article/details/7443324