一道多线程题目的解决方案

 

在iteye上看到的一道多线程的题目，参考了一下网友的实现，那Eclipse调试通过，算是对JAVA5的并发库有个大致的了解，分享出来，欢迎拍砖。

题目：

要求用三个线程，按顺序打印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。

分析：感觉出题人是要考察一下你是否能够很好的控制多线程，让他们有序的进行。

1、线程池：3个线程，需要使用并发库的线程池

2、锁（lcok）：在打印的时候，只允许一个线程进入，其他的线程等待

下面的主要的代码：

[java] view plain copy
 
  1. import java.util.HashMap;  
  2. import java.util.Map;  
  3. import java.util.concurrent.CountDownLatch;  
  4. import java.util.concurrent.ExecutorService;  
  5. import java.util.concurrent.Executors;  
  6. import java.util.concurrent.locks.Condition;  
  7. import java.util.concurrent.locks.Lock;  
  8. import java.util.concurrent.locks.ReentrantLock;  
  9.   
  10. public class NumberPrinter {  
  11.   
  12.     private Lock lock = new ReentrantLock();  
  13.   
  14.     private Condition c1 = lock.newCondition();  
  15.     private Condition c2 = lock.newCondition();  
  16.     private Condition c3 = lock.newCondition();  
  17.   
  18.     private Map<Integer, Condition> condtionContext =   
  19.         new HashMap<Integer, Condition>();  
  20.   
  21.     public NumberPrinter() {  
  22.         condtionContext.put(Integer.valueOf(0), c1);  
  23.         condtionContext.put(Integer.valueOf(1), c2);  
  24.         condtionContext.put(Integer.valueOf(2), c3);  
  25.     }  
  26.       
  27.     private int count = 0;     
  28.       
  29.     public void print(int id) {  
  30.         lock.lock();  
  31.         try {  
  32.             while(count*5 < 75) {  
  33.                 int curID = calcID();  
  34.                 if (id == curID) {  
  35.                     for (int i = 1; i<=5; i++) {  
  36.                         System.out.print(count*5 +i+ ",");  
  37.                     }  
  38.                     System.out.println();  
  39.                     count++;  
  40.                     int nextID = calcID();  
  41.                     Condition nextCondition = condtionContext.get(  
  42.                             Integer.valueOf(nextID));  
  43.                     //通知下一线程  
  44.                     nextCondition.signal();  
  45.                 } else {  
  46.                     Condition condition = condtionContext.get(  
  47.                             Integer.valueOf(id));  
  48.                     condition.await();  
  49.                 }  
  50.             }  
  51.             //通知线程结束  
  52.             for(Condition c : condtionContext.values()) {  
  53.                 c.signal();  
  54.             }  
  55.         } catch (Exception e) {  
  56.             e.printStackTrace();  
  57.         } finally {  
  58.             lock.unlock();  
  59.         }  
  60.     }  
  61.   
  62.       
  63.     private int calcID() {  
  64.         // TODO Auto-generated method stub  
  65.         return count % 3;  
  66.     }  
  67.   
  68.   
  69.     /** 
  70.      * @param args 
  71.      */  
  72.     public static void main(String[] args) {  
  73.         ExecutorService executor = Executors.newFixedThreadPool(3);  
  74.         final CountDownLatch latch = new CountDownLatch(1);     
  75.         final NumberPrinter printer = new NumberPrinter();   
  76.         for (int i = 0; i < 3; i++) {     
  77.             final int id = i;  
  78.             executor.submit(new Runnable() {  
  79.                 @Override  
  80.                 public void run() {  
  81.                     // TODO Auto-generated method stub  
  82.                     try {  
  83.                         latch.await();  
  84.                     } catch (InterruptedException e) {  
  85.                         // TODO Auto-generated catch block  
  86.                         e.printStackTrace();  
  87.                     }  
  88.                       
  89.                     printer.print(id);  
  90.                 }  
  91.                   
  92.             });  
  93.         }  
  94.           
  95.         System.out.println("三个任务开始顺序打印数字。。。。。。");   
  96.         latch.countDown();  
  97.         executor.shutdown();  
  98.     }  
  99.   
  100. }