JDK新特性3

package heima;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
/*
 * 第三题：现有程序同时启动了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不同，则并行执行（相互之间不互斥）。原始代码如下：
 *
 *
 */

public class Test3  extends Thread{
    private TestDo3 testDo;
    private String key;
    private String value;
   
    public Test3(String key,String key2,String value){
     this.testDo = TestDo3.getInstance();
     this.key=key+key2;
     this.value=value;
    }
   
    @Override
    public void run() {
          testDo.doSome(key,value);
    }
   
 public static void main(String[] args) {
       Test3 a = new Test3("1","","1");
    Test3 b = new Test3("1","","2");
    Test3 c = new Test3("3","","3");
    Test3 d = new Test3("4","","4");
    System.out.println("begin:"+(System.currentTimeMillis()));
   
    a.start();
    b.start();
    c.start();
    d.start();
 }

}
class TestDo3{
 private TestDo3(){}
 private  static TestDo3 testDo = new TestDo3();
 public static TestDo3 getInstance(){
  return testDo;
 }
 private ArrayList keys = new ArrayList();
 private CopyOnWriteArrayList keyss = new CopyOnWriteArrayList();
 public void doSome(Object key,String value){
  {
   Object o=key;
   System.out.println("key:"+key);
   if(!keys.contains(o)){
    keys.add(o);
   }else{
    for(Iterator iter=keys.iterator();iter.hasNext();){
     
     /*try {
      Thread.sleep(20);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }*/
     
     Object oo = iter.next();
     if(oo.equals(o)){
      o=oo;
     }
    }
   }
   
   
   synchronized (o) {
    try {
     
     Thread.sleep(1000);
     System.out.println(key+":"+value+":"+(System.currentTimeMillis()/1000));
     
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }
 }
}