亚洲好骚综合-亚洲黄色录像-亚洲黄色网址-亚洲黄色网址大全-99久久99久久-99久久99久久精品国产

　　在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）：在打印的時候，只允許一個線程進入，其他的線程等待

　　下面的主要的代碼：

    import java.util.HashMap; 
    import java.util.Map; 
    import java.util.concurrent.CountDownLatch; 
    import java.util.concurrent.utorService; 
    import java.util.concurrent.utors; 
    import java.util.concurrent.locks.Condition; 
    import java.util.concurrent.locks.Lock; 
    import java.util.concurrent.locks.ReentrantLock; 
    public class NumberPrinter { 
        private Lock lock = new ReentrantLock（）; 
        private Condition c1 = lock.newCondition（）; 
        private Condition c2 = lock.newCondition（）; 
        private Condition c3 = lock.newCondition（）; 
        private Map<Integer， Condition> condtionContext =  
            new HashMap<Integer， Condition>（）; 
        public NumberPrinter（） { 
            condtionContext.put（Integer.valueOf（0）， c1）; 
            condtionContext.put（Integer.valueOf（1）， c2）; 
            condtionContext.put（Integer.valueOf（2）， c3）; 
        } 
         
        private int count = 0;    
         
        public void print（int id） { 
            lock.lock（）; 
            try { 
                while（count*5 < 75） { 
                    int curID = calcID（）; 
                    if （id == curID） { 
                        for （int i = 1; i<=5; i++） { 
                            System.out.print（count*5 +i+ "，"）; 
                        } 
                        System.out.println（）; 
                        count++; 
                        int nextID = calcID（）; 
                        Condition nextCondition = condtionContext.get（ 
                                Integer.valueOf（nextID））; 
                        //通知下一線程
                        nextCondition.signal（）; 
                    } else { 
                        Condition condition = condtionContext.get（ 
                                Integer.valueOf（id））; 
                        condition.await（）; 
                    } 
                } 
                //通知線程結束
                for（Condition c : condtionContext.values（）） { 
                    c.signal（）; 
                } 
            } catch （Exception e） { 
                e.printStackTrace（）; 
            } finally { 
                lock.unlock（）; 
            } 
        } 
         
        private int calcID（） { 
            // TODO Auto-generated method stub
            return count ％ 3; 
        } 
        /**
         * ＠param args
         */
        public static void main（String[] args） { 
            utorService executor = utors.newFixedThreadPool（3）; 
            final CountDownLatch latch = new CountDownLatch（1）;    
            final NumberPrinter printer = new NumberPrinter（）;  
            for （int i = 0; i < 3; i++） {    
                final int id = i; 
                executor.submit（new Runnable（） { 
                    ＠Override
                    public void run（） { 
                        // TODO Auto-generated method stub
                        try { 
                            latch.await（）; 
                        } catch （InterruptedException e） { 
                            // TODO Auto-generated catch block
                            e.printStackTrace（）; 
                        } 
                        printer.print（id）; 
                    } 
                }）; 
            } 
            System.out.println（"三個任務開始順序打印數字。。。。。。"）;  
            latch.countDown（）; 
            executor.shutdown（）; 
        } 
    }