空中网三道线程面试题

avatar 2017年5月25日18:20:02 评论 95 views

空中网4k/5k月薪挑选大四实习生的线程题

两年前,我们一个大四的学员去应聘空中网的实习生职位,空中网只给他出了三道线程题,拿回家做两天后再去给经理讲解,如果前两题做好了给4k月薪,第三道题也做出来的话就给5k的月薪。这样的实习薪水和招聘要求,不需要有工作经验的限制,纯粹是技术功底的比拼和考核,而不像许多其他公司非要招两年工作经验的人,逼得那些刚毕业和未毕业的大学生不得不去撒谎,不得不去做假简历,甚至假毕业证!所以,空中网的这份工作对未毕业的大学生来说,还是很有吸引力的。这个学生是否入职空中网,大家去猜吧,免得有人看不顺眼而叫骂,呵呵!

第一题:

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

原始代码如下:

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

参考答案如下(来自张孝祥视频)

  1. package read;
  2. import java.util.concurrent.ArrayBlockingQueue;
  3. import java.util.concurrent.BlockingDeque;
  4. import java.util.concurrent.BlockingQueue;
  5. /*
  6.  *
  7.  * @author Yanzh
  8.  *
  9.  */
  10. public class Test {
  11.     public static void main(String[] args){
  12.         final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);//也可以是1
  13.         for(int i=0;i<4;i++) {
  14.             new Thread(new Runnable() {
  15.                 @Override
  16.                 public void run() {
  17.                     while(true) {
  18.                         String log;
  19.                         try {
  20.                             log = queue.take();
  21.                             parseLog(log);
  22.                         } catch (InterruptedException e) {
  23.                             // TODO Auto-generated catch block
  24.                             e.printStackTrace();
  25.                         }
  26.                     }
  27.                 }
  28.             }).start();
  29.         }
  30.         System.out.println("begin:"+(System.currentTimeMillis()/1000));
  31.         /*模拟处理16行日志,下面的代码产生了16个日志对象,当前代码需要运行16秒才能打印完这些日志。
  32.         修改程序代码,开四个线程让这16个对象在4秒钟打完。
  33.         */
  34.         for(int i=0;i<16;i++){  //这行代码不能改动
  35.             final String log = ""+(i+1);//这行代码不能改动
  36.             {
  37.                 try {
  38.                     queue.put(log);
  39.                 } catch (InterruptedException e) {
  40.                     // TODO Auto-generated catch block
  41.                     e.printStackTrace();
  42.                 }
  43.                 //Test.parseLog(log);
  44.             }
  45.         }
  46.     }
  47.     //parseLog方法内部的代码不能改动
  48.     public static void parseLog(String log){
  49.         System.out.println(log+":"+(System.currentTimeMillis()/1000));
  50.         try {
  51.             Thread.sleep(1000);
  52.         } catch (InterruptedException e) {
  53.             e.printStackTrace();
  54.         }
  55.     }
  56. }

运行结果如动态图

 

第二题:

现成程序中的Test类中的代码在不断地产生数据,然后交给TestDo.doSome()方法去处理,就好像生产者在不断地产生数据,消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据,这些消费者都调用TestDo.doSome()方法去进行处理,故每个消费者都需要一秒才能处理完,程序应保证这些消费者线程依次有序地消费数据,只有上一个消费者消费完后,下一个消费者才能消费数据,下一个消费者是谁都可以,但要保证这些消费者线程拿到的数据是有顺序的。

原始代码如下:

  1. package queue;
  2.     public class Test {
  3.         public static void main(String[] args) {
  4.             System.out.println("begin:"+(System.currentTimeMillis()/1000));
  5.             for(int i=0;i<10;i++){  //这行不能改动
  6.                 String input = i+"";  //这行不能改动
  7.                 String output = TestDo.doSome(input);
  8.                 System.out.println(Thread.currentThread().getName()+ ":" + output);
  9.             }
  10.         }
  11.     }
  12.     //不能改动此TestDo类
  13.     class TestDo {
  14.         public static String doSome(String input){
  15.             try {
  16.                 Thread.sleep(1000);
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.             String output = input + ":"+ (System.currentTimeMillis() / 1000);
  21.             return output;
  22.         }
  23.     }

参考答案如下(来自张孝祥视频)

  1. package queue;
  2. import java.util.concurrent.Semaphore;
  3. import java.util.concurrent.SynchronousQueue;
  4. /*
  5.  *
  6.  * @author Yanzh
  7.  *
  8.  */
  9. public class Test {
  10.     public static void main(String[] args) {
  11.         Semaphore semaphore = new Semaphore(1);
  12.         final SynchronousQueue<String> queue = new SynchronousQueue<String>();
  13.         for(int i=0;i<10;i++) {
  14.             new Thread(new Runnable() {
  15.                 @Override
  16.                 public void run() {
  17.                     String input;
  18.                     try {
  19.                         semaphore.acquire();
  20.                         input = queue.take();
  21.                         String output = TestDo.doSome(input);
  22.                         System.out.println(Thread.currentThread().getName()+ ":" + output);
  23.                         semaphore.release();
  24.                     } catch (InterruptedException e) {
  25.                         // TODO Auto-generated catch block
  26.                         e.printStackTrace();
  27.                     }
  28.                 }
  29.             }).start();
  30.         }
  31.         System.out.println("begin:"+(System.currentTimeMillis()/1000));
  32.         for(int i=0;i<10;i++){  //这行不能改动
  33.             String input = i+"";  //这行不能改动
  34.             try {
  35.                 queue.put(input);
  36.             } catch (InterruptedException e) {
  37.                 // TODO Auto-generated catch block
  38.                 e.printStackTrace();
  39.             }
  40.         }
  41.     }
  42. }
  43. //不能改动此TestDo类
  44. class TestDo {
  45.     public static String doSome(String input){
  46.         try {
  47.             Thread.sleep(1000);
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }
  51.         String output = input + ":"+ (System.currentTimeMillis() / 1000);
  52.         return output;
  53.     }
  54. }

运行结果动态图

第三题:

现有程序同时启动了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不同,则并行执行(相互之间不互斥)。

原始代码如下:

  1. package syn;
  2.     //不能改动此Test类    
  3.     public class Test extends Thread{
  4.         private TestDo testDo;
  5.         private String key;
  6.         private String value;
  7.         public Test(String key,String key2,String value){
  8.             this.testDo = TestDo.getInstance();
  9.             /*常量"1"和"1"是同一个对象,下面这行代码就是要用"1"+""的方式产生新的对象,
  10.             以实现内容没有改变,仍然相等(都还为"1"),但对象却不再是同一个的效果*/
  11.             this.key = key+key2;
  12.             this.value = value;
  13.         }
  14.         public static void main(String[] args) throws InterruptedException{
  15.             Test a = new Test("1","","1");
  16.             Test b = new Test("1","","2");
  17.             Test c = new Test("3","","3");
  18.             Test d = new Test("4","","4");
  19.             System.out.println("begin:"+(System.currentTimeMillis()/1000));
  20.             a.start();
  21.             b.start();
  22.             c.start();
  23.             d.start();
  24.         }
  25.         public void run(){
  26.             testDo.doSome(key, value);
  27.         }
  28.     }
  29.     class TestDo {
  30.         private TestDo() {}
  31.         private static TestDo _instance = new TestDo();
  32.         public static TestDo getInstance() {
  33.             return _instance;
  34.         }
  35.         public void doSome(Object key, String value) {
  36.             // 以大括号内的是需要局部同步的代码,不能改动!
  37.             {
  38.                 try {
  39.                     Thread.sleep(1000);
  40.                     System.out.println(key+":"+value + ":"
  41.                             + (System.currentTimeMillis() / 1000));
  42.                 } catch (InterruptedException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         }
  47.     }

参考答案如下(来自张孝祥视频)

  1. package syn;
  2. /*
  3.  *
  4.  * @author Yanzh
  5.  *
  6.  */
  7. //不能改动此Test类    
  8. public class Test extends Thread{
  9.     private TestDo testDo;
  10.     private String key;
  11.     private String value;
  12.     public Test(String key,String key2,String value){
  13.         this.testDo = TestDo.getInstance();
  14.         /*常量"1"和"1"是同一个对象,下面这行代码就是要用"1"+""的方式产生新的对象,
  15.         以实现内容没有改变,仍然相等(都还为"1"),但对象却不再是同一个的效果*/
  16.         this.key = key; //key+key2; 
  17.         this.value = value;
  18.     }
  19.     public static void main(String[] args) throws InterruptedException{
  20.         Test a = new Test("1","","1");
  21.         Test b = new Test("1","","2");
  22.         Test c = new Test("3","","3");
  23.         Test d = new Test("4","","4");
  24.         System.out.println("begin:"+(System.currentTimeMillis()/1000));
  25.         a.start();
  26.         b.start();
  27.         c.start();
  28.         d.start();
  29.     }
  30.     public void run(){
  31.         testDo.doSome(key, value);
  32.     }
  33. }
  34. class TestDo {
  35.     private TestDo() {}
  36.     private static TestDo _instance = new TestDo();
  37.     public static TestDo getInstance() {
  38.         return _instance;
  39.     }
  40.     public void doSome(Object key, String value) {
  41.         synchronized (key)
  42.         // 以大括号内的是需要局部同步的代码,不能改动!
  43.         {
  44.             try {
  45.                 Thread.sleep(1000);
  46.                 System.out.println(key+":"+value + ":"
  47.                         + (System.currentTimeMillis() / 1000));
  48.             } catch (InterruptedException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }
  52.     }
  53. }

运行结果动态图

 

本文地址:https://liuyanzhao.com/4406.html

转载请注明

 

  • 微信
  • 交流学习,有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享,问题解决,技术交流。群号:590480292
  • weinxin
avatar

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: