多线程Demo-空中网面试题（张孝祥讲解）

摘自传智播客_张孝祥_空中网挑选实习生的面试题 视频教程的,(主要是线程与队列的使用).

与本人无关,仅供以后参考使用

空中网4k/5k月薪挑选大四实习生的线程题
    两年前，我们一个大四的学员去应聘空中网的实习生职位，空中网只给他出了三道线程题，拿回家做两天后再去给经理讲解，如果前两题做好了给4k月薪，第三道题也做出来的话就给5k的月薪。这样的实习薪水和招聘要求，不需要有工作经验的限制，纯粹是技术功底的比拼和考核，而不像许多其他公司非要招两年工作经验的人，逼得那些刚毕业和未毕业的大学生不得不去撒谎，不得不去做假简历，甚至假毕业证！所以，空中网的这份工作对未毕业的大学生来说，还是很有吸引力的。这个学生是否入职空中网，大家去猜吧，免得有人看不顺眼而叫骂，呵呵！
    第一题：现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印完这些日志对象。原始代码如下：
  

[java]  view plain copy

1. package read;  
2.      
3.    public class Test {  
4.          
5.        public static void main(String[] args){  
6.              
7.            System.out.println("begin:"+(System.currentTimeMillis()/1000));  
8.            /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。 
9.            修改程序代码，开四个线程让这16个对象在4秒钟打完。 
10.            */  
11.            for(int i=0;i<16;i++){  //这行代码不能改动  
12.                final String log = ""+(i+1);//这行代码不能改动  
13.                {  
14.                         Test.parseLog(log);  
15.                }  
16.            }  
17.        }  
18.          
19.        //parseLog方法内部的代码不能改动  
20.        public static void parseLog(String log){  
21.            System.out.println(log+":"+(System.currentTimeMillis()/1000));  
22.              
23.            try {  
24.                Thread.sleep(1000);  
25.            } catch (InterruptedException e) {  
26.                e.printStackTrace();  
27.            }          
28.        }  
29.          
30.    }  

修改后的代码如下:

[java]  view plain copy

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. }  

//*****************************************************

      第二题：现成程序中的Test类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理，就好像生产者在不断地产生数据，消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据，这些消费者都调用TestDo.doSome()方法去进行处理，故每个消费者都需要一秒才能处理完，程序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消费者线程拿到的数据是有顺序的。原始代码如下：

   

[java]  view plain copy

1. package queue;  
2.       
3.     public class Test3 {  
4.       
5.         public static void main(String[] args) {  
6.               
7.             System.out.println("begin:"+(System.currentTimeMillis()/1000));  
8.             for(int i=0;i<10;i++){  //这行不能改动  
9.                 String input = i+"";  //这行不能改动  
10.                 String output = TestDo.doSome(input);  
11.                 System.out.println(Thread.currentThread().getName()+ ":" + output);  
12.             }  
13.         }  
14.     }  
15.       
16.     //不能改动此TestDo类  
17.     class TestDo {  
18.         public static String doSome(String input){  
19.               
20.             try {  
21.                 Thread.sleep(1000);  
22.             } catch (InterruptedException e) {  
23.                 e.printStackTrace();  
24.             }  
25.             String output = input + ":"+ (System.currentTimeMillis() / 1000);  
26.             return output;  
27.         }  
28.     }  

修改后的代码如下:

[java]  view plain copy

1. package queue;  
2.   
3. import java.util.concurrent.Semaphore;  
4. import java.util.concurrent.SynchronousQueue;  
5.   
6. public class Test {  
7.   
8.     public static void main(String[] args) {  
9.         final Semaphore semaphore = new Semaphore(1);  
10.         final SynchronousQueue<String> queue = new SynchronousQueue<String>();  
11.         for(int i=0;i<10;i++){  
12.             new Thread(new Runnable(){  
13.                 @Override  
14.                 public void run() {   
15.                     try {  
16.                         semaphore.acquire();  
17.                         String input = queue.take();  
18.                         String output = TestDo.doSome(input);  
19.                         System.out.println(Thread.currentThread().getName()+ ":" + output);  
20.                         semaphore.release();  
21.                     } catch (InterruptedException e) {  
22.                         // TODO Auto-generated catch block  
23.                         e.printStackTrace();  
24.                     }     
25.                 }  
26.             }).start();  
27.         }  
28.           
29.         System.out.println("begin:"+(System.currentTimeMillis()/1000));  
30.         for(int i=0;i<10;i++){  //这行不能改动  
31.             String input = i+"";  //这行不能改动  
32.             try {  
33.                 queue.put(input);  
34.             } catch (InterruptedException e) {  
35.                 // TODO Auto-generated catch block  
36.                 e.printStackTrace();  
37.             }  
38.         }  
39.     }  
40. }  
41.   
42. //不能改动此TestDo类  
43. class TestDo {  
44.     public static String doSome(String input){  
45.           
46.         try {  
47.             Thread.sleep(1000);  
48.         } catch (InterruptedException e) {  
49.             e.printStackTrace();  
50.         }  
51.         String output = input + ":"+ (System.currentTimeMillis() / 1000);  
52.         return output;  
53.     }  
54. }  

//*************************************************

      第三题：现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法，由于TestDo.doSome(key, value)方法内的代码是先暂停1秒，然后再输出以秒为单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：
        4:4:1258199615
        1:1:1258199615
        3:3:1258199615
        1:2:1258199615
        请修改代码，如果有几个线程调用TestDo.doSome(key, value)方法时，传递进去的key相等（equals比较为true），则这几个线程应互斥排队输出结果，即当有两个线程的key都是"1"时，它们中的一个要比另外其他线程晚1秒输出结果，如下所示：
        4:4:1258199615
        1:1:1258199615
        3:3:1258199615
        1:2:1258199616
      总之，当每个线程中指定的key相等时，这些相等key的线程应每隔一秒依次输出时间值（要用互斥），如果key不同，则并行执行（相互之间不互斥）。原始代码如下：

   

[java]  view plain copy

1. package syn;  
2.   
3.     //不能改动此Test类      
4.     public class Test extends Thread{  
5.           
6.         private TestDo testDo;  
7.         private String key;  
8.         private String value;  
9.           
10.         public Test(String key,String key2,String value){  
11.             this.testDo = TestDo.getInstance();  
12.             /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象（因为是编译后才相加的）， 
13.             以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/  
14.             this.key = key+key2;  
15.             this.value = value;  
16.         }  
17.   
18.   
19.         public static void main(String[] args) throws InterruptedException{  
20.             Test a = new Test("1","","1");  
21.             Test b = new Test("1","","2");  
22.             Test c = new Test("3","","3");  
23.             Test d = new Test("4","","4");  
24.             System.out.println("begin:"+(System.currentTimeMillis()/1000));  
25.             a.start();  
26.             b.start();  
27.             c.start();  
28.             d.start();  
29.   
30.         }  
31.           
32.         public void run(){  
33.             testDo.doSome(key, value);  
34.         }  
35.     }  
36.   
37.     class TestDo {  
38.   
39.         private TestDo() {}  
40.         private static TestDo _instance = new TestDo();      
41.         public static TestDo getInstance() {  
42.             return _instance;  
43.         }  
44.   
45.         public void doSome(Object key, String value) {  
46.       
47.             // 以大括号内的是需要局部同步的代码，不能改动!  
48.             {  
49.                 try {  
50.                     Thread.sleep(1000);  
51.                     System.out.println(key+":"+value + ":"  
52.                             + (System.currentTimeMillis() / 1000));  
53.                 } catch (InterruptedException e) {  
54.                     e.printStackTrace();  
55.                 }  
56.             }  
57.         }  
58.   
59.     }  

修改后的代码如下:

[java]  view plain copy

1. package syn;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.concurrent.CopyOnWriteArrayList;  
6.   
7. //不能改动此Test类      
8. public class Test extends Thread{  
9.       
10.     private TestDo testDo;  
11.     private String key;  
12.     private String value;  
13.       
14.     public Test(String key,String key2,String value){  
15.         this.testDo = TestDo.getInstance();  
16.         /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象， 
17.         以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/  
18.         this.key = key+key2;   
19. /*      a = "1"+""; 
20.         b = "1"+"" 
21. */  
22.         this.value = value;  
23.     }  
24.   
25.   
26.     public static void main(String[] args) throws InterruptedException{  
27.         Test a = new Test("1","","1");  
28.         Test b = new Test("1","","2");  
29.         Test c = new Test("3","","3");  
30.         Test d = new Test("4","","4");  
31.         System.out.println("begin:"+(System.currentTimeMillis()/1000));  
32.         a.start();  
33.         b.start();  
34.         c.start();  
35.         d.start();  
36.   
37.     }  
38.       
39.     public void run(){  
40.         testDo.doSome(key, value);  
41.     }  
42. }  
43.   
44. class TestDo {  
45.   
46.     private TestDo() {}  
47.     private static TestDo _instance = new TestDo();   
48.     public static TestDo getInstance() {  
49.         return _instance;  
50.     }  
51.   
52.     //private ArrayList keys = new ArrayList();  
53.     private CopyOnWriteArrayList keys = new CopyOnWriteArrayList();  
54.     public void doSome(Object key, String value) {  
55.         Object o = key;  
56.         if(!keys.contains(o)){  
57.             keys.add(o);  
58.         }else{  
59.   
60.             for(Iterator iter=keys.iterator();iter.hasNext();){  
61.                 try {  
62.                     Thread.sleep(20);  
63.                 } catch (InterruptedException e) {  
64.                     // TODO Auto-generated catch block  
65.                     e.printStackTrace();  
66.                 }  
67.                 Object oo = iter.next();  
68.                 if(oo.equals(o)){  
69.                     o = oo;  
70.                     break;  
71.                 }  
72.             }  
73.         }  
74.         synchronized(o)  
75.         // 以大括号内的是需要局部同步的代码，不能改动!  
76.         {  
77.             try {  
78.                 Thread.sleep(1000);  
79.                 System.out.println(key+":"+value + ":"  
80.                         + (System.currentTimeMillis() / 1000));  
81.             } catch (InterruptedException e) {  
82.                 e.printStackTrace();  
83.             }  
84.         }  
85.     }  
86.   
87. }