資源經理ReentrantLocks

Question

我想實現的是分配資源（字符串，保存在一個數組）到多個客戶端，可以試圖獲取一組資源的鎖，並給出一個ID解鎖的資源處理類通過鎖定方法。

我想使用公平的ReentrantReadWriteLock-s，每個資源的一個。

我只看到客戶端的日誌。

有幾個問題，有時線程不會停止請求和獲取資源，有時會發生死鎖，有時會發生releaseLock失敗。 任何提示讚賞。

public class ResHandler { 

//ID-s of the granted resource lists 
private static long lockNum = 0; 

//Resources are identified by strings, each client has a list of demanded resources 
//we store these when granted, along with an ID 
private static ConcurrentHashMap<Long, Set<String>> usedResources 
    = new ConcurrentHashMap<Long, Set<String>>(); 

//We store a lock for each resource 
private static ConcurrentHashMap<String, ReentrantReadWriteLock> resources 
    = new ConcurrentHashMap<String, ReentrantReadWriteLock>(); 

//Filling our resources map with the resources and their locks 
static { 
    for (int i = 0; i < SharedValues.RESOURCE_LIST.length; ++i) { 
     String res = SharedValues.RESOURCE_LIST[i]; 
     //Fair reentrant lock 
     ReentrantReadWriteLock lc = new ReentrantReadWriteLock(true); 
     resources.put(res, lc); 
    } 
} 

//We get a set of the required resources and the type of lock we have to use 
public static long getLock(Set<String> mNeededRes, boolean mMethod) { 
    //!!! 
    if (mMethod == SharedValues.READ_METHOD) { 

     //We try to get the required resources 
     for (String mn : mNeededRes) 
      resources.get(mn).readLock().lock(); 

     //After grandted, we put them in the usedResources map 
     ++lockNum; 
     usedResources.put(lockNum, mNeededRes); 
     return lockNum;   
    } 

    //Same thing, but with write locks 
    else { 

     for (String mn : mNeededRes) 
      resources.get(mn).writeLock().lock(); 

     ++lockNum; 
     usedResources.put(lockNum, mNeededRes); 
     return lockNum;   
    } 
} 

//Releasing a set of locks by the set's ID 
public static void releaseLock(long mLockID) { 
    if (!usedResources.containsKey(mLockID)) { 
     System.out.println("returned, no such key as: " + mLockID); 
     return; 
    } 

    Set<String> toBeReleased = usedResources.get(mLockID); 

    //Unlocking every lock from this set 
    for (String s : toBeReleased) { 
     if (resources.get(s).isWriteLockedByCurrentThread()) 
      resources.get(s).writeLock().unlock(); 
     else 
      resources.get(s).readLock().unlock(); 
    } 

    //Deleting from the map 
    usedResources.remove(mLockID); 
} 
} 

Answer 1

更新的解決方案，不妨一試：

public class ResHandler { 

private static AtomicLong lockNum = new AtomicLong(0); 
private static Map<Long, Set<String>> usedResources = new ConcurrentHashMap<Long, Set<String>>(); 
private static final Map<String, ReentrantReadWriteLock> resources = new ConcurrentHashMap<String, ReentrantReadWriteLock>(); 
// "priorityResources" to avoid deadlocks and starvation 
private static final Map<String, PriorityBlockingQueue<Long>> priorityResources = new ConcurrentHashMap<String, PriorityBlockingQueue<Long>>(); 

static { 
    for (int i = 0; i < SharedValues.RESOURCE_LIST.length; ++i) { 
     String res = SharedValues.RESOURCE_LIST[i]; 
     ReentrantReadWriteLock lc = new ReentrantReadWriteLock(true); 
     resources.put(res, lc); 
     priorityResources.put(res, new PriorityBlockingQueue<Long>()); 
    } 
} 

public static long getLock(Set<String> mNeededRes, boolean mMethod) { 
    long lockNumLocal = lockNum.addAndGet(1); 
    for (String mn : mNeededRes) { 
     priorityResources.get(mn).offer(lockNumLocal); 
    } 
    boolean tryLockResult; 
    List<String> lockedList = new ArrayList<String>(); 
    boolean allLocked = false; 
    while (!allLocked) { 
     allLocked = true; 
     for (String mn : mNeededRes) { 
      if (lockedList.contains(mn) == true) { 
       continue;//because we already have the lock 
      } 
      try { 
       if (mMethod == SharedValues.READ_METHOD) { 
        tryLockResult = resources.get(mn).readLock().tryLock(1, TimeUnit.MILLISECONDS); 
       } else { 
        tryLockResult = resources.get(mn).writeLock().tryLock(1, TimeUnit.MILLISECONDS); 
       } 
      } catch (InterruptedException ex) { 
       Logger.getLogger(ResHandler.class.getName()).log(Level.SEVERE, null, ex); 
       tryLockResult = false; 
      } 

      if (tryLockResult) { 
       lockedList.add(mn); 
      } else { 
       allLocked = false; 
       for (int i = lockedList.size() - 1; i >= 0; i--) { 
        //if the lock failed, all previous locked resources need to be released, but only if they will be used by higher priority lock operations 
        if (priorityResources.get(lockedList.get(i)).peek() != lockNumLocal) { 
         if (mMethod == SharedValues.READ_METHOD) { 
          resources.get(lockedList.get(i)).readLock().unlock(); 
         } else { 
          resources.get(lockedList.get(i)).writeLock().unlock(); 
         } 
         lockedList.remove(i); 
        } 
       } 
       break; 
      } 
     } 
    } 
    usedResources.put(lockNumLocal, mNeededRes); 
    for (String mn : mNeededRes) { 
     priorityResources.get(mn).remove(lockNumLocal); 
    } 
    return lockNumLocal; 
} 

public static void releaseLock(long mLockID) { 
    if (!usedResources.containsKey(mLockID)) { 
     System.out.println("returned, no such key as: " + mLockID); 
     return; 
    } 

    Set<String> toBeReleased = usedResources.get(mLockID); 

    //Unlocking every lock from this set 
    for (String s : toBeReleased) { 
     if (resources.get(s).isWriteLockedByCurrentThread()) { 
      resources.get(s).writeLock().unlock(); 
     } else { 
      resources.get(s).readLock().unlock(); 
     } 
    } 

    //Deleting from the map 
    usedResources.remove(mLockID); 
} 

}

Answer 2

我假設，不同的客戶端可以從不同的線程調用GETLOCK。如果是這樣，那麼第一個問題是對lockNum的訪問不同步。兩個線程可能同時調用getLock，因此根據時間的不同，它們可能都會返回相同的鎖定編號。這可以解釋爲什麼釋放鎖有時會失敗。

如果你能解決這個問題，應該更容易計算出發生了什麼。

Answer 3

爲了避免死鎖的資源必須以相同的順序被收購，所以你必須在週期執行鎖之前進行排序Set<String> mNeededRes。排序方法並不重要。

這大大Chapter10. Avoiding Liveness Hazards從Java Concurrency In Practice Brian Göetz說明。

標識recoment您刪除getLock和releaseLock或讓他們私人。並將所有的邏輯都包含在Runnable中。如果你控制所有的鎖定，就沒有辦法忘記釋放它們。讓這樣的事情：

public void performMethod(List<String> mNeededRes, boolean mMethod, Runnable r){ 
    List sortd = Collections.sort(mNeededRes); 
    try{ 
     getLock(mNeededRes, mMethod); 
     r.run(); 
    }finally { 
     releaseLock(mNeededRes); 
    } 
} 

Answer 4

有幾個問題在程序上會是對拘留所和錯誤的原因：

• 一般：聲明全局變量決賽。你不想不小心惹上他們。此外，這允許您將它們用作同步對象。

• 長不保證是原子，也不是運算符++。一個32位的JVM必須分兩步寫這個，因此理論上可以在系統中產生一個主要的特性。更好地使用AtomicLong。

• getLock不是線程安全的。例如：

線程A調用GETLOCK資源1，3，5
線程B同時調用GETLOCK資源2,5,3上1,3
線程A被授予鎖，然後它被放置在暫停
線程B被授予鎖2,5然後被放置在從線程B暫停
線程A現在等待5和線程B現在對3等待從線程A.
死鎖。

請注意，發佈方法不需要同步，因爲它不能鎖定任何其他線程。

• ++lockNum如果同時調用這個全局變量，會導致兩個線程混淆它們的鎖定值。

這裏處於工作狀態的代碼：

private static final AtomicLong lockNum = new AtomicLong(0); 
    private static final ConcurrentHashMap<Long, Set<String>> usedResources = new ConcurrentHashMap<Long, Set<String>>(); 
    private static final ConcurrentHashMap<String, ReentrantReadWriteLock> resources = new ConcurrentHashMap<String, ReentrantReadWriteLock>(); 

    static { 
    for (int i = 0; i < SharedValues.RESOURCE_LIST.length; ++i) { 
     String res = SharedValues.RESOURCE_LIST[i]; 
     ReentrantReadWriteLock lc = new ReentrantReadWriteLock(true); 
     resources.put(res, lc); 
    } 
    } 

    public static long getLock(Set<String> mNeededRes, boolean mMethod) { 
    synchronized (resources) { 
     if (mMethod == SharedValues.READ_METHOD) { 
     for (String mn : mNeededRes) { 
      resources.get(mn).readLock().lock(); 
     } 
     } else { 
     for (String mn : mNeededRes) { 
      resources.get(mn).writeLock().lock(); 
     } 
     } 
    } 
    final long lockNumber = lockNum.getAndIncrement(); 
    usedResources.put(lockNumber, mNeededRes); 
    return lockNumber; 
    } 

    public static void releaseLock(final long mLockID) { 
    if (!usedResources.containsKey(mLockID)) { 
     System.out.println("returned, no such key as: " + mLockID); 
     return; 
    } 

    final Set<String> toBeReleased = usedResources.remove(mLockID); 

    for (String s : toBeReleased) { 
     final ReentrantReadWriteLock lock = resources.get(s); 
     if (lock.isWriteLockedByCurrentThread()) { 
     lock.writeLock().unlock(); 
     } else { 
     lock.readLock().unlock(); 
     } 
    } 
    }