需求：要求用三个线程，按顺序打印1,2,3,4,5.... 71,72,73,74, 75. 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....以此类推, 直到线程3打印到75。
求高手们指点下，尽量有注释的代码哈

如果问题已经解决，请及时修改主题为“提问结束”。
修改主题的方法链接
http://bbs.itheima.com/thread-89313-1-1.html

呵呵我也写了一个，跟上面哥们方法一里的一样。不过这个方法没有效率。跟上面的师兄又学了几招，谢谢了。
思路：三个线程，每个线程都执行相同的代码：i++;system.out.println(i);
判断三个线程中哪一个执行这段代码c / 5 %3，然后写三个方法，c / 5 %3可能等于{0,1,2}
然后根据这个判断哪个线程执行。

1. 
   
2. package com.itheima;
   
3. 
   
4. class  AddInt{
   
5.         public  int i=1;
   
6.         public AddInt(){}
   
7. }
   
8. class  Test01 implements Runnable{
   
9.         private AddInt a;
   
10.         public Test01(){
    
11.                
    
12.         }
    
13.         public Test01(AddInt a){
    
14.                 this.a=a;
    
15.         }
    
16.         public  void run(){
    
17.                 while(a.i<76)        {
    
18.                                                 if(a.i/5%3==0){
    
19.                                                         //synchronized(a){
    
20.                                                                 for(int j=0;j<5;j++){
    
21.                                                                        
    
22.                                                                         System.out.println(Thread.currentThread().getName()+"....."+a.i);
    
23.                                                                         a.i++;
    
24.                                                                 }
    
25.                                                         //}
    
26.                                                        
    
27.                                                 }
    
28.                                                
    
29.                 }
    
30.         }
    
31. }
    
32. class  Test02 implements Runnable{
    
33.         private AddInt a;
    
34.         public Test02(){
    
35.                
    
36.         }
    
37.         public Test02(AddInt a){
    
38.                 this.a=a;
    
39.         }
    
40.         public  void run(){
    
41.                                                
    
42.                
    
43.                 while(a.i<76)        {
    
44.                                                                 if(a.i/5%3==1){
    
45.                                                                         //synchronized(a){
    
46.                                                                                 for(int j=0;j<5;j++){
    
47.                                                                                        
    
48.                                                                                         System.out.println(Thread.currentThread().getName()+"....."+a.i);
    
49.                                                                                         a.i++;
    
50.                                                                                 }
    
51.                                                                         //}
    
52.                                                                 }
    
53.                 }
    
54.         }
    
55. }
    
56. class  Test03 implements Runnable{
    
57.         private AddInt a;
    
58.         public Test03(){
    
59.                
    
60.         }
    
61.         public Test03(AddInt a){
    
62.                 this.a=a;
    
63.         }
    
64.         public  void run(){
    
65.                 while(a.i<76)        {
    
66.                         if(a.i/5%3==2){
    
67.                                 //synchronized(a){
    
68.                                         for(int j=0;j<5;j++){
    
69.                                                
    
70.                                                 System.out.println(Thread.currentThread().getName()+"....."+a.i);
    
71.                                                 a.i++;
    
72.                                         }
    
73.                                 //}
    
74.                         }
    
75.                 }
    
76.                
    
77. 
    
78.         }
    
79. }
    
80. 
    
81. class TestThreads{
    
82. 
    
83.         /**
    
84.          * @param args
    
85.          */
    
86.         public static void main(String[] args) {
    
87.                 AddInt i=new AddInt();
    
88.                
    
89.                 //创建三个实现了Runnable借口的对象，对一个AddInt对象操作。
    
90.                 Test01 t1=new Test01(i);
    
91.                 Test02 t2=new Test02(i);
    
92.                 Test03 t3=new Test03(i);
    
93.                 Thread th1=new Thread(t1);
    
94.                 Thread th2=new Thread(t2);
    
95.                 Thread th3=new Thread(t3);
    
96.                
    
97.                 th1.start();
    
98.                 th2.start();
    
99.                 th3.start();
    
100.         }
     
101.        
     
102.        
     
103. }
     
104. 
     

复制代码

1. 
   
2. <DIV class=blockcode>
   
3. <BLOCKQUOTE>
   
4. <BLOCKQUOTE>
   
5. 简单的分析一下题目要求。从题目考察的角度看，题目考的是线程同步知识，既然是顺序打印，那么也就是在某一个时刻只有一个线程处于运行状态，其他两个线程必须出于等待状态。一个线程在一轮打印中，打印5个数字后，必须转为等待状态。另一个线程接着打印下5个数字，如此类推，直到75个数字全部打完。如何判断某一个线程应该打印，这里给每一个线程分配一个id号，0，1，2，如果需要打印的数字c / 5 %3 == id，表示当前线程需要打印一轮。每个线程都必须要判断15次，采用这种方法，算法的复杂度是15*3，共45个循环。这是打印程序中的基本逻辑，那怎么实现同步呢？请看下面的四种解法。
   
6. 
   
7. 解法一
   
8. 
   
9. 既然是同步的打印，很自然的想到synchronized关键字，那么只要把线程的run方法声明为synchronized的，就可以实现线程的同步。这是这个程序的基本解法。具体的代码如下：
   
10. Java代码
    
11. public class NumberPrinter extends Thread {
    
12. static int c = 0;
    
13. private int id;
    
14. 
    
15. @Override
    
16. public synchronized void run() {
    
17. while (c < 75) {
    
18. if (c / 5 % 3 == id) {
    
19. for (int i = 0; i < 5; i++) {
    
20. c++;
    
21. System.out.format("Thread %d: %d %n", id, c);
    
22. }
    
23. }
    
24. }
    
25. }
    
26. 
    
27. public NumberPrinter(int id) {
    
28. super();
    
29. this.id = id;
    
30. }
    
31. 
    
32. public static void main(String[] args) {
    
33. // 启动3个带有id的线程，
    
34. for (int i = 0; i < 3; i++) {
    
35. new NumberPrinter(i).start();
    
36. }
    
37. }
    
38. }
    
39. 解法二
    
40. 
    
41. 解法一中，线程的run方法基本全是对变量c进行操作的，因此，使用synchronized关键字声明方法同步，系统的开销是比较大的，因此我们可以选择volatile关键字对c变量进行声明，让变量c具有CompareAndSet的特性，也就是对变量的引用和操作是同步的。但是这个关键字在JDK5才被很好的支持，如果是JDK4，会出现意象不到的结果。具体的实现看下面的代码。
    
42. Java代码
    
43. class VolatileNumberPrinter extends Thread {
    
44. volatile static int c = 0;
    
45. private int id;
    
46. 
    
47. @Override
    
48. public void run() {
    
49. while (c < 75) {
    
50. if (c / 5 % 3 == id) {
    
51. for (int i = 0; i < 5; i++) {
    
52. c++;
    
53. System.out.format("Thread %d: %d %n", id, c);
    
54. }
    
55. }
    
56. }
    
57. }
    
58. 
    
59. public VolatileNumberPrinter(int id) {
    
60. super();
    
61. this.id = id;
    
62. }
    
63. 
    
64. public static void main(String[] args) {
    
65. for (int i = 0; i < 3; i++) {
    
66. new VolatileNumberPrinter(i).start();
    
67. }
    
68. }
    
69. }
    
70. 解法三
    
71. 
    
72. JDK5及以后的版本提供了并发锁的类，最常用的是ReentralLock，在多线程环境下可以保证被锁住的代码在某一个特定的运行时刻只有拿到锁的线程才可以运行该代码。锁的使用比synchronized关键要灵活，但必须保证该锁在需要的时候被释放。采用锁机制实现同步的代码如下。
    
73. Java代码
    
74. class ReentrantLockNumberPrinter extends Thread {
    
75. static int c;
    
76. private int id;
    
77. private ReentrantLock lock = new ReentrantLock();
    
78. 
    
79. public ReentrantLockNumberPrinter(int id) {
    
80. super();
    
81. this.id = id;
    
82. }
    
83. 
    
84. @Override
    
85. public void run() {
    
86. try {
    
87. lock.lock(); // 拿到锁的线程在运行，没有拿到的线程在等待
    
88. while (c < 75) {
    
89. if (c / 5 % 3 == id) {
    
90. for (int i = 0; i < 5; i++) {
    
91. c++;
    
92. System.out.format("Thread %d: %d %n", id, c);
    
93. }
    
94. }
    
95. }
    
96. } finally { //确保锁被释放
    
97. lock.unlock();
    
98. }
    
99. }
    
100. 
     
101. public static void main(String[] args) {
     
102. for (int i = 0; i < 3; i++) {
     
103. new ReentrantLockNumberPrinter(i).start();
     
104. }
     
105. }
     
106. }
     
107. 解法四
     
108. 
     
109. JDK5的并发包除了提供锁机制的类外，还提供了用于原子操作的类，把需要打印的变量放入到一个原子类中去，调用该类的CompareAndSet操作是具有原子性的，那么在多线程的环境下，可以避免不一致的变量引用。
     
110. 
     
111. Java代码
     
112. class AtomicIntegerNumberPrinter extends Thread {
     
113. private int id;
     
114. static AtomicInteger c = new AtomicInteger(0); //声明一个原子整数，设置初始值为0
     
115. 
     
116. public AtomicIntegerNumberPrinter(int id) {
     
117. super();
     
118. this.id = id;
     
119. }
     
120. 
     
121. public void run() {
     
122. while (c.get() < 75) {
     
123. if (c.get() / 5 % 3 == id) {
     
124. for (int i = 0; i < 5; i++) {
     
125. c.getAndIncrement(); // 相当于 c++,但是具有原子性
     
126. System.out.format("Thread %d: %d %n", id, c.get());
     
127. }
     
128. }
     
129. }
     
130. }
     
131. 
     
132. public static void main(String args[]) {
     
133. for (int i = 0; i < 3; i++) {
     
134. new AtomicIntegerNumberPrinter(i).start();
     
135. }
     
136. }
     
137. }
     
138. 本例中，AtomaticInteger.getAndIncrement()把原子整数中的变量加1，但是具有原子性，可以保证多线程下不会出现不一致的c变量引用。get方法不具有原子性，不过
     
139. Java代码
     
140. c.get() / 5 % 3 == id
     
141. 这行代码能确保一个值是被期望的线程所打印。
     
142. 
     
143. 从上面的四种解法重看，解法一把run方法声明为同步，其实是给该方法加了一把隐形的锁。解法三是采用并发锁的机制，本质上是和解法一是相同的，解法三需要JDK5及其以后的版本，解法一是最稳定的，适应性最广的，任何JDK版本都可以支持。解法二和解法四类似，但是volatile在jdk5后才被很好的支持，也只有jdk5及以后的版本才支持原子类。因此在实际的多线程编程中，首先还是synchronized关键字，wait()和notify()等传统的线程方法。

复制代码