题目如下：现有程序代码模拟产生16个日志对象，并且需要运行16秒才能打印完这些日志。程序代码如下：

  • 单线程打印16条日志的例子
 
  
  1. public class CopyOfTest { 
  2.     /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。 
  3.     修改程序代码，开四个线程让这16个对象在4秒钟打完。 
  4.     */ 
  5.     public static void main(String[] args){ 
  6.         System.out.println("begin:"+(System.currentTimeMillis()/1000)); 
  7.         for(int i=0;i<16;i++){  //这行代码不能改动 
  8.             final String log = ""+(i+1);//这行代码不能改动 
  9.             { 
  10.                     Test.parseLog(log); 
  11.             } 
  12.         } 
  13.     } 
  14.     //parseLog方法内部的代码不能改动 
  15.     public static void parseLog(String log){ 
  16.         System.out.println(log+":"+(System.currentTimeMillis()/1000)); 
  17.         try { 
  18.             Thread.sleep(1000); 
  19.         } catch (InterruptedException e) { 
  20.             e.printStackTrace(); 
  21.         }        
  22.     } 
  23. } 
 
  
上面的程序是单线程打印16条日志，需要16秒打印完成。运行结果如下：
 
  
 
  
现在要求修改程序(代码中不能改动的地方已经给出)，开4个线程，让这16条日志在4秒内打印完成。修改后的代码如下：
 
  
  • 1-2  四个线程在4秒内打印16条“日志”的例子
 
  
 
  
  1. import java.util.concurrent.ArrayBlockingQueue; 
  2. import java.util.concurrent.BlockingQueue; 
  3.  
  4. public class Test { 
  5.     /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。 
  6.     修改程序代码，开四个线程让这16个对象在4秒钟打完。 
  7.     */ 
  8.     public static void main(String[] args){ 
  9.         //定一个阻塞队列 
  10.         final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1); 
  11.         for(int i=0;i<4;i++){//创建4个线程 
  12.             new Thread(new Runnable(){ 
  13.                 @Override 
  14.                 public void run() { 
  15.                     while(true){ 
  16.                         try { 
  17.                             String log = queue.take();//每一个线程都取数据 
  18.                             parseLog(log);//打印"日志"信息 
  19.                         } catch (InterruptedException e) { 
  20.                             e.printStackTrace(); 
  21.                         } 
  22.                     } 
  23.                 } 
  24.             }).start(); 
  25.         } 
  26.          
  27.         System.out.println("begin:"+(System.currentTimeMillis()/1000)); 
  28.         for(int i=0;i<16;i++){  //这行代码不能改动 
  29.             final String log = ""+(i+1);//这行代码不能改动 
  30.             { 
  31.                     try { 
  32.                         queue.put(log);//往队列中放数据，放16条数据 
  33.                     } catch (InterruptedException e) { 
  34.                         e.printStackTrace(); 
  35.                     } 
  36.                     //Test.parseLog(log); 
  37.             } 
  38.         } 
  39.     } 
  40.      
  41.     //parseLog方法内部的代码不能改动 
  42.     public static void parseLog(String log){ 
  43.         System.out.println(log+":"+(System.currentTimeMillis()/1000)); 
  44.         try { 
  45.             Thread.sleep(1000); 
  46.         } catch (InterruptedException e) { 
  47.             e.printStackTrace(); 
  48.         }        
  49.     } 
  50. } 
 
  
程序运行的结果：
 
  
 
  
可以看到，4线程在4秒内打印完原来需要16秒打印完的“日志”信息。