private void releaseOwnership() {
lock.lock();
try {
operations.popCacheAction();
if (!operations.isInCacheAction()) {
owner = null;
condition.signalAll();
}
} finally {
lock.unlock();
}
}
private void finishLongRunningOperation(boolean wasEnded) {
lock.lock();
try {
operations.popLongRunningOperation();
if (operations.isInCacheAction()) {
restoreOwner();
if (wasEnded) {
onStartWork();
}
}
} finally {
lock.unlock();
}
}
public <K, V> MultiProcessSafePersistentIndexedCache<K, V> newCache(
final PersistentIndexedCacheParameters<K, V> parameters) {
Factory<BTreePersistentIndexedCache<K, V>> indexedCacheFactory =
new Factory<BTreePersistentIndexedCache<K, V>>() {
public BTreePersistentIndexedCache<K, V> create() {
return doCreateCache(
parameters.getCacheFile(),
parameters.getKeySerializer(),
parameters.getValueSerializer());
}
};
MultiProcessSafePersistentIndexedCache<K, V> indexedCache =
parameters.decorate(
new DefaultMultiProcessSafePersistentIndexedCache<K, V>(
indexedCacheFactory, fileAccess));
lock.lock();
try {
caches.add(indexedCache);
if (fileLock != null) {
indexedCache.onStartWork(operations.getDescription(), stateAtOpen);
}
} finally {
lock.unlock();
}
return indexedCache;
}
private boolean startLongRunningOperation(String operationDisplayName) {
boolean wasEnded;
lock.lock();
try {
if (operations.isInCacheAction()) {
checkThreadIsOwner();
wasEnded = onEndWork();
owner = null;
condition.signalAll();
} else {
wasEnded = false;
}
operations.pushLongRunningOperation(operationDisplayName);
} finally {
lock.unlock();
}
return wasEnded;
}
private boolean onStartWork() {
if (fileLock != null) {
return false;
}
fileLock =
lockManager.lock(
lockFile,
lockOptions.withMode(Exclusive),
cacheDisplayName,
operations.getDescription());
stateAtOpen = fileLock.getState();
for (UnitOfWorkParticipant cache : caches) {
cache.onStartWork(operations.getDescription(), stateAtOpen);
}
lockManager.allowContention(fileLock, whenContended());
return true;
}
private void takeOwnership(String operationDisplayName) {
lock.lock();
try {
while (owner != null && owner != Thread.currentThread()) {
try {
condition.await();
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
owner = Thread.currentThread();
operations.pushCacheAction(operationDisplayName);
} finally {
lock.unlock();
}
}