关于多线程练习的几个题目

第一题：现有的程序代码模拟产生了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);
            }
        }
    }