關於多線程練習的幾個題目

第一題：現有的程序代碼模擬產生了16個日志對象，並且需要運行16秒才能打印完這些日志，請在程序中增加4個線程去調用parseLog()方法來分頭打印這16個日志對象，程序只需要運行4秒即可打印完這些日志對象。原始代碼如下：

交給四個線程，打印16個日志對象信息，啟動四個線程容易，但是怎樣將這16個日志對象交給4個線程，這時候我們用阻塞隊列，將要打印的日志信息放到阻塞隊列中，四個線程啟動時都從阻塞隊列中取數據，取完后打印即可。阻塞隊列的大小可以自行設置。

修改為多線程打印日志信息后的代碼及注釋參考下文：

public class Test {
    public static void main(String[] args) {
        System.out.println("begin:" + (System.currentTimeMillis() / 1000)); 
        final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);
        //啟動4個線程
        for(int i = 0; i < 4; i++){
            new Thread(new Runnable(){
                @Override
                public void run() {
                    //不斷從阻塞隊列中取出數據並打印
                    while(true){
                        String log;
                        try {
                            log = queue.take();
                            parseLog(log);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
                
            }).start();
        }
        for (int i = 0; i < 16; i++) { // 這行代碼不能改動
            final String log = "" + (i + 1);// 這行代碼不能改動,生成的日志信息
            {
                try {
                      queue.put(log);                //將日志信息放入阻塞隊列
                      //Test.parseLog(log);            //打印日志信息
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    // parseLog方法內部的代碼不能改動
    public static void parseLog(String log) {
        System.out.println(log + ":" + (System.currentTimeMillis() / 1000));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

第二題：現成程序中的Test類中的代碼在不斷地產生數據，然后交給TestDo.doSome()方法去處理，就好像生產者在不斷地產生數據，消費者在不斷消費數據。請將程序改造成有10個線程來消費生成者產生的數據，這些消費者都調用TestDo.doSome()方法去進行處理，故每個消費者都需要一秒才能處理完，程序應保證這些消費者線程依次有序地消費數據，只有上一個消費者消費完后，下一個消費者才能消費數據，下一個消費者是誰都可以，但要保證這些消費者線程拿到的數據是有順序的。原始代碼如下：

解答：

10個線程，依次消費數據，仍然是將待消費數據放入阻塞隊列，讓10個線程去取數據消費，所不同的是這次消費必須一個一個線程來，而不再是10個線程一起去取，因此用到了線程的同步。同步方法有多種，這里使用Semaphore來進行線程間的同步，代碼及注釋如下：

public class Test {
    
        public static void main(String[] args) {
            
            final SynchronousQueue<String> queue = new SynchronousQueue<String>();
            final Semaphore semaphore = new Semaphore(1);
            //10個線程，分別消費數據，依舊是從阻塞隊列中獲取數據
            for(int i=0; i < 10; i++){
                new Thread(new Runnable(){
                    @Override
                    public void run() {
                        try {
                            semaphore.acquire();
                            String input = queue.take();
                            String output = TestDo.doSome(input);
                            System.out.println(Thread.currentThread().getName()+ ":" + output);
                            semaphore.release();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    
                }).start();
            }
            
            System.out.println("begin:"+(System.currentTimeMillis()/1000));
            for(int i=0;i<10;i++){  //這行不能改動
                String input = i+"";  //這行不能改動，不斷產生數據
                try {
                    queue.put(input);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //String output = TestDo.doSome(input);//不斷消費數據
                //System.out.println(Thread.currentThread().getName()+ ":" + output);
            }
        }
    }