一个 java 多线程问题，讨论一下

上周的时候，碰到一个问题，多线程同时处理一个 key,value 值结构的数据表，需求是这样的：要采用多线程来同时处理这些数据，但是如果与到 key 值相同的数据则要看目前有没有与之相同 key 的数据正在被处理中，如果有则等待之处理完毕后再进行，我写了一个 doSome(String key, String value)的方法，但是对这个方法加锁就不是多线程同时在处理了，主要就是这里面的 key 值应该怎么来处理为了描述我的问题，我把代码贴出吧：

Test.java

Java 代码

1. public class Test extends Thread{

3.  private TestDo testDo;  
   ​

4.  private String key;  
   ​

5.  private String value;  
   ​

7.  public Test(String key,String key2,String value){  
   ​

8.      this.testDo = TestDo.getInstance();  
   ​

9.      this.key = new String(key+key2);  
   ​

10.      this.value = value;  
    ​

11.  }  
    ​

13.  public static void main(String[] args) throws InterruptedException{  
    ​

14.      Test a = new Test("1","","1");  
    ​

15.      Test b = new Test("1","","2");  
    ​

16.      Test c = new Test("3","","3");  
    ​

17.      Test d = new Test("4","","4");  
    ​

18.      System.out.println("begin:"+(System.currentTimeMillis()/1000));  
    ​

19.      a.start();  
    ​

20.      c.start();  
    ​

21.      d.start();  
    ​

22.      b.start();  
    ​

23.  }  
    ​

25.  public void run(){  
    ​

26.      testDo.doSome(key, value);  
    ​

27.  }  
    ​

28. }

TestDo.java

Java 代码

1. public class TestDo {

3.  private static TestDo _instance = new TestDo();  
   ​

4.  //private static ReentrantLock lock = new ReentrantLock ();  
   ​

5.  public static TestDo getInstance() {  
   ​

6.      return _instance;  
   ​

7.  }  
   ​

9.  //public synchronized void doSome(Object key, String value) {  
   ​

10.  public void doSome(Object key, String value) {  
    ​

12.      // 以下代码是需要局部同步的代码  
    ​

13.      {  
    ​

14.          try {  
    ​

15.              Thread.sleep(1000);  
    ​

16.              System.out.println(key+":"+value + ":" + (System.currentTimeMillis() / 1000));  
    ​

17.          } catch (InterruptedException e) {  
    ​

18.              e.printStackTrace();  
    ​

19.          }  
    ​

20.      }  
    ​

21.  }     
    ​

23.  private TestDo() {  
    ​

25.  }  
    ​

26. }

前提是只能修改 TestDo 类中的 doSome 方法，期望的输出要为：
1:1:1256392306
3:3:1256392306
4:4:1256392306
1:2:1256392307
由于最后一个的 key 值与第一个相同，所以它等待第一个执行完毕后再运行，时间差 1 秒
synchronized 应用的作用域为方法或代码块，来实现同步。不知道你用的这个数据结构是不是 Map，你关注的应该是不想让同一个 key 所对应的 value 值被同时操作，所以我们只要关注这一点就行了，就是在对 value 写操作时进行同步，比如 HashMap 里面，你只要在 put 方法的修饰符后面加上 synchronized 就可以达到同步了，这样还会提高效率，因为我们关注的就是这一点啊，我假设你用的是 HashMap，我们重写他的方法，只要加 synchronized，如：
public synchronized V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}

    modCount++; 
    addEntry(hash, key, value, i); 
    return null; 
}
​