做支付寶支付接入時遇到一個問題，對同一個訂單，可能同時存在”支付寶伺服器非同步通知支付結果更新狀態“和“使用者主動要求發起查詢支付結果更新狀態"兩個過程。因為在查詢要使用者已支付訂單完成後要向其它系統發起交易請求，所以要求對同一訂單，兩個過程執行緒必須在更新時是同步執行的。但如果不區分的對整個更新方法加鎖，則併發量又上不去。綜合考慮，我決定自行實現一個鎖機制，要求加鎖後的更新方法做到以下要求：1、對不同的訂單，執行更新方法的執行緒是非同步執行的；2、對相同的訂單，執行更新方法的執行緒是同步執行的。

初步的程式碼實現如下：

import java.util.HashMap;

/**
 * 訂單鎖，當兩個執行緒同時操作同一個oderNo訂單時，進入臨界區，不同的oderNo不涉及臨界區操作.<br>
 * <p>Long order=1234l;<br>
 * try{<br>
 * 	OrderLock.lock(oderNo);<br>
 *  同步程式碼執行……<br>
 * }finally{<br>
 * 	OrderLock.unlock();<br>
 * }</p>
 * <br>
 *
 */
public class OrderLock {
	
	private final static HashMap<Long,ObjectLocker<String>> LockerStore=new HashMap<Long,ObjectLocker<String>>();
	
	private final static Object lock=new Object();
	
	/**
	 * 嘗試進入訂單號臨界區，其它執行緒若在其後呼叫此訂單號進入，則等待此執行緒釋放鎖後才能進入臨界區
	 * @param oderNo 訂單號，若已有其它執行緒使用相同的訂單號呼叫此方法，則需要等待其它執行緒呼叫過unlock方法後才能進入臨界區
	 */
	public static void lock(String oderNo){
		ObjectLocker<String> objLoc=null;
		synchronized (lock) {
			for(Long id : LockerStore.keySet()){
				if(LockerStore.get(id).equals(oderNo)){
					objLoc=LockerStore.get(id);
				}
			}
			if(objLoc==null){
				objLoc=new ObjectLocker<String>(oderNo);
			}
			LockerStore.put(Thread.currentThread().getId(), objLoc);
		}
		objLoc.lock();
	}
	
	/**
	 * 解除鎖，允許其它執行緒進入訂單臨界區
	 */
	public static void unlock(){
		ObjectLocker<String> objLoc=null;
		synchronized (lock) {
			objLoc=LockerStore.remove(Thread.currentThread().getId());
		}
		if(objLoc!=null){
			objLoc.unlock();
		}
	}
	
	/**
	 * 物件鎖
	 *
	 * @param <T>
	 */
	static class ObjectLocker<T> {

		private final Object locker = new Object();

		private final static long nullThread = -1;

		private long threadId = nullThread;
		
		private int requestCount=0;

		private T target;

		public ObjectLocker(T target) {
			super();
			this.target = target;
		}

		@Override
		public boolean equals(Object obj) {
			if(target==null){
				return super.equals(obj);
			}else{
				return target.equals(obj);
			}
			
		}
		public void lock() {
			synchronized (locker) {
				requestCount++;
				do {
					long currThread=Thread.currentThread().getId();
					if (currThread == threadId || threadId == nullThread) {
						threadId = currThread;
						break;
					}
					try {
						locker.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} while (true);

			}
		}

		public void unlock() {
			synchronized (locker) {
				requestCount--;
				if (Thread.currentThread().getId() == threadId) {
					threadId = nullThread;
					locker.notifyAll();
				}
			}
		}
		
		public int getReqeustCount(){
			return requestCount;
		}

	}
}
 

初步的測試程式碼

import java.util.ArrayList;
import java.util.HashMap;

public class LockTest {
	
	static HashMap<Long,ArrayList<Long>> cache=new HashMap<Long,ArrayList<Long>>();

	static class TestThread extends Thread{
		
		Long orderNo;
		
		public TestThread(Long orderNo) {
			super();
			this.orderNo = orderNo;
		}

		@Override
		public void run() {
			try {
				sleep(2000l);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			for(int i=0;i<60;++i){
				try{
				//	System.out.println("執行緒"+getId()+"等待鎖"+orderNo+"……");
					OrderLock.lock(orderNo.toString());
					cache.get(orderNo).add(getId());
						try {
							sleep(20l);
						} catch (InterruptedException e) {}
				
			//		System.out.println("執行緒"+getId()+"獲得鎖"+orderNo+"……");		
				} finally{
					cache.get(orderNo).add(getId());
					OrderLock.unlock();
				}
		//		System.out.println("執行緒"+getId()+"釋放鎖"+orderNo+"……");
				try {
					sleep(20l);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	public static void main(String[] args) {
		long time0=System.currentTimeMillis();
		TestThread[] ts=new TestThread[24];
		cache.put(0l, new ArrayList<Long>());
		cache.put(1l, new ArrayList<Long>());
		cache.put(2l, new ArrayList<Long>());
		cache.put(3l, new ArrayList<Long>());
		for(int i=0;i<ts.length;++i){
			ts[i]=new TestThread(i%4l);
			ts[i].start();
		}
		for(int i=0;i<ts.length;++i){
			try {
				ts[i].join();
			} catch (InterruptedException e) {}
		}
		System.out.println(System.currentTimeMillis()-time0);
		for(Long key : cache.keySet()){
			ArrayList<Long> l=cache.get(key);
			int len=l.size()/2;
			for(int i=0;i<len;i++){
				if(!l.get(2*i).equals(l.get(2*i+1))){
					System.out.println(2*i);
					System.out.println(l.get(2*i));
					System.out.println(l.get(2*i+1));
					System.out.println(list2String(l));
					throw new RuntimeException("出現錯誤");
				}
			}
		//	System.out.println(list2String(l));
		}
	}
	static String list2String(ArrayList<Long> l){
		String tmp="";
		for(Long i : l){
			tmp+=i+",";
		}
		return tmp;
	}
}