Менеджер ресурсов с ReentrantLocks

В вашей программе происходит несколько проблем, которые являются причиной зависаний и ошибок:

• В общем: объявите глобальные переменные окончательными. Не стоит с ними случайно связываться. Вдобавок это позволяет использовать их в качестве объектов синхронизации.

• Не гарантируется, что long будет атомарным, как и оператор ++. 32-разрядная JVM должна записать это в два этапа и, следовательно, теоретически может вызвать серьезный сбой в вашей системе. Лучше использовать AtomicLong.

• GetLock не является потокобезопасным. Пример:

Поток A вызывает getLock для ресурса 1, 3, 5
Поток B вызывает getLock одновременно для ресурса 2,5,3
Потоку A предоставляется блокировка на 1, 3, затем он ставится на паузу
Поток B получает блокировку на 2, 5, затем ставится на паузу
Поток A теперь ожидает 5 от потока B, а поток 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();
      }
    }
  }

Я предполагаю, что разные клиенты могут вызывать getLock из разных потоков. Если это так, то первая проблема заключается в том, что доступ к lockNum не синхронизирован. Два потока могут вызывать getLock одновременно, поэтому, в зависимости от времени, они оба могут закончить возвращение одного и того же номера блокировки. Это могло бы объяснить, почему блокировка разблокировки иногда не работает.

Если вы сможете решить эту проблему, вам будет легче понять, что еще происходит.

Чтобы избежать взаимоблокировки, ваши ресурсы должны быть получены в том же порядке, поэтому вам нужно отсортировать Set<String> mNeededRes перед выполнением циклических блокировок. Метод сортировки особого значения не имеет.

Это подробно описано в Chapter10. Как избежать опасности для жизни от Java Concurrency In Practice Brian Göetz.

Я рекомендую вам удалить 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);
    }
}

Обновленное решение, попробуйте:

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);
}

}