并发基础知识1

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

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



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



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

view plain copy to clipboard print ?

1. publicclassLiftOffimplementsRunnable {
2. protectedintcountDown =10;
3. privatestaticinttaskCount =0;
4. /** 用来区分任务的多个实例 */
5. //因为他是final的,一旦被初始化之后就不希望被修改
6. privatefinalintid = taskCount++;
7. publicLiftOff(){}
8. publicLiftOff(intcountDown){
9. this.countDown = countDown;
10. }
12. publicString status(){
13. return"#"+ id +"("+ (countDown >0?countDown :"LiftOff!") +"), ";
14. }
16. @Override
17. publicvoidrun() {
18. while(countDown-- >0){
19. System.out.print(status());
20. //线程调度器：表示“我们已经执行完声明周期中最重要的部分了，此刻正是切换给其他任务执行一段时间的大好时机”
21. Thread.yield();
22. }
23. }
25. publicstaticvoidmain(String[] args) {
26. oneThread();
27. }
29. /**
30. * main只是一个单线程的调用
31. */
32. privatestaticvoidoneThread() {
33. LiftOff launch =newLiftOff();
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. publicstaticvoidmain(String[] args) {
2. moreBasicThreads();
3. }
6. /**
7. * 添加更多的线程去驱动更多的任务
8. */
9. privatestaticvoidmoreBasicThreads() {
10. for(inti=0;i<5;i++){
11. newThread(newLiftOff()).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. packagecom.partner4java.tij;
3. importjava.util.concurrent.ExecutorService;
4. importjava.util.concurrent.Executors;
6. publicclassCachedTreadPool {
8. publicstaticvoidmain(String[] args) {
9. //我们可以使用Executor来代替显示的创建Thread对象
10. ExecutorService executorService = Executors.newCachedThreadPool();
11. for(inti=0;i<10;i++){
12. executorService.execute(newLiftOff());
13. }
14. executorService.shutdown();
15. }
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. packagecom.partner4java.tij;
3. importjava.util.concurrent.Callable;
5. /**
6. * 具有返回值的任务
7. * @author partner4java
8. *
9. */
10. publicclassTaskWithResultimplementsCallable<String> {
11. privateintid;
13. publicTaskWithResult(intid) {
14. this.id = id;
15. }
18. @Override
19. publicString call()throwsException {
20. return"result of TaskWithResult "+ id;
21. }
23. }
26. packagecom.partner4java.tij;
28. importjava.util.ArrayList;
29. importjava.util.List;
30. importjava.util.concurrent.ExecutionException;
31. importjava.util.concurrent.ExecutorService;
32. importjava.util.concurrent.Executors;
33. importjava.util.concurrent.Future;
35. publicclassCallableDemo {
37. publicstaticvoidmain(String[] args) {
38. ExecutorService executorService = Executors.newCachedThreadPool();
40. List<Future<String>> results =newArrayList<Future<String>>();
41. for(inti=0;i<10;i++){
42. //submit()方法会产生Future对象，他用Callable返回结果的特定类型进行了参数化。
43. //你可以用isDone()方法来查询Future是否已经完成。
44. results.add(executorService.submit(newTaskWithResult(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. }
58. }

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

view plain copy to clipboard print ?

1. packagecom.partner4java.tij;
3. importjava.util.concurrent.ExecutorService;
4. importjava.util.concurrent.Executors;
5. importjava.util.concurrent.TimeUnit;
7. publicclassSleepingTaskextendsLiftOff {
9. @Override
10. publicvoidrun() {
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. }
22. publicstaticvoidmain(String[] args) {
23. ExecutorService executorService = Executors.newCachedThreadPool();
24. for(inti=0;i<5;i++){
25. executorService.execute(newSleepingTask());
26. }
27. executorService.shutdown();
28. }
30. }

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

view plain copy to clipboard print ?

1. packagecom.partner4java.tij;
3. importjava.util.concurrent.ExecutorService;
4. importjava.util.concurrent.Executors;
6. publicclassSimplePrioritiesimplementsRunnable {
7. privateintcountDown =5;
8. privatevolatiledoubled;//No optimization
9. privateintpriority;
10. publicSimplePriorities(intpriority){
11. this.priority = priority;
12. }
14. @Override
15. publicString toString() {
16. returnThread.currentThread() +" : "+ countDown;
17. }
19. @Override
20. publicvoidrun() {
21. Thread.currentThread().setPriority(priority);
22. while(true){
23. //加一个这么大的循环的目的是，确保不进行任何编译器优化
24. //An expensive,interruptable operation:
25. for(inti=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. }
36. publicstaticvoidmain(String[] args) {
37. ExecutorService executorService = Executors.newCachedThreadPool();
38. for(inti=0;i<5;i++){
39. executorService.execute(newSimplePriorities(Thread.MIN_PRIORITY));
40. }
41. executorService.execute(newSimplePriorities(Thread.MAX_PRIORITY));
42. executorService.shutdown();
43. //本身假象状态会先打印最后一个线程，因为给予了Thread.MAX_PRIORITY级别的优先级，单位我CPU是双核4线程的，就没那么明显，不过，线程6还是基本优于其他线程打印
44. }
46. }

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




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



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

view plain copy to clipboard print ?

1. packagecom.partner4java.tij;
3. importjava.util.concurrent.TimeUnit;
5. /**
6. * 后台（daemon）线程<br/>
7. * Daemon threads don't prevent the program from ending.
8. * @author partner4java
9. *
10. */
11. publicclassSimpleDaemonsimplementsRunnable {
13. @Override
14. publicvoidrun() {
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. }
27. publicstaticvoidmain(String[] args)throwsInterruptedException {
28. for(inti=0;i<10;i++){
29. Thread daemon =newThread(newSimpleDaemons());
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. packagecom.partner4java.tij;
3. importjava.util.concurrent.ThreadFactory;
4. importjava.util.concurrent.atomic.AtomicInteger;
6. /**
7. * 这与普通的ThreadFactory的唯一差异就是他讲后台状态全部设置成了true
8. * @author partner4java
9. *
10. */
11. publicclassDaemonThreadFactoryimplementsThreadFactory {
13. @Override
14. publicThread newThread(Runnable r) {
15. Thread thread =newThread(r);
16. thread.setDaemon(true);
17. returnthread;
18. }
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. //}
55. packagecom.partner4java.tij;
57. importjava.util.concurrent.ExecutorService;
58. importjava.util.concurrent.Executors;
59. importjava.util.concurrent.TimeUnit;
61. publicclassDaemonFromFactoryimplementsRunnable {
63. @Override
64. publicvoidrun() {
65. try{
66. TimeUnit.MILLISECONDS.sleep(100);
67. System.out.println(Thread.currentThread() +" "+this);
68. }catch(InterruptedException e) {
69. e.printStackTrace();
70. }
71. }
73. publicstaticvoidmain(String[] args)throwsInterruptedException {
74. ExecutorService executorService = Executors.newCachedThreadPool(newDaemonThreadFactory());
75. for(inti=0;i<10;i++){
76. executorService.execute(newDaemonFromFactory());
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. packagecom.partner4java.tij;
3. importjava.util.concurrent.TimeUnit;
5. publicclassADaemonimplementsRunnable {
7. @Override
8. publicvoidrun() {
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. }
19. }
22. packagecom.partner4java.tij;
24. publicclassDaeonsDontRunFinally {
26. publicstaticvoidmain(String[] args) {
27. Thread thread =newThread(newADaemon());
28. thread.setDaemon(true);
29. thread.start();
30. //后台打印：
31. //Starting ADaemon
32. }
34. }

9、编码的变体
Demo：

view plain copy to clipboard print ?

1. packagecom.partner4java.tij;
3. /**
4. * 定义一个内部的Thread类
5. * @author partner4java
6. *
7. */
8. publicclassInnerThread1 {
9. privateintcountDown =5;
10. privateInner inner;
12. publicInnerThread1(String name){
13. inner =newInner(name);
14. }
16. privateclassInnerextendsThread{
17. Inner(String name){
18. super(name);
19. start();
20. }
21. @Override
22. publicvoidrun() {
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. publicString toString() {
35. returngetName() +":"+ countDown;
36. }
37. }
38. }
42. packagecom.partner4java.tij;
44. /**
45. * 在构造器中直接new出来一个Thread
46. * @author partner4java
47. *
48. */
49. publicclassInnerThread2 {
50. privateintcountDown =5;
51. privateThread thread;
52. publicInnerThread2(String name){
53. thread =newThread(name){
54. publicvoidrun() {
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. }
66. @Override
67. publicString toString() {
68. returngetName() +":"+ countDown;
69. }
70. };
71. thread.start();
72. }
74. }
78. packagecom.partner4java.tij;
80. /**
81. * 单独起一个方法来启动和创建Thread
82. * @author partner4java
83. *
84. */
85. publicclassThreadMethod {
86. privateintcountDown =5;
87. privateThread thread;
88. privateString name;
89. publicThreadMethod(String name) {
90. this.name = name;
91. }
92. publicvoidrunTask(){
93. if(thread ==null){
94. thread =newThread(name){
95. publicvoidrun() {
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. publicString toString() {
107. returngetName() +":"+ countDown;
108. }
109. };
110. thread.start();
111. }
112. }
113. }

测试：

view plain copy to clipboard print ?

1. packagecom.partner4java.tij;
3. publicclassThreadVariations {
5. publicstaticvoidmain(String[] args) {
6. newInnerThread1("InnerThread1");
7. newInnerThread2("InnerThread2");
8. newThreadMethod("ThreadMethod").runTask();
9. }
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. packagecom.partner4java.tij.util;
3. importjava.lang.Thread.UncaughtExceptionHandler;
5. /**
6. * 当 Thread 因未捕获的异常而突然终止时，调用处理程序的接口。 <br/>
7. * 当某一线程因未捕获的异常而即将终止时，Java 虚拟机将使用 Thread.getUncaughtExceptionHandler()
8. * 查询该线程以获得其 UncaughtExceptionHandler 的线程，并调用处理程序的 uncaughtException 方法，
9. * 将线程和异常作为参数传递。如果某一线程没有明确设置其 UncaughtExceptionHandler，
10. * 则将它的 ThreadGroup 对象作为其 UncaughtExceptionHandler。
11. * 如果 ThreadGroup 对象对处理异常没有什么特殊要求，那么它可以将调用转发给默认的未捕获异常处理程序。
12. * @author partner4java
13. *
14. */
15. publicclassMyUncaughtExceptionHandlerimplementsUncaughtExceptionHandler {
17. @Override
18. publicvoiduncaughtException(Thread t, Throwable e) {
19. System.out.println("caught "+ e);
20. }
22. }
25. packagecom.partner4java.tij.util;
27. publicclassExceptionThreadimplementsRunnable {
29. @Override
30. publicvoidrun() {
31. Thread thread = Thread.currentThread();
32. System.out.println("run() by "+ thread);
33. System.out.println("en = "+ thread.getUncaughtExceptionHandler());
34. thrownewRuntimeException("error by slef");
35. }
37. }
40. packagecom.partner4java.tij.util;
42. importjava.util.concurrent.ThreadFactory;
44. publicclassHandlerThreadFactoryimplementsThreadFactory {
46. @Override
47. publicThread newThread(Runnable r) {
48. System.out.println(this+" creating new Thread");
49. Thread thread =newThread(r);
50. System.out.println("created "+ thread);
51. thread.setUncaughtExceptionHandler(newMyUncaughtExceptionHandler());
52. System.out.println("en = "+ thread.getUncaughtExceptionHandler());
53. returnthread;
54. }
56. }
60. packagecom.partner4java.tij.util;
62. importjava.util.concurrent.ExecutorService;
63. importjava.util.concurrent.Executors;
65. publicclassCaptureUncaughtException {
67. publicstaticvoidmain(String[] args) {
68. ExecutorService executorService = Executors.newCachedThreadPool(newHandlerThreadFactory());
69. executorService.execute(newExceptionThread());
70. //最终在UncaughtExceptionHandler里面得到了捕获
71. }
73. }

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

view plain copy to clipboard print ?

1. packagecom.partner4java.tij.util;
3. importjava.util.concurrent.ExecutorService;
4. importjava.util.concurrent.Executors;
6. publicclassSettingDefaultHandler {
8. publicstaticvoidmain(String[] args) {
9. Thread.setDefaultUncaughtExceptionHandler(newMyUncaughtExceptionHandler());
10. ExecutorService executorService = Executors.newCachedThreadPool();
11. executorService.execute(newExceptionThread());
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
17. //最终在UncaughtExceptionHandler里面得到了捕获
18. }
20. }

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

view plain copy to clipboard print ?

1. packagecom.partner4java.tij.sharing;
3. /**
4. * 包含消费者任务（EvenChecker）必须了解的必不可少的方法
5. * @author partner4java
6. *
7. */
8. publicabstractclassIntGenerator {
9. //为了保证可视性，添加了volatile
10. privatevolatilebooleancanceled =false;
11. /**
12. * 产生偶数
13. * @return
14. */
15. publicabstractintnext();
16. /**
17. * 修改boolean类型的canceled标志的状态
18. */
19. publicvoidcancel(){
20. canceled =true;
21. }
22. /**
23. * 查看是否已经被取消
24. * @return
25. */
26. publicbooleanisCanceled(){
27. returncanceled;
28. }
30. }
34. packagecom.partner4java.tij.sharing;
36. importjava.util.concurrent.ExecutorService;
37. importjava.util.concurrent.Executors;
39. /**
40. * 任务检测
41. * @author partner4java
42. *
43. */
44. publicclassEvenCheckerimplementsRunnable {
45. privateIntGenerator generator;
46. privatefinalintid;//看到了么？final类型的全局变量不一定非的马上赋值，也可以通过构造器来赋值
48. publicEvenChecker(IntGenerator generator,intid) {
49. this.generator = generator;
50. this.id = id;
51. }
53. @Override
54. publicvoidrun() {
55. while(!generator.isCanceled()){
56. intval = 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. }
65. //Test any type of IntGenerator:
66. publicstaticvoidtest(IntGenerator generator,intcount) {
67. System.out.println("Presss Control-C to exit");
68. ExecutorService executorService = Executors.newCachedThreadPool();
69. for(inti=0;i<count;i++){
70. executorService.execute(newEvenChecker(generator, i));
71. }
72. executorService.shutdown();
73. }
75. //Default value of count:
76. publicstaticvoidtest(IntGenerator generator){
77. test(generator,10);
78. }
79. }
83. packagecom.partner4java.tij.sharing;
85. /**
86. * 一个简单实现
87. * @author partner4java
88. *
89. */
90. publicclassEvenGeneratorextendsIntGenerator {
91. privateintcurrentEventValue =0;
93. @Override
94. publicintnext() {
95. ++currentEventValue;//Danger point here!
96. ++currentEventValue;
97. returncurrentEventValue;
98. }
100. publicstaticvoidmain(String[] args) {
101. EvenChecker.test(newEvenGenerator());
102. //后台打印：
103. //Presss Control-C to exit
104. //447 not even!
105. //447 not even!
106. //449 not even!
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. packagecom.partner4java.tij.sharing;
3. publicclassSynchronizedEvenGeneratorextendsIntGenerator {
4. privateintcurrentEventValue =0;
6. @Override
7. publicsynchronizedintnext() {
8. ++currentEventValue;//Danger point here!
9. Thread.yield();
10. ++currentEventValue;
11. returncurrentEventValue;
12. }
14. publicstaticvoidmain(String[] args) {
15. //这样就永远出来不，就打印一个“Presss Control-C to exit”
16. EvenChecker.test(newSynchronizedEvenGenerator());
17. //把currentEventValue改成static，再加上下面这句话，就会出现问题了,
18. //这样可以证明，非静态方法的锁属于这个new出来的对象而不是这个类。
19. //如果在方法上也加上static，就没问题了，还是同一把锁
20. EvenChecker.test(newSynchronizedEvenGenerator());
21. }
22. }
26. packagecom.partner4java.tij.sharing;
28. importjava.util.concurrent.ExecutorService;
29. importjava.util.concurrent.Executors;
31. publicclassAtomicityTestimplementsRunnable {
32. privateintcountDown =0;
34. publicintgetCountDown() {
35. returncountDown;
36. }
38. privatesynchronizedvoidevenIncrement(){
39. ++countDown;
40. ++countDown;
41. }
44. @Override
45. publicvoidrun() {
46. while(true){
47. evenIncrement();
48. }
49. }
51. publicstaticvoidmain(String[] args) {
52. ExecutorService executorService = Executors.newCachedThreadPool();
53. AtomicityTest atomicityTest =newAtomicityTest();
54. executorService.execute(atomicityTest);
56. while(true){
57. intval = atomicityTest.getCountDown();
58. //正常的情况是不会打印下面if里面的内容
59. if(val %2!=0){
60. System.out.println(val);
61. System.exit(0);
62. }
64. //当你给getCountDown方法也加上synchronized的时候就正确了，原因前面说过。
66. }
67. }
68. }

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

view plain copy to clipboard print ?

1. packagecom.partner4java.tij.sharing;
3. importjava.util.concurrent.locks.Lock;
4. importjava.util.concurrent.locks.ReentrantLock;
6. /**
7. * 显示的Lock<br/>
8. * 与synchronized相比代码量多，但是，可以拿到异常在finally里
9. * @author partner4java
10. *
11. */
12. publicclassMutexEvenGeneratorextendsIntGenerator {
13. privateintcurrentEventValue =0;
14. privateLock lock =newReentrantLock();
16. @Override
17. publicintnext() {
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. returncurrentEventValue;
27. }catch(Exception e) {
28. e.printStackTrace();
29. }finally{
30. lock.unlock();
31. }
32. returncurrentEventValue;
33. }
35. publicstaticvoidmain(String[] args) {
36. EvenChecker.test(newMutexEvenGenerator());
37. //当然，使用这种方式，就是同事new出来多少个对象也不会出现问题，因为lock是非静态且本身是独立的。
38. //currentEventValue如果为static，也是会有问题
39. EvenChecker.test(newMutexEvenGenerator());
40. }
41. }

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

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

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

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

Demo:

view plain copy to clipboard print ?

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

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

Demo:

view plain copy to clipboard print ?

1. packagecom.partner4java.tij.sharing;
3. importjava.util.concurrent.ExecutorService;
4. importjava.util.concurrent.Executors;
5. importjava.util.concurrent.atomic.AtomicInteger;
7. publicclassAtomicityIntegerTestimplementsRunnable {
8. privateAtomicInteger countDown =newAtomicInteger(0);
10. publicintgetCountDown() {
11. returncountDown.get();
12. }
14. privatevoidevenIncrement(){
15. countDown.addAndGet(2);
16. }
19. @Override
20. publicvoidrun() {
21. while(true){
22. evenIncrement();
23. }
24. }
26. publicstaticvoidmain(String[] args) {
27. ExecutorService executorService = Executors.newCachedThreadPool();
28. AtomicityIntegerTest atomicityTest =newAtomicityIntegerTest();
29. executorService.execute(atomicityTest);
31. while(true){
32. intval = atomicityTest.getCountDown();
33. //正常的情况是不会打印下面if里面的内容
34. if(val %2!=0){
35. System.out.println(val);
36. System.exit(0);
37. }
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. packagecom.partner4java.tij.sharing;
3. /**
4. * 两个方法互不干扰，在不同的锁里面
5. * @author partner4java
6. *
7. */
8. publicclassDualSynch {
9. privateObject synchObject =newObject();
10. publicsynchronizedvoidf(){
11. for(inti=0;i<5;i++){
12. System.out.println("f()");
13. Thread.yield();
14. }
15. }
17. publicvoidg(){
18. synchronized(synchObject) {
19. for(inti=0;i<5;i++){
20. System.out.println("g()");
21. Thread.yield();
22. }
23. }
24. }
26. publicstaticvoidmain(String[] args) {
27. finalDualSynch dualSynch =newDualSynch();
28. newThread(){
29. @Override
30. publicvoidrun() {
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()
47. //如果改成synchronized (this)，就会出现先打印完g()，再打印f()的情况，因为互斥了
48. }
49. }

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

Demo:

view plain copy to clipboard print ?

1. packagecom.partner4java.tij.sharing;
3. importjava.util.Random;
4. importjava.util.concurrent.ExecutorService;
5. importjava.util.concurrent.Executors;
6. importjava.util.concurrent.TimeUnit;
8. publicclassAccessorimplementsRunnable {
9. privatefinalintid;
10. publicAccessor(intid) {
11. this.id = id;
12. }
14. @Override
15. publicvoidrun() {
16. while(!Thread.currentThread().isInterrupted()){
17. ThreadLocalVariableHolder.increment();
18. System.out.println(this);
19. Thread.yield();
20. }
21. }
23. @Override
24. publicString toString() {
25. return"#"+ id +": "+ ThreadLocalVariableHolder.get();
26. }
28. publicstaticvoidmain(String[] args)throwsInterruptedException {
29. ExecutorService executorService = Executors.newCachedThreadPool();
30. for(inti=0;i<5;i++){
31. executorService.execute(newAccessor(i));
32. }
33. TimeUnit.MILLISECONDS.sleep(3000);
34. executorService.shutdown();
35. }
36. }
38. classThreadLocalVariableHolder{
39. privatestaticThreadLocal<Integer> value =newThreadLocal<Integer>(){
40. privateRandom random =newRandom(47);
41. @Override
42. protectedInteger initialValue() {
43. returnrandom.nextInt(10000);
44. }
46. };
47. publicstaticvoidincrement(){
48. value.set(value.get() +1);
49. }
50. publicstaticintget(){
51. returnvalue.get();
52. }
54. }
56. //其中，get()方法将返回与其线程相关联的对象的副本，而set()会讲参数插入到为其线程存储的对象中，并返回存储中原有的对象。