空中网多线程面试题

1. 空中网面试题1  
  
package com.kongzhongwang.interview;  
  
import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.BlockingQueue;  
  
//myeclipse强大功能：将代码直接复制到项目的src路径下可以自动相应生成包名和类名  
/** 
 *  
 *    空中网面试题1：现有程序代码模拟产生16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加四个线程去调用 
 * parseLog()方法来分头打印这16个日志对象，程序只需运行4秒即可打印完这些日志对象。 
 * 考察新技术BlockingQueue 
 */  
  
public class ReadLog {  
    public static void main(String[] args) {  
  
        /*此处有一个巧合：这里ArrayBlockingQueue<String>(1)和ArrayBlockingQueue<String>(16) 
         * 达到的效果一样，并且前者产生的数据组合更整齐；目前推测是巧合，希望大牛发现因果了告知一声 
         */  
        final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1);  
        for (int i = 0; i < 4; i++) {  
            new Thread(new Runnable() {  
                public void run() {  
                    while (true) {  
                        try {  
                            String log = queue.take();  
                            parseLog(log);  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                }  
            }).start();  
        }  
        System.out.println("begin:" + (System.currentTimeMillis() / 1000));  
        /* 
         * 模拟处理16个日志，下面代码产生了16个日志对象；当前代码需要运行16秒才能打印完成这些日志对象; 
         * 修改程序代码，开四个线程让16个对象在4秒内打完 
         */  
        for (int i = 0; i < 16; i++) { // 这行代码不能改动  
            final String log = "" + (i + 1); // 这行代码不能改动  
            {  
                // ReadLog.parseLog(log);  
                try {  
                    queue.put(log);  
                } catch (InterruptedException 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();  
        }  
    }  
}  
2. 空中网面试题2  
  
package com.kongzhongwang.interview;  
  
import java.util.concurrent.Semaphore;  
import java.util.concurrent.SynchronousQueue;  
  
/** 
 *    空中网面试题2： 现成程序中的Test类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理； 
 * 这就好像是生产者在不断地产生数据，消费者在不断地消费数据。请将程序改造成有10个线程来消费生产者产生的数据， 
 * 这些消费者都调用TestDo.doSome()方法去处理，固每个消费者都需要1秒才能处理完，程序应该保证这些 
 * 消费者线程依次有序的消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以， 但要保证消费者拿到的数据是有顺序的。 
 */  
public class Test {  
  
    public static void main(String[] args) {  
  
        //使用semaphore信号灯相当于上一个lock锁  
        final Semaphore semaphore = new Semaphore(1);  
        //新的队列方式  
        final SynchronousQueue<String> queue = new SynchronousQueue<String>();  
        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 (InterruptedException 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 (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  
  
// TestDo类不能动  
class TestDo {  
  
    public static String doSome(String input) {  
        try {  
            Thread.sleep(1000);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        String output = input + ":" + (System.currentTimeMillis() / 1000);  
        return output;  
    }  
  
}  
 3.空中网面试题3  
  
package com.kongzhongwang.interview;  
  
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.concurrent.CopyOnWriteArrayList;  
  
public class Tests extends Thread {  
  
    /** 
     * 空中网面试题3： 现有程序同时启动了四个线程去调用TestDo.doSome(key,value)方法； 
     * 由于TestsDo.doSome(key,value)方法内的代码是先暂停1秒，然后再输出以秒为单位的当前时间值， 
     * 所以会打印出四个相同的时间值，如下所示：4：4 1258199615 1:1 1258199615 3:3 1258199615 2:2 
     * 1258199615 ；请修改代码，如果有几个线程调用TestDo.doSome(key,value)方法时； 
     * 传递进去的key值相等（equals比较为true），则这几个线程应互斥输出结果，即当有两个线程的key都为1时， 
     * 它们中的一个要比其他线程晚一步输出结果，如下所示：4：4 1258199615 1:1 1258199615 3:3 1258199615 1:2 
     * 1258199616 ；总之每个线程中指定的key相等时；这些相等的线程应每隔1秒输出时间值（要用互斥）， 
     * key不同，则并行执行（相互之间不互斥） 
     */  
  
    private TestsDo testDo;  
    private String key;  
    private String value;  
  
    private Tests(String key, String key2, String value) {  
        this.testDo = TestsDo.getInstance();  
        /* 
         * 常量“1”和“1”是同一个对象，下面这行代码就是要用“1”+“”的方式产生新的对象； 
         * 以实现内容没有改变，仍然相等（都还为“1”），但对象却不再是同一个的效果 
         */  
        this.key = key + key2;  
        /* 
         * a = "1"+""; 
         * b = "2"+""; 
         * a和b是同一个对象，因为编译器在执行之前就会将其优化为 a=“1”； 
         * 但是this.key = key + key2;这句，编译器不会给你优化， 
         * 因为你是属性变量，编译器不知道你将来要传入什么值 
         */  
        this.value = value;  
    }  
  
    public static void main(String[] args) {  
  
        Tests a = new Tests("1", "", "1");  
        Tests b = new Tests("1", "", "2");  
        Tests c = new Tests("3", "", "3");  
        Tests d = new Tests("4", "", "4");  
        System.out.println("begin:" + (System.currentTimeMillis() / 1000));  
        a.start();  
        b.start();  
        c.start();  
        d.start();  
    }  
  
    public void run() {  
        testDo.doSome(key, value);  
    }  
}  
  
class TestsDo {  
    private TestsDo() {}  
    private static TestsDo _instance = new TestsDo();  
    public static TestsDo getInstance() {  
        return _instance;  
    }  
    //传统写法，没有考虑到线程并发问题    
//  private ArrayList keys = new ArrayList();  
    private CopyOnWriteArrayList keys = new CopyOnWriteArrayList();  
    public void doSome(Object key,String value){  
        Object o = key;  
        if(! keys.contains(o)){  
            keys.add(o);  
        }else{  
            //迭代的过程中不能进行其他操作；  
            for(Iterator iter = keys.iterator();iter.hasNext();){  
                /*这里的休眠作用：为了让大家看到，使用传统的private ArrayList keys = new ArrayList()； 
                 * 会导致Exception in thread "Thread-1" java.util.ConcurrentModificationException异常 
                 * 因为迭代的过程中不能进行其他操作；你非要在迭代的时候向其中添加数据就会导致这种异常，而且在迭代中放入休眠这种错误百发百中。 
                 */  
                try {  
                    Thread.sleep(20);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                Object oo = iter.next();  
                if(o.equals(oo)){  
                o = oo;   
                }  
            }  
        }  
        //这里为了区别是不同对象，所以不能直接使用synchronized(key)  
        synchronized(o)  
        //大括号内的是需要同步的代码，不能改动  
        {  
            try{  
                Thread.sleep(1000);  
                System.out.println(key+":"+value+":" + (System.currentTimeMillis() / 1000));  
            }catch(Exception e){  
                e.printStackTrace();  
            }  
        }  
    }  
}

本文出自 “点滴积累” 博客，请务必保留此出处http://tianxingzhe.blog.51cto.com/3390077/1717050