并发基础知识1

1并发的多面性  
并发编程令人困惑的一个主要原因是是：使用并发时需要解决的问题有多个，而实现并发的方式也有多种，并且这两者之间没有明显的映射关系。 
用并发解决的问题大体上分为“速度”和“设计可管理性”两种。 

1、更快的执行 
并发是用于多处理器编程的基本工具。 
但是，并发通常是提高运行在单处理器上的程序的性能。（但是，会出现上下文切换的代价） 
但是，单处理器上，还可以处理阻塞的问题。 
在处理单处理器系统中的性能提高的常见示例是事件驱动编程。 
实现并发最直接的方式是操作系统级别使用进程。（但是，任务之间对资源的使用是一个问题） 



2、改进代码设计 
协作多线程。Java的线程机制是抢占式的。 



2基本的线程机制  
1、定义任务 
线程可以驱动任务，因此你需要一种描述任务的方式，这可以由Runnable接口来提供。 
要想定义任务，只需实现Runnable接口并发编写run()方法，是的该任务可以执行你的命令。 
demo： 

view plain copy to clipboard print ?

1. public class LiftOff implements Runnable {  
2.     protected int countDown = 10;  
3.     private static int taskCount = 0;  
4.     /** 用来区分任务的多个实例 */  
5.     //因为他是final的,一旦被初始化之后就不希望被修改  
6.     private final int id = taskCount++;  
7.     public LiftOff(){}  
8.     public LiftOff(int countDown){  
9.         this.countDown = countDown;  
10.     }  
11.       
12.     public String status(){  
13.         return "#" + id + "(" + (countDown > 0 ?countDown : "LiftOff!") + "), ";  
14.     }  
15.       
16.     @Override  
17.     public void run() {  
18.         while(countDown-- > 0){  
19.             System.out.print(status());  
20.             //线程调度器：表示“我们已经执行完声明周期中最重要的部分了，此刻正是切换给其他任务执行一段时间的大好时机”  
21.             Thread.yield();  
22.         }  
23.     }  
24.       
25.     public static void main(String[] args) {  
26.         oneThread();  
27.     }  
28.       
29.     /** 
30.      * main只是一个单线程的调用 
31.      */  
32.     private static void oneThread() {  
33.         LiftOff launch = new LiftOff();  
34.         launch.run();  
35. //      后台打印：  
36. //      #0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(LiftOff!),   
37.     }  
38. }  

2、Thread类 
将Runnable对象转变为工作任务的传统方式是把他提交给一个Thread构造器。 
Thread构造器只需要一个Runnable对象。调用Thread对象的start()方法为该线程执行必需的初始化操作，然后调用Runnable的run()方法，以便在这个新线程中启动该任务。

view plain copy to clipboard print ?

1.     public static void main(String[] args) {  
2.         moreBasicThreads();  
3.     }  
4.       
5.       
6.     /** 
7.      * 添加更多的线程去驱动更多的任务 
8.      */  
9.     private static void moreBasicThreads() {  
10.         for(int i=0;i<5;i++){  
11.             new Thread(new LiftOff()).start();  
12.         }  
13.         System.out.println("Waiting for LiftOff");  
14. //      后台打印：  
15. //      Waiting for LiftOff  
16. //      #4(9), #3(9), #1(9), #0(9), #1(8), #3(8), #2(9), #4(8), #2(8), #3(7), #1(7), #0(8), #1(6), #3(6), #3(5), #2(7), #4(7), #2(6), #3(4), #1(5), #2(5), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #2(4), #3(3), #1(4), #4(6), #1(3), #3(2), #2(3), #0(LiftOff!), #2(2), #2(1), #2(LiftOff!), #3(1), #1(2), #3(LiftOff!), #4(5), #1(1), #1(LiftOff!), #4(4), #4(3), #4(2), #4(1), #4(LiftOff!),   
17.     }  

3、使用Executor 
Java SE5的java.util.concurrent包中的执行器(Executor)将为你管理Thread对象，从而简化了并发编程。 
Executor在客户端和任务执行之间提供了一个间接层；与客户端直接执行任务不同，这个中介对象将执行任务。 
demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5.   
6. public class CachedTreadPool {  
7.   
8.     public static void main(String[] args) {  
9.         //我们可以使用Executor来代替显示的创建Thread对象  
10.         ExecutorService executorService = Executors.newCachedThreadPool();  
11.         for(int i=0;i<10;i++){  
12.             executorService.execute(new LiftOff());  
13.         }  
14.         executorService.shutdown();  
15.     }  
16.   
17. }  

单个的Executor被用来创建和管理系统中所有的任务。 

对shutDown方法的调用可以防止新任务被提交给这个Executor，当前线程将继续运行在shutDown()被调用之前的任务。完成任务后Executor会尽快退出。 


Executors.newFixedThreadPool(5)--FixedThreadPool： 
创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。 
一次性预先执行代价高昂的线程分配，因而也就可以限制线程的数量了。 
相反Executors.newCachedThreadPool()通常会创建与所需数量相同的线程，然后在他回收就线程时停止创建新线程。 
SingleThreadExecutor就像是线程数量为1的FixedThreadPool。 




4、从任务中产生返回值 
如果你希望任务在完成时能够返回一个值，可以实现Callable接口。 
在Java SE5中引用的Callable是一种具有类型参数的泛型，他的类型参数表示是从方法call()中返回的值，并且必须是使用ExecutorService.submit()方法调用他。 
demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.Callable;  
4.   
5. /** 
6. * 具有返回值的任务 
7. * @author partner4java 
8. * 
9. */  
10. public class TaskWithResult implements Callable<String> {  
11.     private int id;  
12.   
13.     public TaskWithResult(int id) {  
14.         this.id = id;  
15.     }  
16.   
17.   
18.     @Override  
19.     public String call() throws Exception {  
20.         return "result of TaskWithResult " + id;  
21.     }  
22.   
23. }  
24.   
25.   
26. package com.partner4java.tij;  
27.   
28. import java.util.ArrayList;  
29. import java.util.List;  
30. import java.util.concurrent.ExecutionException;  
31. import java.util.concurrent.ExecutorService;  
32. import java.util.concurrent.Executors;  
33. import java.util.concurrent.Future;  
34.   
35. public class CallableDemo {  
36.   
37.     public static void main(String[] args) {  
38.         ExecutorService executorService = Executors.newCachedThreadPool();  
39.           
40.         List<Future<String>> results = new ArrayList<Future<String>>();  
41.         for(int i=0;i<10;i++){  
42.             //submit()方法会产生Future对象，他用Callable返回结果的特定类型进行了参数化。  
43.             //你可以用isDone()方法来查询Future是否已经完成。  
44.             results.add(executorService.submit(new TaskWithResult(i)));  
45.         }  
46.         for(Future<String> res:results){  
47.             try {  
48.                 //当任务完成时，他具有一个结果，你可以调用get()方法来获取该结果。  
49.                 System.out.println(res.get());  
50.             } catch (InterruptedException e) {  
51.                 e.printStackTrace();  
52.             } catch (ExecutionException e) {  
53.                 e.printStackTrace();  
54.             }  
55.         }  
56.     }  
57.   
58. }  

5、休眠 
Java SE5引入了更加显示的sleep()版本作为TimeUnit类的一部分，这个方法允许你指定sleep()延迟的时间单元，因此可以提供更好的可阅读性。TimeUnit还可以被用来执行转换，就想稍后你会在本书中看到的那样。 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. public class SleepingTask extends LiftOff {  
8.   
9.     @Override  
10.     public void run() {  
11. //      super.run();  
12.         try {  
13.             while(countDown-- > 0){  
14.                 System.out.print(status());  
15.                 TimeUnit.MILLISECONDS.sleep(1000);  
16.             }  
17.         } catch (InterruptedException e) {  
18.             e.printStackTrace();  
19.         }  
20.     }  
21.       
22.     public static void main(String[] args) {  
23.         ExecutorService executorService = Executors.newCachedThreadPool();  
24.         for(int i=0;i<5;i++){  
25.             executorService.execute(new SleepingTask());  
26.         }  
27.         executorService.shutdown();  
28.     }  
29.   
30. }  

6、优先级 
线程的优先级将该线程的重要性传递给了调度器。 
你可以用getPriority()来读取现有线程的优先级，并且在任何时刻都可以通过setPriority()来修改他。 
demo:

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5.   
6. public class SimplePriorities implements Runnable {  
7.     private int countDown = 5;  
8.     private volatile double d;//No optimization  
9.     private int priority;  
10.     public SimplePriorities(int priority){  
11.         this.priority = priority;  
12.     }  
13.       
14.     @Override  
15.     public String toString() {  
16.         return Thread.currentThread() + " : " + countDown;  
17.     }  
18.   
19.     @Override  
20.     public void run() {  
21.         Thread.currentThread().setPriority(priority);  
22.         while(true){  
23.             //加一个这么大的循环的目的是，确保不进行任何编译器优化  
24.             //An expensive,interruptable operation:  
25.             for(int i=1;i<100000;i++){  
26.                 d += (Math.PI + Math.E) / (double)i;  
27.                 if(i % 1000 == 0){  
28.                     Thread.yield();  
29.                 }  
30.             }  
31.             System.out.println(this + " : " + priority);  
32.             if(--countDown == 0) return;  
33.         }  
34.     }  
35.   
36.     public static void main(String[] args) {  
37.         ExecutorService executorService = Executors.newCachedThreadPool();  
38.         for(int i=0;i<5;i++){  
39.             executorService.execute(new SimplePriorities(Thread.MIN_PRIORITY));  
40.         }  
41.         executorService.execute(new SimplePriorities(Thread.MAX_PRIORITY));  
42.         executorService.shutdown();  
43.         //本身假象状态会先打印最后一个线程，因为给予了Thread.MAX_PRIORITY级别的优先级，单位我CPU是双核4线程的，就没那么明显，不过，线程6还是基本优于其他线程打印  
44.     }  
45.       
46. }  

一别建议使用三个常量：Thread.MIN_PRIORITY、NORM_PRIORITY、Thread.MAX_PRIORITY。 




7、让步 
如果知道已经完成了在run()方法的循环的一次迭代过程中所需要的工作，就可以给线程调度一个机制暗示：你的工作已经做的差不多了，可以让给别的线程使用CPU了。通过调用yield()来实现。 



8、后台进程 
所谓后台（daemon）线程，是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺部分。 
（当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中所有后台线程。反过来说，只要有任何非后台线程还在运行，程序就不会终止。） 
demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.TimeUnit;  
4.   
5. /** 
6. * 后台（daemon）线程<br/> 
7. * Daemon threads don't prevent the program from ending. 
8. * @author partner4java 
9. * 
10. */  
11. public class SimpleDaemons implements Runnable {  
12.   
13.     @Override  
14.     public void run() {  
15.         try {  
16.             while(true){  
17.                 //当你把这个设置成大于200的时候，就会发生什么都不打印的情况，也是前面完事了，就的杀死后面的  
18.                 TimeUnit.MILLISECONDS.sleep(100);  
19.                 System.out.println(Thread.currentThread() + " " + this);  
20.             }  
21.         } catch (InterruptedException e) {  
22. //          e.printStackTrace();  
23.             System.out.println("sleep() interrupted");  
24.         }  
25.     }  
26.   
27.     public static void main(String[] args) throws InterruptedException {  
28.         for(int i=0;i<10;i++){  
29.             Thread daemon = new Thread(new SimpleDaemons());  
30.             //必须在线程启动之前调用setDaemon方法，才能把它设置为后台线程  
31.             daemon.setDaemon(true);//不添加后台就会在一直不停的打  
32.             daemon.start();  
33.         }  
34.         System.out.println("All daemons started");  
35.         TimeUnit.MILLISECONDS.sleep(175);  
36.     }  
37. }  

使用Executor，且实现后台线程： 
Demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.ThreadFactory;  
4. import java.util.concurrent.atomic.AtomicInteger;  
5.   
6. /** 
7. * 这与普通的ThreadFactory的唯一差异就是他讲后台状态全部设置成了true 
8. * @author partner4java 
9. * 
10. */  
11. public class DaemonThreadFactory implements ThreadFactory {  
12.   
13.     @Override  
14.     public Thread newThread(Runnable r) {  
15.         Thread thread = new Thread(r);  
16.         thread.setDaemon(true);  
17.         return thread;  
18.     }  
19.   
20. }  
21. //  
22. //默认的那个：  
23. ///**  
24. // * The default thread factory  
25. // */  
26. //static class DefaultThreadFactory implements ThreadFactory {  
27. //    static final AtomicInteger poolNumber = new AtomicInteger(1);  
28. //    final ThreadGroup group;  
29. //    final AtomicInteger threadNumber = new AtomicInteger(1);  
30. //    final String namePrefix;  
31. //  
32. //    DefaultThreadFactory() {  
33. //        SecurityManager s = System.getSecurityManager();  
34. //        group = (s != null)? s.getThreadGroup() :  
35. //                             Thread.currentThread().getThreadGroup();  
36. //        namePrefix = "pool-" +  
37. //                      poolNumber.getAndIncrement() +  
38. //                     "-thread-";  
39. //    }  
40. //  
41. //    public Thread newThread(Runnable r) {  
42. //        Thread t = new Thread(group, r,  
43. //                              namePrefix + threadNumber.getAndIncrement(),  
44. //                              0);  
45. //        if (t.isDaemon())  
46. //            t.setDaemon(false);  
47. //        if (t.getPriority() != Thread.NORM_PRIORITY)  
48. //            t.setPriority(Thread.NORM_PRIORITY);  
49. //        return t;  
50. //    }  
51. //}  
52.   
53.   
54.   
55. package com.partner4java.tij;  
56.   
57. import java.util.concurrent.ExecutorService;  
58. import java.util.concurrent.Executors;  
59. import java.util.concurrent.TimeUnit;  
60.   
61. public class DaemonFromFactory implements Runnable {  
62.   
63.     @Override  
64.     public void run() {  
65.         try {  
66.             TimeUnit.MILLISECONDS.sleep(100);  
67.             System.out.println(Thread.currentThread() + " " + this);  
68.         } catch (InterruptedException e) {  
69.             e.printStackTrace();  
70.         }  
71.     }  
72.   
73.     public static void main(String[] args) throws InterruptedException {  
74.         ExecutorService executorService = Executors.newCachedThreadPool(new DaemonThreadFactory());  
75.         for(int i=0;i<10;i++){  
76.             executorService.execute(new DaemonFromFactory());  
77.         }  
78.         System.out.println("All daemons started");  
79.         TimeUnit.MILLISECONDS.sleep(175);  
80.     }  
81. }  

你还可以考虑和Thread.yield()结合来转交控制权等。 


示例： 
finally的内容会打印么？ 
Demo:

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. import java.util.concurrent.TimeUnit;  
4.   
5. public class ADaemon implements Runnable {  
6.   
7.     @Override  
8.     public void run() {  
9.         try {  
10.             System.out.println("Starting ADaemon");  
11.             TimeUnit.SECONDS.sleep(1);  
12.         } catch (InterruptedException e) {  
13.             e.printStackTrace();  
14.         }finally{  
15.             System.out.println("This should always run?");  
16.         }  
17.     }  
18.   
19. }  
20.   
21.   
22. package com.partner4java.tij;  
23.   
24. public class DaeonsDontRunFinally {  
25.   
26.     public static void main(String[] args) {  
27.         Thread thread = new Thread(new ADaemon());  
28.         thread.setDaemon(true);  
29.         thread.start();  
30. //      后台打印：  
31. //      Starting ADaemon  
32.     }  
33.   
34. }  

9、编码的变体 
Demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. /** 
4. * 定义一个内部的Thread类 
5. * @author partner4java 
6. * 
7. */  
8. public class InnerThread1 {  
9.     private int countDown = 5;  
10.     private Inner inner;  
11.       
12.     public InnerThread1(String name){  
13.         inner = new Inner(name);  
14.     }  
15.       
16.     private class Inner extends Thread{  
17.         Inner(String name){  
18.             super(name);  
19.             start();  
20.         }  
21.         @Override  
22.         public void run() {  
23.             try {  
24.                 while(true){  
25.                     System.out.println(this);  
26.                     if(--countDown == 0) return;  
27.                     sleep(10);  
28.                 }  
29.             } catch (InterruptedException e) {  
30.                 e.printStackTrace();  
31.             }  
32.         }  
33.         @Override  
34.         public String toString() {  
35.             return getName() + ":" + countDown;  
36.         }  
37.     }  
38. }  
39.   
40.   
41.   
42. package com.partner4java.tij;  
43.   
44. /** 
45. * 在构造器中直接new出来一个Thread 
46. * @author partner4java 
47. * 
48. */  
49. public class InnerThread2 {  
50.     private int countDown = 5;  
51.     private Thread thread;  
52.     public InnerThread2(String name){  
53.         thread = new Thread(name){  
54.             public void run() {  
55.                 try {  
56.                     while(true){  
57.                         System.out.println(this);  
58.                         if(--countDown == 0) return;  
59.                         sleep(10);  
60.                     }  
61.                 } catch (InterruptedException e) {  
62.                     e.printStackTrace();  
63.                 }  
64.             }  
65.               
66.             @Override  
67.             public String toString() {  
68.                 return getName() + ":" + countDown;  
69.             }  
70.         };  
71.         thread.start();  
72.     }  
73.       
74. }  
75.   
76.   
77.   
78. package com.partner4java.tij;  
79.   
80. /** 
81. * 单独起一个方法来启动和创建Thread 
82. * @author partner4java 
83. * 
84. */  
85. public class ThreadMethod {  
86.     private int countDown = 5;  
87.     private Thread thread;  
88.     private String name;  
89.     public ThreadMethod(String name) {  
90.         this.name = name;  
91.     }  
92.     public void runTask(){  
93.         if(thread == null){  
94.             thread = new Thread(name){  
95.                 public void run() {  
96.                     try {  
97.                         while(true){  
98.                             System.out.println(this);  
99.                             if(--countDown == 0) return;  
100.                             sleep(10);  
101.                         }  
102.                     } catch (InterruptedException e) {  
103.                         e.printStackTrace();  
104.                     }  
105.                 }  
106.                 public String toString() {  
107.                     return getName() + ":" + countDown;  
108.                 }  
109.             };  
110.             thread.start();  
111.         }  
112.     }  
113. }  

测试： 

view plain copy to clipboard print ?

1. package com.partner4java.tij;  
2.   
3. public class ThreadVariations {  
4.   
5.     public static void main(String[] args) {  
6.         new InnerThread1("InnerThread1");  
7.         new InnerThread2("InnerThread2");  
8.         new ThreadMethod("ThreadMethod").runTask();  
9.     }  
10.   
11. }  

10、术语 
描述将要执行的工作使用术语“任务”，只有在引用到驱动任务的具体机制时，才使用“线程”。因为，如果你在概念级别上讨论系统，那就可以指使用“任务”，而压根不需要提及驱动机制。 



11、加入一个线程 
一个线程可以在其他线程之上调用join()方法，起效果是等待一段时间直到第二个线程结束才继续执行。 
如果某个线程在另一个线程t上调用t.join()，此线程将被挂起，直到目标线程t结束才恢复（即t.isAlive()返回为假）。 
也可以在调用join()时带上一个超时参数，这样如果目标线程在这段时间到期时还没有结束回话，join()方法总能返回。 
对join()方法的调用可以被中断，做法是调用线程上调用interrupt()方法，这是需要用到try-catch子句。 




12、创建有相应的用户界面 
System.in.read(); 


13、线程组 
Joshua Bloch：“最好吧线程组看成是一次不成功的尝试，你只要忽略它就好了”。 
Joseph Stiglitz：“继续错误的代价由别人来承担，而承认错误的代价由自己承担。” 



14、捕获异常 
由于线程的本质特性，使得你不能捕获从线程中逃逸的异常。 
为了解决这个问题，我们要修改Executor产生线程的方式。 
Thread.UncaughtExceptionHandler是Java SE5中的新街口，他允许你在每个Thread对象上附着一个异常处理器。 

Demo:

view plain copy to clipboard print ?

1. package com.partner4java.tij.util;  
2.   
3. import java.lang.Thread.UncaughtExceptionHandler;  
4.   
5. /** 
6. * 当 Thread 因未捕获的异常而突然终止时，调用处理程序的接口。 <br/> 
7. * 当某一线程因未捕获的异常而即将终止时，Java 虚拟机将使用 Thread.getUncaughtExceptionHandler()  
8. * 查询该线程以获得其 UncaughtExceptionHandler 的线程，并调用处理程序的 uncaughtException 方法， 
9. * 将线程和异常作为参数传递。如果某一线程没有明确设置其 UncaughtExceptionHandler， 
10. * 则将它的 ThreadGroup 对象作为其 UncaughtExceptionHandler。 
11. * 如果 ThreadGroup 对象对处理异常没有什么特殊要求，那么它可以将调用转发给默认的未捕获异常处理程序。  
12. * @author partner4java 
13. * 
14. */  
15. public class MyUncaughtExceptionHandler implements UncaughtExceptionHandler {  
16.   
17.     @Override  
18.     public void uncaughtException(Thread t, Throwable e) {  
19.         System.out.println("caught " + e);  
20.     }  
21.   
22. }  
23.   
24.   
25. package com.partner4java.tij.util;  
26.   
27. public class ExceptionThread implements Runnable {  
28.   
29.     @Override  
30.     public void run() {  
31.         Thread thread = Thread.currentThread();  
32.         System.out.println("run() by " + thread);  
33.         System.out.println("en = " + thread.getUncaughtExceptionHandler());  
34.         throw new RuntimeException("error by slef");  
35.     }  
36.   
37. }  
38.   
39.   
40. package com.partner4java.tij.util;  
41.   
42. import java.util.concurrent.ThreadFactory;  
43.   
44. public class HandlerThreadFactory implements ThreadFactory {  
45.   
46.     @Override  
47.     public Thread newThread(Runnable r) {  
48.         System.out.println(this + " creating new Thread");  
49.         Thread thread = new Thread(r);  
50.         System.out.println("created " + thread);  
51.         thread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());  
52.         System.out.println("en = " + thread.getUncaughtExceptionHandler());  
53.         return thread;  
54.     }  
55.   
56. }  
57.   
58.   
59.   
60. package com.partner4java.tij.util;  
61.   
62. import java.util.concurrent.ExecutorService;  
63. import java.util.concurrent.Executors;  
64.   
65. public class CaptureUncaughtException {  
66.   
67.     public static void main(String[] args) {  
68.         ExecutorService executorService = Executors.newCachedThreadPool(new HandlerThreadFactory());  
69.         executorService.execute(new ExceptionThread());  
70.         //最终在UncaughtExceptionHandler里面得到了捕获  
71.     }  
72.   
73. }  

如果在你的代码中，多出需要使用相同的异常处理器，简单的方式是在Thread类中设置一个静态域，给予一个默认的未捕获异常处理器： 
当然，如果单独设置，默认会失效 

view plain copy to clipboard print ?

1. package com.partner4java.tij.util;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5.   
6. public class SettingDefaultHandler {  
7.   
8.     public static void main(String[] args) {  
9.         Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());  
10.         ExecutorService executorService = Executors.newCachedThreadPool();  
11.         executorService.execute(new ExceptionThread());  
12. //      后台打印：  
13. //      run() by Thread[pool-1-thread-1,5,main]  
14. //      en = java.lang.ThreadGroup[name=main,maxpri=10]  
15. //      caught java.lang.RuntimeException: error by slef  
16.   
17.         //最终在UncaughtExceptionHandler里面得到了捕获  
18.     }  
19.   
20. }  

3共享受限资源  
1、不正确地访问资源 
在java中，递增不是原子性的操作。因此，如果不保护任务，即使单一的递增也是不安全的。 
Demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. /** 
4. * 包含消费者任务（EvenChecker）必须了解的必不可少的方法 
5. * @author partner4java 
6. * 
7. */  
8. public abstract class IntGenerator {  
9.     //为了保证可视性，添加了volatile  
10.     private volatile boolean canceled = false;  
11.     /** 
12.      * 产生偶数 
13.      * @return 
14.      */  
15.     public abstract int next();  
16.     /** 
17.      * 修改boolean类型的canceled标志的状态 
18.      */  
19.     public void cancel(){  
20.         canceled = true;  
21.     }  
22.     /** 
23.      * 查看是否已经被取消 
24.      * @return 
25.      */  
26.     public boolean isCanceled(){  
27.         return canceled;  
28.     }  
29.       
30. }  
31.   
32.   
33.   
34. package com.partner4java.tij.sharing;  
35.   
36. import java.util.concurrent.ExecutorService;  
37. import java.util.concurrent.Executors;  
38.   
39. /** 
40. * 任务检测 
41. * @author partner4java 
42. * 
43. */  
44. public class EvenChecker implements Runnable {  
45.     private IntGenerator generator;  
46.     private final int id;//看到了么？final类型的全局变量不一定非的马上赋值，也可以通过构造器来赋值  
47.       
48.     public EvenChecker(IntGenerator generator, int id) {  
49.         this.generator = generator;  
50.         this.id = id;  
51.     }  
52.       
53.     @Override  
54.     public void run() {  
55.         while(!generator.isCanceled()){  
56.             int val = generator.next();  
57.             //当没有问题时，就是是偶数，那么将一直死循环下去。但是，当出现了资源共享问题，就会通过这个if  
58.             if(val % 2 != 0){  
59.                 System.out.println(val + " not even!");  
60.                 generator.cancel();//Cancels all EventCheckers  
61.             }  
62.         }  
63.     }  
64.       
65.     //Test any type of IntGenerator:  
66.     public static void test(IntGenerator generator,int count) {  
67.         System.out.println("Presss Control-C to exit");  
68.         ExecutorService executorService = Executors.newCachedThreadPool();  
69.         for(int i=0;i<count;i++){  
70.             executorService.execute(new EvenChecker(generator, i));  
71.         }  
72.         executorService.shutdown();  
73.     }  
74.   
75.     //Default value of count:  
76.     public static void test(IntGenerator generator){  
77.         test(generator, 10);  
78.     }  
79. }  
80.   
81.   
82.   
83. package com.partner4java.tij.sharing;  
84.   
85. /** 
86. * 一个简单实现 
87. * @author partner4java 
88. * 
89. */  
90. public class EvenGenerator extends IntGenerator {  
91.     private int currentEventValue = 0;  
92.       
93.     @Override  
94.     public int next() {  
95.         ++currentEventValue;//Danger point here!  
96.         ++currentEventValue;  
97.         return currentEventValue;  
98.     }  
99.       
100.     public static void main(String[] args) {  
101.         EvenChecker.test(new EvenGenerator());  
102. //      后台打印：  
103. //      Presss Control-C to exit  
104. //      447 not even!  
105. //      447 not even!  
106. //      449 not even!  
107.   
108.         //那么就证明了有问题，正常的情况会全部是偶数，不会出现非偶数  
109.     }  
110. }  

2、解决共享资源的竞争 
对于并发工作，你需要某种方式来防止两个任务访问相同的资源，至少在关键阶段不能出现这种情况。 
基本大家都是使用序列化访问共享资源的方案。 
锁语句产生了一种花香排斥的效果，所以这种机制常常成为互斥量（mutex）。 
Java以提供关键字synchronized的形式，来防止资源冲突提供了内置支持。 

所以对象都自动含有单一的锁（也称为监视器）。当在对象上调用起任意synchronized方法的时候，此对象都被加锁，这时该对象上的其他synchronized方法之一等到前一个方法调用完毕并释放了锁之后才能被调用。 

在使用并发时，将域设置为private是非常重要的，否则，synchronized关键字就不能防止其他任务直接访问域，这样就会发生冲突。 

一个任务可以多次获得对象的锁。如果一个方法在同一个对象上调用了第二个方法，后者又调用了同一个对象上的另一个方法，就会发生这种情况。 
JVM负责跟踪对象被加锁的次数。如果一个对象被解锁（即锁被完全释放），其计数变为0。 
在任务第一次给对象加锁的时候，计数变为1。每当这个相同的任务在这个对象上获得锁时，计数都会递增。显然，只有首先获得了锁的任务才能允许继续获得多个锁。每当任务离开 一个synchronized方法，计数递减，当计数为零的时候，所被完全释放，此时别的任务就可以使用此资源。 

针对每个类，也有一个锁（作为ie累的Class对象的一部分），所以synchronized static方法可以在类的范围内防止对static数据的并发访问。 

Demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. public class SynchronizedEvenGenerator extends IntGenerator {  
4.     private  int currentEventValue = 0;  
5.       
6.     @Override  
7.     public synchronized int next() {  
8.         ++currentEventValue;//Danger point here!  
9.         Thread.yield();  
10.         ++currentEventValue;  
11.         return currentEventValue;  
12.     }  
13.       
14.     public static void main(String[] args) {  
15.         //这样就永远出来不，就打印一个“Presss Control-C to exit”  
16.         EvenChecker.test(new SynchronizedEvenGenerator());  
17.         //把currentEventValue改成static，再加上下面这句话，就会出现问题了,  
18. //      这样可以证明，非静态方法的锁属于这个new出来的对象而不是这个类。  
19. //      如果在方法上也加上static，就没问题了，还是同一把锁  
20.         EvenChecker.test(new SynchronizedEvenGenerator());  
21.     }  
22. }  
23.   
24.   
25.   
26. package com.partner4java.tij.sharing;  
27.   
28. import java.util.concurrent.ExecutorService;  
29. import java.util.concurrent.Executors;  
30.   
31. public class AtomicityTest implements Runnable {  
32.     private int countDown = 0;  
33.       
34.     public int getCountDown() {  
35.         return countDown;  
36.     }  
37.       
38.     private synchronized void evenIncrement(){  
39.         ++countDown;  
40.         ++countDown;  
41.     }  
42.   
43.   
44.     @Override  
45.     public void run() {  
46.         while(true){  
47.             evenIncrement();  
48.         }     
49.     }  
50.   
51.     public static void main(String[] args) {  
52.         ExecutorService executorService = Executors.newCachedThreadPool();  
53.         AtomicityTest atomicityTest = new AtomicityTest();  
54.         executorService.execute(atomicityTest);  
55.           
56.         while(true){  
57.             int val = atomicityTest.getCountDown();  
58.             //正常的情况是不会打印下面if里面的内容  
59.             if(val % 2 != 0){  
60.                 System.out.println(val);  
61.                 System.exit(0);  
62.             }  
63.               
64.             //当你给getCountDown方法也加上synchronized的时候就正确了，原因前面说过。  
65.               
66.         }  
67.     }  
68. }  

使用显示的Lock对象： 
Lock对象必须被显式的创建、锁定和释放。 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. import java.util.concurrent.locks.Lock;  
4. import java.util.concurrent.locks.ReentrantLock;  
5.   
6. /** 
7. * 显示的Lock<br/> 
8. * 与synchronized相比代码量多，但是，可以拿到异常在finally里 
9. * @author partner4java 
10. * 
11. */  
12. public class MutexEvenGenerator extends IntGenerator {  
13.     private int currentEventValue = 0;  
14.     private Lock lock = new ReentrantLock();  
15.       
16.     @Override  
17.     public int next() {  
18.         lock.lock();  
19.         //还有一个优点就是可以尝试去获取锁，如果获取不到，就可以去做别的  
20. //      lock.tryLock(2, TimeUnit.SECONDS);  
21.         try {  
22.             ++currentEventValue;//Danger point here!  
23.             Thread.yield();//Cause failure faster  
24.             ++currentEventValue;  
25.             //不能忽略这个return，否则，还是会报错。（以确保unlock()不会过早的发生）  
26.             return currentEventValue;  
27.         } catch (Exception e) {  
28.             e.printStackTrace();  
29.         }finally{  
30.             lock.unlock();  
31.         }  
32.         return currentEventValue;  
33.     }  
34.       
35.     public static void main(String[] args) {  
36.         EvenChecker.test(new MutexEvenGenerator());  
37.         //当然，使用这种方式，就是同事new出来多少个对象也不会出现问题，因为lock是非静态且本身是独立的。  
38.         //currentEventValue如果为static，也是会有问题  
39.         EvenChecker.test(new MutexEvenGenerator());  
40.     }  
41. }  

3、原子性和易变性 
（警告：不要依赖于原子性替代同步） 
原子性可以应用于除long和double之外的所有基本类型之上的“简单操作”。 
在多处理器系统上，性对于蛋处理器系统而言，可视性问题远比原子性问题多得多。 
volatile关键字还确保了应用中的可视性。（volatile会把修改立即写入到主存中，即便你使用了本地缓存） 
当一个域的值依赖于他之前的值时，volatile就无法工作了。 

使用volatile而不是synchronized的唯一安全的情况是类中只要一个可变的域。 

上面的AtomicityTest类也讲述了原子性的问题。 

基本上，如果一个域可能会被多个任务同时访问，合作和这些任务中至少有一个是写入任务，那么你就应该将这个域设置为volatile。 

Demo: 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. public class MyVolatile {  
8.     private int count;  
9.   
10.     private void upper() {  
11.         ++count;  
12.     }  
13.   
14.     private void lower() {  
15.         --count;  
16.     }  
17.   
18.     public static void main(String[] args) {  
19. //      test1();  
20.         test2();  
21.     }  
22.   
23.     private static void test1() {  
24.         final MyVolatile myVolatile = new MyVolatile();  
25.   
26.         ExecutorService executorService = Executors.newCachedThreadPool();  
27.         executorService.execute(new Runnable() {  
28.   
29.             @Override  
30.             public void run() {  
31.                 for (int i = 0; i < 100000; i++) {  
32.                     myVolatile.upper();  
33.                 }  
34.                 System.out.println("myVolatile.upper is ok");  
35.             }  
36.         });  
37.           
38.         executorService.execute(new Runnable() {  
39.   
40.             @Override  
41.             public void run() {  
42.                 for (int i = 0; i < 100000; i++) {  
43.                     myVolatile.lower();  
44.                 }  
45.                 System.out.println("myVolatile.lower is ok");  
46.             }  
47.         });  
48.           
49.         try {  
50.             TimeUnit.MILLISECONDS.sleep(1000);  
51.         } catch (InterruptedException e) {  
52.             e.printStackTrace();  
53.         }  
54.           
55.         executorService.shutdown();  
56.         System.out.println(myVolatile.count);  
57. //      后台打印：  
58. //      myVolatile.lower is ok  
59. //      myVolatile.upper is ok  
60. //      4747  
61.           
62. //      你会想，怎么会这样呢？明明调用的次数相同，你是不是会想给int加个volatile，加上之后还是会有问题，不信你试试。  
63.         //这个例子和前面提到的也很像，那你就给两个方法都加上对象锁，才可以  
64.     }  
65.   
66.       
67.     //那么volatile到底哪些时候比较有用呢？  
68.     private static void test2() {  
69.         final MyVolatile myVolatile = new MyVolatile();  
70.   
71.         ExecutorService executorService = Executors.newCachedThreadPool();  
72.         executorService.execute(new Runnable() {  
73.   
74.             @Override  
75.             public void run() {  
76.                 for (int i = 0; i < 100000; i++) {  
77.                     myVolatile.upper();  
78.                 }  
79.                 System.out.println("myVolatile.upper is ok");  
80.             }  
81.         });  
82.           
83.         executorService.execute(new Runnable() {  
84.   
85.             @Override  
86.             public void run() {  
87.                 for (int i = 0; i < 100000; i++) {  
88.                     myVolatile.upper();  
89.                 }  
90.                 System.out.println("myVolatile.lower is ok");  
91.             }  
92.         });  
93.           
94.         try {  
95.             TimeUnit.MILLISECONDS.sleep(1000);  
96.         } catch (InterruptedException e) {  
97.             e.printStackTrace();  
98.         }  
99.           
100.         executorService.shutdown();  
101.         System.out.println(myVolatile.count);  
102. //      后台打印：  
103. //      myVolatile.upper is ok  
104. //      myVolatile.lower is ok  
105. //      187213  
106.           
107. //      是不是有些出乎我们的意料不是200000，我都是调用的++啊，这样也会出现问题。  
108.         //那么我们就想到了可见性，那么在count前面加上个volatile，还是会有问题？为什么？  
109.           
110.     }  
111. }  

4、原子类 
Java SE5引入了诸如AtomicInteger、AtomicLong、AtomicReference等特殊的原子性变量类。 
这些类被调整为可以使用在某些现代处理器上的可获得的，并且是在机器级别上的原子性，因此在使用他们时，通常我们不需要担心。 
（但是，还是需要强调，通常依赖于锁活更安全一些，除非在特殊的情况下在自己的代码中使用他们） 

Demo: 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.atomic.AtomicInteger;  
6.   
7. public class AtomicityIntegerTest implements Runnable {  
8.     private AtomicInteger countDown = new AtomicInteger(0);  
9.       
10.     public int getCountDown() {  
11.         return countDown.get();  
12.     }  
13.       
14.     private void evenIncrement(){  
15.         countDown.addAndGet(2);  
16.     }  
17.   
18.   
19.     @Override  
20.     public void run() {  
21.         while(true){  
22.             evenIncrement();  
23.         }     
24.     }  
25.   
26.     public static void main(String[] args) {  
27.         ExecutorService executorService = Executors.newCachedThreadPool();  
28.         AtomicityIntegerTest atomicityTest = new AtomicityIntegerTest();  
29.         executorService.execute(atomicityTest);  
30.           
31.         while(true){  
32.             int val = atomicityTest.getCountDown();  
33.             //正常的情况是不会打印下面if里面的内容  
34.             if(val % 2 != 0){  
35.                 System.out.println(val);  
36.                 System.exit(0);  
37.             }  
38.               
39.             //我们去掉了evenIncrement的synchronized，但是也没有出现错误的情况，看来AtomicInteger还是好使的，而且会提高性能  
40.         }  
41.     }  
42. }  

5、临界区 
有时，你只是希望防止多个线程同时访问方法内部的部分代码而不是防止访问整个方法。 
通过这种方式分离出来的代码段成为临界区（critical section），他也使用synchronized关键字建立。 
这里，synchronized被用来指定某个对象，次对象的锁被用来对花括号内的代码进行同步控制： 
synchronized(syncObject){ 
//This code can be accessed 
//by only one task at a time 
} 
这也被成为同步控制块；在进入次代码前，必须得到syncObject对象的锁。 
如果其他对象已经得到这个锁，那么就的等到锁被释放以后，才能进入临界区。 

或者你还可使用Lock对象创建临界区。 



6、在其他对象上同步 
synchronized块必须给定一个在其上进行同步的对象，并且最合理的方式是，使用其方法正在被调用的当前对象：synchronized(this). 
有时必须在另一个对象上同步，但是如果你要这么做，就必须确保所有相关的任务都是在同一个对象上同步的。 
Demo： 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. /** 
4. * 两个方法互不干扰，在不同的锁里面 
5. * @author partner4java 
6. * 
7. */  
8. public class DualSynch {  
9.     private Object synchObject = new Object();  
10.     public synchronized void f(){  
11.         for(int i=0;i<5;i++){  
12.             System.out.println("f()");  
13.             Thread.yield();  
14.         }  
15.     }  
16.       
17.     public void g(){  
18.         synchronized (synchObject) {  
19.             for(int i=0;i<5;i++){  
20.                 System.out.println("g()");  
21.                 Thread.yield();  
22.             }  
23.         }  
24.     }  
25.       
26.     public static void main(String[] args) {  
27.         final DualSynch dualSynch = new DualSynch();  
28.         new Thread(){  
29.             @Override  
30.             public void run() {  
31.                 dualSynch.f();  
32.             }  
33.         }.start();  
34.         dualSynch.g();  
35. //      后台打印：  
36. //      g()  
37. //      f()  
38. //      g()  
39. //      f()  
40. //      f()  
41. //      f()  
42. //      f()  
43. //      g()  
44. //      g()  
45. //      g()  
46.   
47. //      如果改成synchronized (this)，就会出现先打印完g()，再打印f()的情况，因为互斥了  
48.     }  
49. }  

7、线程本地存储 
防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。 
线程本地存储是一种自动化机制，可以为使用相同变量的不同的线程都创建不同的存储。 
可以由java.lang.ThreadLocal类来实现。 

Demo: 

view plain copy to clipboard print ?

1. package com.partner4java.tij.sharing;  
2.   
3. import java.util.Random;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6. import java.util.concurrent.TimeUnit;  
7.   
8. public class Accessor implements Runnable {  
9.     private final int id;  
10.     public Accessor(int id) {  
11.         this.id = id;  
12.     }  
13.       
14.     @Override  
15.     public void run() {  
16.         while(!Thread.currentThread().isInterrupted()){  
17.             ThreadLocalVariableHolder.increment();  
18.             System.out.println(this);  
19.             Thread.yield();  
20.         }  
21.     }  
22.   
23.     @Override  
24.     public String toString() {  
25.         return "#" + id + ": " + ThreadLocalVariableHolder.get();  
26.     }  
27.       
28.     public static void main(String[] args) throws InterruptedException {  
29.         ExecutorService executorService = Executors.newCachedThreadPool();  
30.         for(int i=0;i<5;i++){  
31.             executorService.execute(new Accessor(i));  
32.         }  
33.         TimeUnit.MILLISECONDS.sleep(3000);  
34.         executorService.shutdown();  
35.     }  
36. }  
37.   
38. class ThreadLocalVariableHolder{  
39.     private static ThreadLocal<Integer> value = new ThreadLocal<Integer>(){  
40.         private Random random = new Random(47);  
41.         @Override  
42.         protected Integer initialValue() {  
43.             return random.nextInt(10000);  
44.         }  
45.           
46.     };  
47.     public static void increment(){  
48.         value.set(value.get() + 1);  
49.     }  
50.     public static int get(){  
51.         return value.get();  
52.     }  
53.       
54. }  
55.   
56. //其中，get()方法将返回与其线程相关联的对象的副本，而set()会讲参数插入到为其线程存储的对象中，并返回存储中原有的对象。