1. package syn;
   
2. 
   
3.         //不能改动此Test类       
   
4.         public class Test extends Thread{
   
5.                
   
6.                 private TestDo testDo;
   
7.                 private String key;
   
8.                 private String value;
   
9.                
   
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.                 }
    
17. 
    
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.                 }
    
31.                
    
32.                 public void run(){
    
33.                         testDo.doSome(key, value);
    
34.                 }
    
35.         }
    
36. 
    
37.         class TestDo {
    
38. 
    
39.                 private TestDo() {}
    
40.                 private static TestDo _instance = new TestDo();       
    
41.                 public static TestDo getInstance() {
    
42.                         return _instance;
    
43.                 }
    
44. 
    
45.                 public void doSome(Object key, String value) {
    
46.        
    
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.                 }
    
58. 
    
59.         }

复制代码

以上是原题，其中有老师注解
本人有一种简单解法，用key.hashCode()作为互斥的锁即可：

1. package syn;
   
2. 
   
3. import java.util.concurrent.ArrayBlockingQueue;
   
4. import java.util.concurrent.BlockingQueue;
   
5. import java.util.concurrent.LinkedBlockingDeque;
   
6. 
   
7. //不能改动此Test类       
   
8. public class Test extends Thread {
   
9. 
   
10.         private TestDo testDo;
    
11.         private String key;
    
12.         private String value;
    
13. 
    
14.         public Test(String key, String key2, String value) {
    
15.                 this.testDo = TestDo.getInstance();
    
16.                 /*
    
17.                  * 常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，
    
18.                  * 以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果
    
19.                  */
    
20.                 this.key = key + key2;
    
21.                 this.value = value;
    
22.         }
    
23. 
    
24.         public static void main(String[] args) throws InterruptedException {
    
25.                 Test a = new Test("1", "", "1");
    
26.                 Test b = new Test("1", "", "2");
    
27.                 Test c = new Test("3", "", "3");
    
28.                 Test d = new Test("4", "", "4");
    
29.                 System.out.println("begin:" + (System.currentTimeMillis() / 1000));
    
30.                 a.start();
    
31.                 b.start();
    
32.                 c.start();
    
33.                 d.start();
    
34. 
    
35.         }
    
36. 
    
37.         public void run() {
    
38.                 testDo.doSome(key, value);
    
39.         }
    
40. }
    
41. 
    
42. class TestDo {
    
43. 
    
44.         private TestDo() {
    
45.         }
    
46. 
    
47.         private static TestDo _instance = new TestDo();
    
48. 
    
49.         public static TestDo getInstance() {
    
50.                 return _instance;
    
51.         }
    
52. 
    
53.         public void doSome(Object key, String value) {
    
54.                 //解答如下：
    
55.                 synchronized ((Integer) key.hashCode()) {
    
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.                 }
    
67.         }
    
68. }

复制代码

谢谢分享!