Java 并发编程之线程池的使用（一）

目录(?)[+]

在任务与执行策略之间的隐性耦合

Executor框架可以将任务的提交与任务的执行策略解耦开来（就是独立化）。虽然Executor框架为制定和修改执行策略都提供了相当大的灵活性，但并非所有的任务都能适用所有的执行策略

比如：

依赖性任务

比如依赖于执行时序，执行结果或者其他效果，那么任务就带有隐含的依赖性。此时必须小心 地维持这些执行策略以避免产生活跃性问题（死锁等造成执行困难的问题）

使用线程封闭机制的任务

与线程池相比，单线程的Executor能够对并发性做出更强的承诺，它们能确保任务不会并发地执行。

对响应时间敏感的任务

比如GUI任务。如果将一个运行时间较长的任务提交到单线程的Executor中。或者将多个运行时间较长的任务提交到一个只包含少量线程的线程池中，那么会降低该 Executor的响应性。

使用ThreadLocal的任务

ThreadLocal使每个线程都可以拥有某个变量的私有版本，然而。只要条件允许Executor可以自由地重用这些线程。在标准的Executor中，当执行需求较低时将回收空间线程，而当需求增加时将添加新的线程，并且如果从任务 中招聘了一个未检查异常，那么 将用一个新的线程去替代 这个发生问题的线程。只有当线程本地值的生命周期受限于任务的生命周期时，在线程池的线程中使用ThreadLocal才有意义 ，而在线程池的线程中不应该使用Threadlocal在任务之间传递值。

最后，只有当任务都是同类型并且相互独立时，线程池的性能才能达到最佳。如果 将运行时间相差较大的任务放在同一个线程池中，那么除非线程池足够大，否则就会造成阻塞。。一般的基于网络的典型服务器应用 程序 中，如网页服务器，邮件服务器和文件服务器它们的请求都是同类型并且 相互独立的 。

记得讲你的执行策略写入文档，那么 将来的维护人员就不会由于使用了错误的执行策略而破坏了安全性和活跃性。

线程饥饿死锁

如果是单线程的Executor。如果提交了两个任务，两个任务相互依赖对方的执行结果，那么就会造成死锁。

举个栗子：

[java]  view plain copy print ?

1. import java.lang.ProcessBuilder.Redirect;  
2. import java.util.concurrent.Callable;  
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.Future;  
6.   
7. public class ThreadDeadlock {  
8.     ExecutorService exec = Executors.newSingleThreadExecutor();  
9.   
10.     public static void main(String[] args) {  
11.         try {  
12.             ThreadDeadlock tdl = new ThreadDeadlock();  
13.   
14.             System.out.println(tdl.new ReaderPageTask().call());  
15.         } catch (Exception e) {  
16.             // TODO Auto-generated catch block  
17.             e.printStackTrace();  
18.         }  
19.     }  
20.   
21.     public class ReaderPageTask implements Callable<String> {  
22.   
23.         @Override  
24.         public String call() throws Exception {  
25.             // TODO Auto-generated method stub  
26.             Future<String> header, footer;  
27.             header = exec.submit(new LoadFileTask("header.html"));  
28.             footer = exec.submit(new LoadFileTask("footer.html"));  
29.             String page = "bodyyyyyyyyyyyyyyy";  
30.             //将发生死锁，由于任务在等待子任务的结果  
31.             return header.get() + page + footer.get();  
32.         }  
33.     }  
34.   
35.     public class LoadFileTask implements Callable<String> {  
36.   
37.         public LoadFileTask(String filepath) {  
38.             super();  
39.             // TODO Auto-generated constructor stub  
40.         }  
41.   
42.         @Override  
43.         public String call() throws Exception {  
44.             // TODO Auto-generated method stub  
45.             return "sdf";  
46.         }  
47.     }  
48. }  

上面这个栗子是可以运算出结果的。可是相对来说慢了很多.属于线程饥饿死锁。
死锁并不是一定要“死”，看一下死锁的定义 。

死锁的规范定义：集合中的每一个进程都在等待只能由本集合中的其他进程才能引发的事件，那么该组进程是死锁的。

除了线程池大小的显式限制外，还有很多由于外部资源限制而导致的死锁，比如jdbc限制有10个连接 ，那么 每个线程都需要一个连接 ，已经有十个线程在线程池内运行，那么接下来的线程虽然 已经在线程池内了，可是因为无法取得与数据库的连接而阻塞。

运行时间较长的任务

如果任务阻塞时间过长，那么即使不出现死锁 ，线程池的响应性也会变得糟糕。Java早就准备好了解决问题的方法 。大多数可阻塞的方法中java的库内都有限时版本和不限时版本，比如Thread.join.Blockingqueue.put.CountDownLatch.await以及Select.select等。如果等待超时，可以把任务标识为失败，然后中止任务或者将任务重新放回队列，甚至可以加上计数器。如果几次失败仍如此那么 再中止它。如果线程池内总是充满了被阻塞的任务，那么 也可能说明是线程池的规模过小。

下面举个栗子，我也是弄了半天才明白Thread.join（timeout）的意思 

[java]  view plain copy print ?

1. public class ThreadDeadlock {  
2.     public Boolean flag = false;  
3.   
4.     public static void main(String[] args) {  
5.         testThread tt = new ThreadDeadlock().new testThread();  
6.         testThread1 tt1 = new ThreadDeadlock().new testThread1();  
7.         tt1.start();  
8.   
9.         try {  
10.             tt1.join(200);  
11.         } catch (InterruptedException e) {  
12.             // TODO Auto-generated catch block  
13.             e.printStackTrace();  
14.         }  
15.         tt.start();  
16.       
17.     }  
18.   
19.     class testThread extends Thread {  
20.   
21.         @Override  
22.         public void run() {  
23.             int result = 0;  
24.             // TODO Auto-generated method stub  
25.             while (true)  
26.                 System.out.println(result);  
27.   
28.         }  
29.   
30.     }  
31.   
32.     class testThread1 extends Thread {  
33.         @Override  
34.         public void run() {  
35.             int result = 10;  
36.             while (true)  
37.                 System.out.println(result);  
38.         }  
39.   
40.     }  
41.   
42. }  

结果是。先是输出了200毫秒的10.然后开始输出0.也就是说join的超时机制是先执行Join的那个线程的任务，让它优先完成。但是如果设置了超时之后 ，如果在这个时间段内它仍不能完成任务，则放弃阻塞。并发地执行接下来的任务