public virtual Resource CheckPoint()
{
Lock writeLock = @lock.writeLock();
writeLock.@lock();
return(writeLock.unlock);
}
internal EntryUpdater(Lock @lock)
{
this.@lock = @lock;
if (@lock != null)
{
this._thread = Thread.CurrentThread;
@lock.@lock();
}
}
//-------------------------------------------------------------------------
/// <summary>
/// Creates an instance wrapping the specified listener. </summary>
/// <param name="listener"> the underlying listener wrapped by this object </param>
/// <param name="tasksExpected"> the number of tasks to be executed </param>
/// <param name="columns"> the columns for which values are being calculated </param>
internal ListenerWrapper(CalculationListener listener, int tasksExpected, IList <CalculationTarget> targets, IList <Column> columns)
{
this.listener = ArgChecker.notNull(listener, "listener");
this.tasksExpected = ArgChecker.notNegative(tasksExpected, "tasksExpected");
listenerLock.@lock();
try
{
listener.calculationsStarted(targets, columns);
if (tasksExpected == 0)
{
listener.calculationsComplete();
}
}
finally
{
listenerLock.unlock();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.graphdb.Resource storeCopy(org.neo4j.function.ThrowingAction<java.io.IOException> beforeFirstConcurrentStoreCopy) throws java.io.IOException
public virtual Resource StoreCopy(ThrowingAction <IOException> beforeFirstConcurrentStoreCopy)
{
Lock readLock = @lock.readLock();
bool firstConcurrentRead = IncrementCount() == 0;
bool success = false;
try
{
if (firstConcurrentRead)
{
try
{
beforeFirstConcurrentStoreCopy.Apply();
}
catch (IOException e)
{
_storeCopyActionError = e;
throw e;
}
catch (Exception e)
{
_storeCopyActionError = e;
throw new IOException(e);
}
_storeCopyActionCompleted = true;
}
else
{
// Wait for the "before" first store copy to complete
WaitForFirstStoreCopyActionToComplete();
}
success = true;
}
finally
{
if (success)
{
readLock.@lock();
}
else
{
DecrementCount();
}
}
return(() =>
{
// Decrement concurrent store-copy count
DecrementCount();
readLock.unlock();
});
}
public virtual void RecoverIndexSamples()
{
_samplingLock.@lock();
try
{
IndexMap indexMap = _indexMapSnapshotProvider.indexMapSnapshot();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.iterator.LongIterator indexIds = indexMap.indexIds();
LongIterator indexIds = indexMap.IndexIds();
while (indexIds.hasNext())
{
long indexId = indexIds.next();
if (_indexRecoveryCondition.test(indexMap.GetIndexProxy(indexId).Descriptor))
{
SampleIndexOnCurrentThread(indexMap, indexId);
}
}
}
finally
{
_samplingLock.unlock();
}
}
public virtual bool CanExecuteMoreSamplingJobs()
{
@lock.@lock();
try
{
return(!_stopped && _executingJobs.Count < _jobLimit);
}
finally
{
@lock.unlock();
}
}
private LockWrapper(Lock @lock, UpdateLock managingLock, Logger logger)
{
this.@lock = @lock;
if (_debugLocking)
{
if ([email protected]())
{
logger.Log(Thread.CurrentThread + " may block on " + @lock + " of " + managingLock);
while (!TryLockBlocking(@lock, managingLock, logger))
{
logger.Log(Thread.CurrentThread + " still blocked on " + @lock + " of " + managingLock);
}
}
}
else
{
@lock.@lock();
}
}
internal virtual void CloseInstantiateCloseLock()
{
InstantiateCloseLock.@lock();
_closed = true;
InstantiateCloseLock.unlock();
}
//-------------------------------------------------------------------------
/// <summary>
/// Accepts a calculation result and delivers it to the listener
/// <para>
/// This method can be invoked concurrently by multiple threads.
/// Only one of them will invoke the listener directly to ensure that
/// it is not accessed concurrently by multiple threads.
/// </para>
/// <para>
/// The other threads do not block while the listener is invoked. They
/// add their results to a queue and return quickly. Their results are
/// delivered by the thread invoking the listener.
///
/// </para>
/// </summary>
/// <param name="result"> the result of a calculation </param>
public override void accept(CalculationResults result)
{
CalculationResults nextResult;
// Multiple calculation threads can try to acquire this lock at the same time.
// The thread which acquires the lock will set the executing flag and proceed into
// the body of the method.
// If another thread acquires the lock while the first thread is executing it will
// add an item to the queue and return.
// The lock also ensures the state of the executing flag and the queue are visible
// to any thread acquiring the lock.
@lock.@lock();
try
{
if (executing)
{
// Another thread is already invoking the listener. Add the result to
// the queue and return. The other thread will ensure the queued results
// are delivered.
queue.AddLast(result);
return;
}
else
{
// There is no thread invoking the listener. Set the executing flag to
// ensure no other thread passes this point and invoke the listener.
executing = true;
nextResult = result;
}
}
finally
{
@lock.unlock();
}
// The logic in the block above guarantees that there will never be more than one thread in the
// rest of the method below this point.
// Loop until the nextResult and all the results from the queue have been delivered
for (;;)
{
// The logic above means this lock is never contended; the executing flag means
// only one thread will ever be in this loop at any given time.
// This lock is required to ensure any state changes in the listener are visible to all threads
listenerLock.@lock();
try
{
// Invoke the listener while not protected by lock. This allows other threads
// to queue results while this thread is delivering them to the listener.
foreach (CalculationResult cell in nextResult.Cells)
{
listener.resultReceived(nextResult.Target, cell);
}
}
catch (Exception e)
{
log.warn("Exception invoking listener.resultReceived", e);
}
finally
{
listenerLock.unlock();
}
// The following code must be executed whilst holding the lock to guarantee any changes
// to the executing flag and to the state of the queue are visible to all threads
@lock.@lock();
try
{
if (++tasksReceived == tasksExpected)
{
// The expected number of results have been received, inform the listener.
// The listener lock must be acquired to ensure any state changes in the listener are
// visible to all threads
listenerLock.@lock();
try
{
listener.calculationsComplete();
}
catch (Exception e)
{
log.warn("Exception invoking listener.calculationsComplete", e);
}
finally
{
listenerLock.unlock();
}
return;
}
else if (queue.Count == 0)
{
// There are no more results to deliver. Unset the executing flag and return.
// This allows the next calling thread to deliver results.
executing = false;
return;
}
else
{
// There are results on the queue. This means another thread called accept(),
// added a result to the queue and returned while this thread was invoking the listener.
// This thread must deliver the results from the queue.
nextResult = queue.RemoveFirst();
}
}
finally
{
@lock.unlock();
}
}
}
