JAVA5线程池使用

线程池是Java5提供的一个新技术，方便我们快速简洁的定义线程池。包括如下：

       诸如 Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器，这种方式可能是通过网络协议（例如 HTTP、FTP 或 POP）、通过 JMS 队列或者可能通过轮询数据库。不管请求如何到达，服务器应用程序中经常出现的情况是：单个任务处理的时间很短而请求的数目却是巨大的。

        构建服务器应用程序的一个过于简单的模型应该是：每当一个请求到达就创建一个新线程，然后在新线程中为请求服务。实际上，对于原型开发这种方法工作得很好，但如果试图部署以这种方式运行的服务器应用程序，那么这种方法的严重不足就很明显。每个请求对应一个线程（thread-per-request）方法的不足之一是：为每个请求创建一个新线程的开销很大；为每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源要比花在处理实际的用户请求的时间和资源更多。

        除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。在一个 JVM 里创建太多的线程可能会导致系统由于过度消耗内存而用完内存或“切换过度”。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目。

        线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。而且，通过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到获得一个线程来处理为止，从而可以防止资源不足。

Java5提供以下线程池：

缓存线程池(newCachedThreadPool)，可以创建任意个线程，每个任务过来后都会创建一个线程，用于任务少，或执行时间短的任务，例如我们创建十个任务，那么缓冲线程池将会创建十个线程来执行。如下代码：

[java] view plaincopy

1. ExecutorService threadPool = Executors.newCachedThreadPool();  
2.           
3.         for(int i=1; i<=10; i++){  
4.             final int taskId = i;  
5.             threadPool.execute(new Runnable(){  
6.       
7.                 public void run() {  
8.                     for(int i=1; i<=10; i++){  
9.                         System.out.println(Thread.currentThread().getName() + " is looping of " + i + " the task is " + taskId);  
10.                         try {  
11.                             Thread.sleep(20);  
12.                         } catch (InterruptedException e) {  
13.                             // TODO Auto-generated catch block  
14.                             e.printStackTrace();  
15.                         }  
16.                           
17.                     }  
18.                 }  
19.                   
20.             });  
21.         }  
22.         System.out.println("add  all of 10 task");  
23.         threadPool.shutdown();  

固定数量线程池（newFixedThreadPool）允许我们创建固定线程数量的线程池，如果任务数大于线程池中线程的数量，那么任务将等待，如下代码：

[java] view plaincopy

1. ExecutorService threadPool = Executors.newFixedThreadPool(3);         
2. for(int i=1; i<=10; i++){  
3.     final int taskId = i;  
4.     threadPool.execute(new Runnable(){  
5.   
6.         public void run() {  
7.             for(int i=1; i<=10; i++){  
8.                 System.out.println(Thread.currentThread().getName() + " is looping of " + i + " the task is " + taskId);  
9.                 try {  
10.                     Thread.sleep(20);  
11.                 } catch (InterruptedException e) {  
12.                     // TODO Auto-generated catch block  
13.                     e.printStackTrace();  
14.                 }  
15.                   
16.             }  
17.         }  
18.           
19.     });  
20. }  
21. System.out.println("add  all of 10 task");  
22. threadPool.shutdown();  

如何实现线程挂掉后重新启动（创建单一的线程池）newSingleThreadExecutor()，这样线程池中只会有一个线程工作，当线程失败后会重新创建一个线程将失败的线程替换掉

定时器线程池（scheduleAtFixedRate）与定时器很类似，可以指定线程池中线程在多长时间后执行，以及每个多长时间执行一次，代码如下，可以模拟让炸弹在6s后爆炸，并且每隔2s炸一次：

[java] view plaincopy

1. Executors.newScheduledThreadPool(3).scheduleAtFixedRate(  
2. //      .schedule(  
3.                 new Runnable(){  
4.   
5.             public void run() {  
6.                 System.out.println("boming");  
7.             }  
8.               
9.         }, 6, 2, TimeUnit.SECONDS);  
10.     }