空中网面试题

第一题

现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印完这些日志对象。原始代码如下：

package read;public class Test {public static void main(String[] args){    System.out.println("begin:"+(System.currentTimeMillis()/1000));/*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。修改程序代码，开四个线程让这16个对象在4秒钟打完。*/for(int i=0;i<16;i++){  //这行代码不能改动final String log = ""+(i+1);//这行代码不能改动{     Test.parseLog(log);}}}//parseLog方法内部的代码不能改动public static void parseLog(String log){System.out.println(log+":"+(System.currentTimeMillis()/1000));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}

分析：

主程序Test类的主方法通过16次循环，产生了16个日志文件，并且调用静态方法parseLog(String log)将日志文件打印出来。打印方法每打印一次用时1秒。题目要求增加4个线程用4秒时间将全部日志文件打印完，所以每个线程要调用4次打印方法才能将16个日志文件在4秒钟内打印。主方法中循环16次不可改动，并且不可以在循环中创建线程，因为如果在循环中创建线程会创建16个线程。注意到在循环中创建的日志文件是一个局部变量，所以要用一个容器将产生的日志文件保存起来。我想到用一个容量为16的String数组将日志文件保存。然后每个线程取出数组中的日志文件并调用parseLog方法并将其打印出来。

我的程序

public class Test {public static void main(String[] args){        System.out.println("begin:"+(System.currentTimeMillis()/1000));/*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。修改程序代码，开四个线程让这16个对象在4秒钟打完。*///用String数组将产生的日志缓存起来final String[] buf = new String[16];for(int i=0;i<16;i++){  //这行代码不能改动final String log = ""+(i+1);//这行代码不能改动{     //Test.parseLog(log);//将日志文件放到String数组中保存起来buf[i] = log;}}//新建并启动四个线程for(int i = 0; i < 4; i++){final int temp = i;new Thread(){@Overridepublic void run() {//每一个线程创建4个日志对象for(int j = 0; j < 4; j++){parseLog(buf[temp*4+j]);}}}.start();}}//parseLog方法内部的代码不能改动public static void parseLog(String log){System.out.println(log+":"+(System.currentTimeMillis()/1000));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}

运行

张老师答案：

张老师用的是一个阻塞队列ArrayBlockingQueue将日志文件存储，然后打印。看到打印的日志顺序更加顺序化。

public class Test {public static void main(String[] args){final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);        System.out.println("begin:"+(System.currentTimeMillis()/1000));/*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。修改程序代码，开四个线程让这16个对象在4秒钟打完。*/for(int i=0;i<16;i++){  //这行代码不能改动final String log = ""+(i+1);//这行代码不能改动{     //Test.parseLog(log);try {//将日志文件存储到queue中queue.put(log);} catch (InterruptedException e) {e.printStackTrace();}}}for(int i = 0; i < 4; i++){new Thread(){@Overridepublic void run() {try {for(int j = 0; j < 4; j++){//从queue中取出日志并打印String log = queue.take();parseLog(log);}} catch (InterruptedException e) {e.printStackTrace();}}}.start();}}//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()方法去进行处理，故每个消费者都需要一秒才能处理完，程序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消费者线程拿到的数据是有顺序的。原始代码如下：

public class Test {public static void main(String[] args) {System.out.println("begin:"+(System.currentTimeMillis()/1000));for(int i=0;i<10;i++){  //这行不能改动String input = i+"";  //这行不能改动String output = TestDo.doSome(input);System.out.println(Thread.currentThread().getName()+ ":" + output);}}}//不能改动此TestDo类class TestDo {public static String doSome(String input){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}String output = input + ":"+ (System.currentTimeMillis() / 1000);return output;}}

分析：

因为主程序循环10次产生10个input，并且要求创建10个线程并调用TestDo.doSome()方法，所以想到直接在循环中创建线程。

我的错误答案：

又因为要实现线程的互斥，保证这些消费者线程依次有序地消费数据，想到创建一个单线程池并且在循环中创建Runnable对象作为10个不同的线程并作为target传到线程池并运行。这样实现了线程的有序运行，但是忽略了虽然创建了10个不同的Runnable对象但是线程池只有一个线程，不符合题目要求的10个线程。看程序。

public class Test {public static void main(String[] args) {//一个单线程池ExecutorService pool = Executors.newFixedThreadPool(1);System.out.println("begin:"+(System.currentTimeMillis()/1000));for(int i=0;i<10;i++){  //这行不能改动String input = i+"";  //这行不能改动//String output = TestDo.doSome(input);//System.out.println(Thread.currentThread().getName()+ ":" + output);//因为匿名内部类要用到局部变量input//所以定义一个final修饰的myInput并将赋予input的值final String myInput = input;//创建Runable匿名对象并赋给targetRunnable target = new Runnable() {@Overridepublic void run() {String output = TestDo.doSome(myInput);System.out.println(Thread.currentThread().getName()+ ":" + output);}};//将target交由线程池执行pool.execute(target);}//关闭线程池pool.shutdown();}}//不能改动此TestDo类class TestDo {public static String doSome(String input){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}String output = input + ":"+ (System.currentTimeMillis() / 1000);return output;}}

运行看到只有一个线程

修改：

要使用10个线程并且要有序运行，需要使用一个信号类Semaphore以控制10个线程的运行。

public class Test {public static void main(String[] args) {//信号类控制线程运行final Semaphore semaphore = new Semaphore(1);System.out.println("begin:"+(System.currentTimeMillis()/1000));for(int i=0;i<10;i++){  //这行不能改动String input = i+"";  //这行不能改动//String output = TestDo.doSome(input);//System.out.println(Thread.currentThread().getName()+ ":" + output);final String myInput = input;new Thread(){@Overridepublic void run() {try {//多个线程并发操作要先获取信号才可继续运行semaphore.acquire();String output = TestDo.doSome(myInput);System.out.println(Thread.currentThread().getName()+ ":" + output);//运行完后释放信号semaphore.release();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}.start();}}}//不能改动此TestDo类class TestDo {public static String doSome(String input){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}String output = input + ":"+ (System.currentTimeMillis() / 1000);return output;}}

运行

10条线程每隔1秒运行一次。

第三题

现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法，由于TestDo.doSome(key, value)方法内的代码是先暂停1秒，然后再输出以秒为单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：
4:4:1258199615
1:1:1258199615
3:3:1258199615
1:2:1258199615
请修改代码，如果有几个线程调用TestDo.doSome(key, value)方法时，传递进去的key相等（equals比较为true），则这几个线程应互斥排队输出结果，即当有两个线程的key都是"1"时，它们中的一个要比另外其他线程晚1秒输出结果，如下所示：
4:4:1258199615
1:1:1258199615
3:3:1258199615
1:2:1258199616
总之，当每个线程中指定的key相等时，这些相等key的线程应每隔一秒依次输出时间值（要用互斥），如果key不同，则并行执行（相互之间不互斥）。原始代码如下：

//不能改动此Test类public class Test extends Thread{private TestDo testDo;private String key;private String value;public Test(String key,String key2,String value){this.testDo = TestDo.getInstance();/*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/this.key = key+key2; this.value = value;}public static void main(String[] args) throws InterruptedException{Test a = new Test("1","","1");Test b = new Test("1","","2");Test c = new Test("3","","3");Test d = new Test("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 TestDo {private TestDo() {}private static TestDo _instance = new TestDo();public static TestDo getInstance() {return _instance;}public void doSome(Object key, String value) {// 以大括号内的是需要局部同步的代码，不能改动!{try {Thread.sleep(1000);System.out.println(key+":"+value + ":"+ (System.currentTimeMillis() / 1000));} catch (InterruptedException e) {e.printStackTrace();}}}}

分析：

因为要求在TestDo.doSome方法中，当每个线程中指定的key相等时，这些相等key的线程应每隔一秒依次输出时间值，需要用互斥，所以要在doSome中增加同步代码块并且使用合适的锁以便互斥。如果使用key作为锁，由于在Test类中其构造方法将内容相同的字符串也改变为两个不同的对象，所以不可以实现key内容相同时互斥。所以要想办法将内容相同的key变成同一个对象。

我的错误答案：

因为要将内容相同的key变成一个对象，所以想到使用HashSet，因为将添加到HashSet中的元素不可以内容重复，即内容相同的两个对象只会添加一个，所以取出时就是一个对象，这样，就可以将key作为锁使用同步了。

但是我忽略了HashSet是线程不安全的，线程并发访问时会出现安全隐患。

//不能改动此Test类public class Test1 extends Thread{private TestDo testDo;private String key;private String value;public Test1(String key,String key2,String value){this.testDo = TestDo.getInstance();/*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/this.key = key+key2; this.value = value;}public static void main(String[] args) throws InterruptedException{Test1 a = new Test1("1","","1");Test1 b = new Test1("1","","2");Test1 c = new Test1("3","","3");Test1 d = new Test1("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 TestDo {private Set<Object>set = new HashSet<Object>();private TestDo() {}private static TestDo _instance = new TestDo();public static TestDo getInstance() {return _instance;}public void doSome(Object key, String value) {set.add(key);Iterator<Object> it = set.iterator();Object myKey = null;while(it.hasNext()){try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}String str = (String)it.next();if(str.equals(key)){ myKey = str;}}synchronized(myKey)// 以大括号内的是需要局部同步的代码，不能改动!{try {Thread.sleep(1000);System.out.println(key+":"+value + ":"+ (System.currentTimeMillis() / 1000));} catch (InterruptedException e) {e.printStackTrace();}}}}

运行

如果在遍历时让线程睡眠，则会出现异常。因为线程并发访问HashSet会出现安全隐患：多线程并发访问的情况下，迭代的同时不可以向HashSet中添加元素。

修改：

不使用线程不安全的HashSet而使用JDK1.5提供的线程安全的ConcurrentSkipListSet。

//不能改动此Test类public class Test1 extends Thread{private TestDo testDo;private String key;private String value;public Test1(String key,String key2,String value){this.testDo = TestDo.getInstance();/*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/this.key = key+key2; this.value = value;}public static void main(String[] args) throws InterruptedException{Test1 a = new Test1("1","","1");Test1 b = new Test1("1","","2");Test1 c = new Test1("3","","3");Test1 d = new Test1("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 TestDo {//使用线程安全的ConcurrentSkipListSetprivate ConcurrentSkipListSet<Object>set = new ConcurrentSkipListSet<Object>();private TestDo() {}private static TestDo _instance = new TestDo();public static TestDo getInstance() {return _instance;}public void doSome(Object key, String value) {//将key添加进set，如果set中包含内容重复的元素则不添加set.add(key);Iterator<Object> it = set.iterator();Object myKey = null;while(it.hasNext()){try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}String str = (String)it.next();//找到set中与key内容相同的元素，将其赋给myKey作为锁if(str.equals(key)){ myKey = str;}}synchronized(myKey)// 以大括号内的是需要局部同步的代码，不能改动!{try {Thread.sleep(1000);System.out.println(key+":"+value + ":"+ (System.currentTimeMillis() / 1000));} catch (InterruptedException e) {e.printStackTrace();}}}}

运行

张老师答案：

张老师使用的是线程安全的CopyOnWriteArrayList，将key添加进集合，如果集合中已经包含了该key，那么将集合中的该元素作为锁，这样当key内容相同时使用的锁就会是同一个对象了。

//不能改动此Test类public class Test extends Thread{private TestDo testDo;private String key;private String value;public Test(String key,String key2,String value){this.testDo = TestDo.getInstance();/*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/this.key = key+key2; this.value = value;}public static void main(String[] args) throws InterruptedException{Test a = new Test("1","","1");Test b = new Test("1","","2");Test c = new Test("3","","3");Test d = new Test("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 TestDo {//使用线程安全的CopyOnWriteArrayListprivate CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<Object>();private TestDo() {}private static TestDo _instance = new TestDo();public static TestDo getInstance() {return _instance;}public void doSome(Object key, String value) {Object myKey = key;//如果list中不包含myKey，那么添加if(!list.contains(myKey)){list.add(myKey);}else{//否则，找到与key内容相同的元素并取出//遍历listfor(Iterator<Object> it = list.iterator();it.hasNext();){Object obj = it.next();//找到内容相同的元素if(obj.equals(key)){//将obj赋给myKeymyKey = obj;break;}}}//使用myKey作为锁synchronized(myKey)// 以大括号内的是需要局部同步的代码，不能改动!{try {Thread.sleep(1000);System.out.println(key+":"+value + ":"+ (System.currentTimeMillis() / 1000));} catch (InterruptedException e) {e.printStackTrace();}}}}