《张孝祥Java多线程与并发库高级应用视频教程》中关于“空中网面试题1”的代码，用了BlockingQueue阻塞队列，增加了一个循环，为什么不用Executors？改进完以后不用增加循环，而且代码更简单，结果一样。
这是原文代码：

1. package read;
   
2. 
   
3. import java.util.concurrent.ArrayBlockingQueue;
   
4. import java.util.concurrent.BlockingQueue;
   
5. 
   
6. public class Test {
   
7.        
   
8.         public static void main(String[] args){
   
9.         final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1);
   
10.                 for(int i=0;i<4;i++){
    
11.                         new Thread(new Runnable(){
    
12.                                 @Override
    
13.                                 public void run() {
    
14.                                         while(true){
    
15.                                                 try {
    
16.                                                         String log = queue.take();
    
17.                                                         parseLog(log);
    
18.                                                 } catch (InterruptedException e) {
    
19.                                                         // TODO Auto-generated catch block
    
20.                                                         e.printStackTrace();
    
21.                                                 }
    
22.                                         }
    
23.                                 }
    
24.                                
    
25.                         }).start();
    
26.                 }
    
27.                
    
28.                 System.out.println("begin:"+(System.currentTimeMillis()/1000));
    
29.                 /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。
    
30.                 修改程序代码，开四个线程让这16个对象在4秒钟打完。
    
31.                 */
    
32.                 for(int i=0;i<16;i++){  //这行代码不能改动
    
33.                         final String log = ""+(i+1);//这行代码不能改动
    
34.                         {
    
35.                                         try {
    
36.                                                 queue.put(log);
    
37.                                         } catch (InterruptedException e) {
    
38.                                                 // TODO Auto-generated catch block
    
39.                                                 e.printStackTrace();
    
40.                                         }
    
41.                                      //Test.parseLog(log);
    
42.                         }
    
43.                 }
    
44.         }
    
45.        
    
46.         //parseLog方法内部的代码不能改动
    
47.         public static void parseLog(String log){
    
48.                 System.out.println(log+":"+(System.currentTimeMillis()/1000));
    
49.                
    
50.                 try {
    
51.                         Thread.sleep(1000);
    
52.                 } catch (InterruptedException e) {
    
53.                         e.printStackTrace();
    
54.                 }               
    
55.         }
    
56.        
    
57. }
    

复制代码

这是改进的：

1. package read;
   
2. 
   
3. import java.util.concurrent.ExecutorService;
   
4. import java.util.concurrent.Executors;
   
5. 
   
6. public class t {
   
7. 
   
8.         public static void main(String[] args) {
   
9. 
   
10.                 System.out.println("begin:" + (System.currentTimeMillis() / 1000));
    
11.                 /*
    
12.                  * 模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。
    
13.                  * 修改程序代码，开四个线程让这16个对象在4秒钟打完。
    
14.                  */
    
15.                 ExecutorService es = Executors.newFixedThreadPool(4);
    
16.                 for (int i = 0; i < 16; i++) { // 这行代码不能改动
    
17.                         final String log = "" + (i + 1);// 这行代码不能改动
    
18.                         es.execute(new Runnable() {
    
19.                                 @Override
    
20.                                 public void run() {
    
21.                                         // TODO Auto-generated method stub
    
22.                                         Test.parseLog(log);
    
23.                                 }
    
24.                         });
    
25.                 }
    
26.                 es.shutdown();
    
27.         }
    
28. 
    
29.         // parseLog方法内部的代码不能改动
    
30.         public static void parseLog(String log) {
    
31.                 System.out.println(log + ":" + (System.currentTimeMillis() / 1000));
    
32. 
    
33.                 try {
    
34.                         Thread.sleep(1000);
    
35.                 } catch (InterruptedException e) {
    
36.                         e.printStackTrace();
    
37.                 }
    
38.         }
    
39. 
    
40. }
    

复制代码

你这样肯定是不行的，你开的那4个线程没有指定顺序，完全可能输出2、1、4、3这种顺序。我拿你的代码运行就输出了：
begin:1407602421
1:1407602421
2:1407602421
3:1407602421
4:1407602421
5:1407602422
6:1407602422
7:1407602422
8:1407602422
9:1407602423
12:1407602423
11:1407602423
10:1407602423
13:1407602424
16:1407602424
15:1407602424
14:1407602424
很明显顺序乱了

嗯。线程没有指定顺序！

额。。题目中没有要求有序

fantacyleo 发表于 2014-8-10 00:43
你这样肯定是不行的，你开的那4个线程没有指定顺序，完全可能输出2、1、4、3这种顺序。我拿你的代码运行就 ...

张老师的也没有指定顺序，你多运行几遍也会乱序，因为在第一秒内，四个线程依次生成，他们在take()的时候应该是有序的，但是在后面三秒等待take()的时候也是随意获取的，如果安排他们顺序的话，时间就要应该就不是4秒了。当然我的更乱。
这是某一次的运行结果（看13、14）：
begin:1407686503
1:1407686503
2:1407686503
3:1407686503
4:1407686503
5:1407686504
6:1407686504
7:1407686504
8:1407686504
9:1407686505
10:1407686505
11:1407686505
12:1407686505
14:1407686506
13:1407686506
15:1407686506
16:1407686506

wnmmp 发表于 2014-8-11 00:11
张老师的也没有指定顺序，你多运行几遍也会乱序，因为在第一秒内，四个线程依次生成，他们在take()的时候 ...

所以张老师的解法也是有问题的。。。因为原先的代码直接运行是有序的，而张老师之所以把BlockingQueue的size设为1，其意图也是想保持有序，但事与愿违。第三题张老师的解法也有问题，几年前有人给他发邮件指出，他也承认了

fantacyleo 发表于 2014-8-11 00:19
所以张老师的解法也是有问题的。。。因为原先的代码直接运行是有序的，而张老师之所以把BlockingQueue的s ...

哇塞，你好牛！知道的很多啊

fantacyleo 发表于 2014-8-11 00:19
所以张老师的解法也是有问题的。。。因为原先的代码直接运行是有序的，而张老师之所以把BlockingQueue的s ...

那么，应该怎么解比较好？

a6511631 发表于 2014-8-11 08:23
那么，应该怎么解比较好？

在楼主解法的

1. es.execute(new Runnable() {
   
2.                                 @Override
   
3.                                 public void run() {
   
4.                                         // TODO Auto-generated method stub
   
5.                                         Test.parseLog(log);
   
6.                                 }
   
7.                         });

复制代码

语句之后加一句Thread.sleep(10);  这是我目前唯一能想出来的办法。网上也有不少人尝试顺序输出，但都不行

fantacyleo 发表于 2014-8-11 10:36
在楼主解法的

语句之后加一句Thread.sleep(10);  这是我目前唯一能想出来的办法。网上也有不少人尝试顺 ...

这个还算可行，要是能知道线程运行的时间就更好设置sleep时间了