空中网三道线程面试题

avatar 2017年05月25日18:20:02 0 2300 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
空中网4k/5k月薪挑选大四实习生的线程题

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

第一题：


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

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

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

运行结果如动态图




第二题：


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

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

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

运行结果动态图


第三题：


现有程序同时启动了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;
  3.     //不能改动此Test类    
  4.     public class Test extends Thread{
  6.         private TestDo testDo;
  7.         private String key;
  8.         private String value;
  10.         public Test(String key,String key2,String value){
  11.             this.testDo = TestDo.getInstance();
  12.             /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，
  13.             以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/
  14.             this.key = key+key2;
  15.             this.value = value;
  16.         }
  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();
  30.         }
  32.         public void run(){
  33.             testDo.doSome(key, value);
  34.         }
  35.     }
  37.     class TestDo {
  39.         private TestDo() {}
  40.         private static TestDo _instance = new TestDo();
  41.         public static TestDo getInstance() {
  42.             return _instance;
  43.         }
  45.         public void doSome(Object key, String value) {
  47.             // 以大括号内的是需要局部同步的代码，不能改动!
  48.             {
  49.                 try {
  50.                     Thread.sleep(1000);
  51.                     System.out.println(key+":"+value + ":"
  52.                             + (System.currentTimeMillis() / 1000));
  53.                 } catch (InterruptedException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.         }
  59.     }

参考答案如下(来自张孝祥视频)
  1. package syn;
  3. /*
  4.  *
  5.  * @author Yanzh
  6.  *
  7.  */
  10. //不能改动此Test类    
  11. public class Test extends Thread{
  13.     private TestDo testDo;
  14.     private String key;
  15.     private String value;
  17.     public Test(String key,String key2,String value){
  18.         this.testDo = TestDo.getInstance();
  19.         /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，
  20.         以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/
  21.         this.key = key; //key+key2; 
  22.         this.value = value;
  23.     }
  26.     public static void main(String[] args) throws InterruptedException{
  27.         Test a = new Test("1","","1");
  28.         Test b = new Test("1","","2");
  29.         Test c = new Test("3","","3");
  30.         Test d = new Test("4","","4");
  31.         System.out.println("begin:"+(System.currentTimeMillis()/1000));
  32.         a.start();
  33.         b.start();
  34.         c.start();
  35.         d.start();
  37.     }
  39.     public void run(){
  40.         testDo.doSome(key, value);
  41.     }
  42. }
  44. class TestDo {
  46.     private TestDo() {}
  47.     private static TestDo _instance = new TestDo();
  48.     public static TestDo getInstance() {
  49.         return _instance;
  50.     }
  54.     public void doSome(Object key, String value) {
  55.         synchronized (key)
  56.         // 以大括号内的是需要局部同步的代码，不能改动!
  57.         {
  58.             try {
  59.                 Thread.sleep(1000);
  60.                 System.out.println(key+":"+value + ":"
  61.                         + (System.currentTimeMillis() / 1000));
  62.             } catch (InterruptedException e) {
  63.                 e.printStackTrace();
  64.             }
  65.         }
  66.     }
  68. }

运行结果动态图





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

转载请注明

历史上的今天
五月
25日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0