Java面试题1_多线程并发
1.
第一题：现有的程序代码模拟产生了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(); } } }解决方式一:采用线程池
public class Interview1 { public static void main(String[] args){ System.out.println("begin:"+(System.currentTimeMillis()/1000)); /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。 修改程序代码，开四个线程让这16个对象在4秒钟打完。 */ ExecutorService threadPool=Executors.newFixedThreadPool(4); for(int i=0;i<16;i++){ //这行代码不能改动 final String log = ""+(i+1);//这行代码不能改动 { threadPool.execute(new Runnable(){//提交16个任务给线程池 public void run(){ Interview1.parseLog(log); } }); } } threadPool.shutdown(); } //parseLog方法内部的代码不能改动 public static void parseLog(String log){ //为了输出明确添加线程名称 System.out.println(Thread.currentThread().getName()+"..."+log+":"+(System.currentTimeMillis()/1000)); try { Thread.sleep(1000);//可以增加每个线程执行Interview1.parseLog(log)的概率 //不加可能该线程很快执行完空闲,又去执行下一个任务,其它线程机会较少 } catch (InterruptedException e) { e.printStackTrace(); } } }
解决方式二:采用阻塞队列:
class Interview1_2 { public static void main(String[] args){ System.out.println("begin:"+(System.currentTimeMillis()/1000)); /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。 修改程序代码，开四个线程让这16个对象在4秒钟打完。 */ final ArrayBlockingQueue<String> blockQueue=new ArrayBlockingQueue<String> (1);//可以是任意值,下面有循环控制最好1~16 for(int i=0;i<4;++i) new Thread(new Runnable(){ @Override public void run() { while(true){ try { Interview1_2.parseLog(blockQueue.take()); } catch (InterruptedException e) { // TODO 自动生成的 catch 块 e.printStackTrace(); } } } }).start(); for(int i=0;i<16;i++){ //这行代码不能改动 final String log = ""+(i+1);//这行代码不能改动 { try { blockQueue.put(log); } catch (InterruptedException e) { // TODO 自动生成的 catch 块 e.printStackTrace(); } //Interview1_2.parseLog(log); } } } //parseLog方法内部的代码不能改动 public static void parseLog(String log){ //为了输出明确添加线程名称 System.out.println(Thread.currentThread().getName()+"..."+log+":"+(System.currentTimeMillis()/1000)); try { Thread.sleep(1000);//采用阻塞队列,这里如果不让每个线程sleep下,每个线程可能多次take } catch (InterruptedException e) { e.printStackTrace(); } } }
2.
第二题：现成程序中的Test类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理，就好像生产者在不断地产生数据，消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据，这些消费者都调用TestDo.doSome()方法去进行处理，故每个消费者都需要一秒才能处理完，程序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消费者线程拿到的数据是有顺序的。原始代码如下：
package queue; 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; } }为了控制取出的顺序,依然可以采用阻塞队列,每个消费者都需要一秒才能处理完:采用同步
package com.itheima.thread.current.interview; import java.util.concurrent.ArrayBlockingQueue; public class Interview2 { private static ArrayBlockingQueue<String> blockQueue= new ArrayBlockingQueue<String> (10); public static void main(String[] args) { System.out.println("begin:"+(System.currentTimeMillis()/1000)); for(int i=0;i<10;i++){ //这行不能改动 String input = i+""; //这行不能改改动 try { blockQueue.put(input); } catch (InterruptedException e1) { // TODO 自动生成的 catch 块 e1.printStackTrace(); } System.out.println(blockQueue);//可以看到put过程,运行结果主线程,一直在打印,这是因为子线程中doSome的sleep导致 new Thread(new Runnable(){ @Override public void run(){ String output=null; synchronized(Interview2.class){ try { output = TestDo.doSome(blockQueue.take()); } catch (InterruptedException e) { // TODO 自动生成的 catch 块 e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ ":" + output); } } }).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; } } /* 也可以尝试使用SynchronousQueue:一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。 */
3.
第三题：现有程序同时启动了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不同，则并行执行（相互之间不互斥）。原始代码如下：package syn; //不能改动此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(); } } } }第三道题难就难在如何让满足条件的线程的key.equals(anotherKey)==true互斥,不满足的不互斥
思想:将doSome中的代码放到同步代码块中,通过改变锁来控制线程间是否同步
在解决这个问题前,先看本题涉及的其它问题:
代码中:
/*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象， 以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/
this.key = key+key2;
this.value = value;
导致a和b的key不是同一个对象,如果没有这个直接是this.key=key;那么直接将doSome中的代码放到synchronized(key)中就可以完成需求.
为什么不是同一个对象?看一个小例子:
package com.itheima.thread.current.interview; public class StringTest { /** * @param args */ public static void main(String[] args) { // TODO 自动生成的方法存根 String str1="1"+"a"; String str2="1"+"a"; System.out.println(str1==str2);//true compare(str1,str2); } public static void compare(String str1,String str2){ String k1=str1+str2; String k2=str1+str2; System.out.println(k1==k2);//false } }反编译:
public com.itheima.thread.current.interview.StringTest(); Code: 0: aload_0 1: invokespecial #8 // Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); Code: 0: ldc #16 // String 1a 2: astore_1 3: ldc #16 // String 1a 5: astore_2 6: getstatic #18 // Field java/lang/System.out:Ljava/io/PrintStream; 9: aload_1 10: aload_2 11: if_acmpne 18 14: iconst_1 15: goto 19 18: iconst_0 19: invokevirtual #24 // Method java/io/PrintStream.println:(Z)V 22: aload_1 23: aload_2 24: invokestatic #30 // Method compare:(Ljava/lang/String;Ljava/lang/String;) V 27: return public static void compare(java.lang.String, java.lang.String); Code: //采用StringBuilder完成+动作,然后StringBuilder.toString()会new一个新的String对象 0: new #43 // class java/lang/StringBuilder 3: dup 4: aload_0 5: invokestatic #45 // Method java/lang/String.valueOf:(Ljava/lang/Object;)L java/lang/String; 8: invokespecial #49 // Method java/lang/StringBuilder."<init>":(Ljava/lang/S tring;)V 11: aload_1 12: invokevirtual #52 // Method java/lang/StringBuilder.append:(Ljava/lang/Str ing;)Ljava/lang/StringBuilder; 15: invokevirtual #56 // Method java/lang/StringBuilder.toString:()Ljava/lang/ String; 18: astore_2 19: new #43 // class java/lang/StringBuilder 22: dup 23: aload_0 24: invokestatic #45 // Method java/lang/String.valueOf:(Ljava/lang/Object;)L java/lang/String; 27: invokespecial #49 // Method java/lang/StringBuilder."<init>":(Ljava/lang/S tring;)V 30: aload_1 31: invokevirtual #52 // Method java/lang/StringBuilder.append:(Ljava/lang/Str ing;)Ljava/lang/StringBuilder; 34: invokevirtual #56 // Method java/lang/StringBuilder.toString:()Ljava/lang/ String; 37: astore_3 38: getstatic #18 // Field java/lang/System.out:Ljava/io/PrintStream; 41: aload_2 42: aload_3 43: if_acmpne 50 46: iconst_1 47: goto 51 50: iconst_0 51: invokevirtual #24 // Method java/io/PrintStream.println:(Z)V 54: return }再来解决上面的问题:
public class Interview3 extends Thread{ private TestDo2 testDo; private String key; private String value; public Interview3(String key,String key2,String value){ this.testDo = TestDo2.getInstance(); /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象， 以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/ this.key = key+key2; this.value = value; } public static void main(String[] args) throws InterruptedException{ Interview3 a = new Interview3("1","","1"); Interview3 b = new Interview3("1","","2"); Interview3 c = new Interview3("3","","3"); Interview3 d = new Interview3("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 TestDo2 { private TestDo2() {} private ArrayList al=new ArrayList ();//定义一个集合 //private CopyOnWriteArrayList al=new CopyOnWriteArrayList(); private static TestDo2 _instance = new TestDo2(); public static TestDo2 getInstance() { return _instance; } public void doSome(Object key, String value) { Object obj=key; synchronized(TestDo2.class){//这里必须加同步,即使用一个同步的集合(CopyOnArrayList或Collections返回的等)//可以使用同步的集合,然后在add前使用sleep来测试,每个线程可能均执行不到else if(!al.contains(key)){ //同步集合只能保证并发修改数据不会出错(add,remove...)其实也就是只在add上加了同步 al.add(key); //如果不加同步,很可能所有线程都执行al.add(key); } else //obj=al.get(al.indexOf(key));//index内部使用equals进行查找 //一般使用迭代器: for(Iterator it=al.iterator();it.hasNext();){//如果不加同步,可能出现一个线程add,切换到另一个线程it.next Object getObj=it.next(); //并发修改异常,同步的集合可以避免这个异常,保证在add时,//其它线程不能it.next if(getObj.equals(obj)) obj=getObj; } } // 以大括号内的是需要局部同步的代码，不能改动! synchronized(obj) { try { Thread.sleep(1000); System.out.println(key+":"+value + ":" + (System.currentTimeMillis()/1000 )); } catch (InterruptedException e) { e.printStackTrace(); } } } }
