空中网线程题

第一题：现有的程序代码模拟产生了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();
   }  
  }
  
 }

正解:

package read;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
 
 public class Test {
  
  public static void main(String[] args){
   final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);
         for(int i = 0 ;i<4; i++ ){
          new Thread(new Runnable(){

     @Override
     public void run() {
      while(true){
       try {
        String log = queue.take();
        Test.parseLog(log);
       } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        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);//这行代码不能改动
    {
//          Test.parseLog(log);
         try {
       queue.put(log);
      } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       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();
   }  
  }
  
 }

 

第二题：现成程序中的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 queue;

import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;
 
 public class Test {
 
  public static void main(String[] args) {
   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() {
      String input;
      try {
       semaphore.acquire();
       input = queue.take();
       String output = TestDo.doSome(input);
          System.out.println(Thread.currentThread().getName()+":"+output);
          semaphore.release();
      } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
      }
      
     }
     
    }).start();
   }
   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);
    try {
     queue.put(input);
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
  }
 }
 
 //不能改动此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;
  }
 }

 第三题：现有程序同时启动了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();
    }
   }
  }

 }

 

正解:

package syn;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

 //不能改动此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;
  }
       
//  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 it = keys.iterator();it.hasNext();){
           Object oo = it.next();
           o = oo;
          }
         }
        
   synchronized(o){
   // 以大括号内的是需要局部同步的代码，不能改动!
   {
    try {
     Thread.sleep(1000);
     System.out.println(key+":"+value + ":"
       + (System.currentTimeMillis() / 1000));
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }
  }
 }

关键点：1. 必须用一个同步锁. 如果没有key则添加到集合中,如果有相同的key则需要把后面的KEY指向新的key

              2. 防止并发修改异常，这就是将读写分离技术

 

1、JAVA中“=”操作只是将引用和某个对象关联，假如同时有一个线程将引用指向另外一个对象，一个线程获取这个引用指向的对象，那么他们之间不会发生ConcurrentModificationException，他们是在虚拟机层面阻塞的，而且速度非常快，几乎不需要CPU时间。

2、JAVA中两个不同的引用指向同一个对象，当第一个引用指向另外一个对象时，第二个引用还将保持原来的对象。

基于上面这个常识，我们再来探讨下面这个问题：

在CopyOnWriteArrayList里处理写操作（包括add、remove、set等）是先将原始的数据通过JDK1.6的Arrays.copyof()来生成一份新的数组

然后在新的数据对象上进行写，写完后再将原来的引用指向到当前这个数据对象（这里应用了常识1），这样保证了每次写都是在新的对象上（因为要保证写的一致性，这里要对各种写操作要加一把锁，JDK1.6在这里用了重入锁），

然后读的时候就是在引用的当前对象上进行读（包括get，iterator等），不存在加锁和阻塞，针对iterator使用了一个叫COWIterator的阉割版迭代器，因为不支持写操作，当获取CopyOnWriteArrayList的迭代器时，是将迭代器里的数据引用指向当前引用指向的数据对象，无论未来发生什么写操作，都不会再更改迭代器里的数据对象引用，所以迭代器也很安全（这里应用了常识2）。

CopyOnWriteArrayList中写操作需要大面积复制数组，所以性能肯定很差，但是读操作因为操作的对象和写操作不是同一个对象，读之间也不需要加锁，读和写之间的同步处理只是在写完后通过一个简单的“=”将引用指向新的数组对象上来，这个几乎不需要时间，这样读操作就很快很安全，适合在多线程里使用，绝对不会发生ConcurrentModificationException，所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。