[Test] public void AwaitAfterMultipleReentrantLockingPreservesLockCount([Values(true, false)] bool isFair)
{
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
ThreadManager.StartAndAssertRegistered(
"T",
delegate
{
using (_lock.Lock())
{
Assert.That(_lock.HoldCount, Is.EqualTo(1));
c.Await();
Assert.That(_lock.HoldCount, Is.EqualTo(1));
}
},
delegate
{
using (_lock.Lock())
using (_lock.Lock())
{
Assert.That(_lock.HoldCount, Is.EqualTo(2));
c.Await();
Assert.That(_lock.HoldCount, Is.EqualTo(2));
}
});
Thread.Sleep(Delays.Short);
Assert.IsFalse(_lock.IsLocked);
using (_lock.Lock()) c.SignalAll();
ThreadManager.JoinAndVerify();
}
/// <summary>
/// Retrieves and removes the head of this queue, waiting if necessary
/// until an element becomes available.
/// </summary>
/// <returns> the head of this queue</returns>
public override T Take()
{
ReentrantLock rl = _lock;
rl.LockInterruptibly();
try {
try {
while (_innerQueue.Count == 0)
{
notEmpty.Await();
}
}
catch (ThreadInterruptedException) {
notEmpty.Signal(); // propagate to non-interrupted thread
throw;
}
T element;
if (!_innerQueue.Poll(out element))
{
throw new InvalidOperationException("Poll returns unexpected false");
}
return(element);
}
finally {
rl.Unlock();
}
}
public void GetWaitQueueLengthReturnsNumberOfThreads(bool isFair)
{
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
ThreadManager.StartAndAssertRegistered(
"T1",
delegate
{
using (_lock.Lock())
{
Assert.IsFalse(_lock.HasWaiters(c));
Assert.AreEqual(0, _lock.GetWaitQueueLength(c));
c.Await();
}
});
Thread.Sleep(Delays.Short);
ThreadManager.StartAndAssertRegistered(
"T2",
delegate
{
using (_lock.Lock())
{
Assert.IsTrue(_lock.HasWaiters(c));
Assert.AreEqual(1, _lock.GetWaitQueueLength(c));
c.Await();
}
});
try
{
Thread.Sleep(Delays.Short);
_lock.Lock();
Assert.IsTrue(_lock.HasWaiters(c));
Assert.AreEqual(2, _lock.GetWaitQueueLength(c));
c.SignalAll();
_lock.Unlock();
Thread.Sleep(Delays.Short);
_lock.Lock();
Assert.IsFalse(_lock.HasWaiters(c));
Assert.AreEqual(0, _lock.GetWaitQueueLength(c));
_lock.Unlock();
}
finally
{
ThreadManager.JoinAndVerify();
}
}
[Test] public void HasWaitersReturnTrueWhenThreadIsWaitingElseFalse([Values(true, false)] bool isFair)
{
_lock = new ReentrantLock(true);
ICondition c = _lock.NewCondition();
ThreadManager.StartAndAssertRegistered(
"T1",
delegate
{
using (_lock.Lock())
{
Assert.IsFalse(_lock.HasWaiters(c));
Assert.That(_lock.GetWaitQueueLength(c), Is.EqualTo(0));
c.Await();
}
});
Thread.Sleep(Delays.Short);
_lock.Lock();
Assert.IsTrue(_lock.HasWaiters(c));
Assert.AreEqual(1, _lock.GetWaitQueueLength(c));
c.Signal();
_lock.Unlock();
Thread.Sleep(Delays.Short);
_lock.Lock();
Assert.IsFalse(_lock.HasWaiters(c));
Assert.AreEqual(0, _lock.GetWaitQueueLength(c));
_lock.Unlock();
ThreadManager.JoinAndVerify();
}
public void AwaitChokesWhenLockIsNotOwned([Values(true, false)] bool isFair)
{
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
c.Await();
}
public void GetWaitingThreadsIncludesWaitingThreads(bool isFair)
{
PublicReentrantLock myLock = new PublicReentrantLock(isFair);
ICondition c = myLock.NewCondition();
myLock.Lock();
Assert.That(myLock.GetWaitingThreadsPublic(c).Count, Is.EqualTo(0));
myLock.Unlock();
Thread t1 = ThreadManager.StartAndAssertRegistered(
"T1",
delegate
{
myLock.Lock();
Assert.That(myLock.GetWaitingThreadsPublic(c).Count, Is.EqualTo(0));
c.Await();
myLock.Unlock();
});
Thread.Sleep(Delays.Short);
Thread t2 = ThreadManager.StartAndAssertRegistered(
"T2",
delegate
{
myLock.Lock();
Assert.That(myLock.GetWaitingThreadsPublic(c).Count, Is.Not.EqualTo(0));
c.Await();
myLock.Unlock();
});
Thread.Sleep(Delays.Short);
myLock.Lock();
Assert.IsTrue(myLock.HasWaiters(c));
Assert.IsTrue(myLock.GetWaitingThreadsPublic(c).Contains(t1));
Assert.IsTrue(myLock.GetWaitingThreadsPublic(c).Contains(t2));
c.SignalAll();
myLock.Unlock();
Thread.Sleep(Delays.Short);
myLock.Lock();
Assert.IsFalse(myLock.HasWaiters(c));
Assert.IsTrue((myLock.GetWaitingThreadsPublic(c).Count == 0));
myLock.Unlock();
ThreadManager.JoinAndVerify();
}
public void AwaitNanos_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
Assert.IsFalse(c.Await(new TimeSpan(1)));
myLock.WriterLock.Unlock();
}
public ZKRebalancerListener(
ZookeeperConsumerConnector parent,
string group,
string consumerIdString,
IDictionary <string, IList <KafkaStream <TKey, TValue> > > kafkaMessageAndMetadataStreams)
{
this.parent = parent;
this.group = group;
this.consumerIdString = consumerIdString;
this.KafkaMessageAndMetadataStreams = kafkaMessageAndMetadataStreams;
this.@lock = new ReentrantLock();
this.cond = [email protected]();
this.watcherExecutorThread = new Thread(() =>
{
Logger.InfoFormat("starting watcher executor thread for consumer {0}", consumerIdString);
bool doRebalance;
while (!parent.isShuttingDown.Get())
{
try
{
[email protected]();
try
{
if (!isWatcherTriggered)
{
cond.Await(TimeSpan.FromMilliseconds(1000)); // wake up periodically so that it can check the shutdown flag
}
}
finally
{
doRebalance = isWatcherTriggered;
isWatcherTriggered = false;
@lock.Unlock();
}
if (doRebalance)
{
this.SyncedRebalance();
}
}
catch (Exception e)
{
Logger.Error("Error during syncedRebalance", e);
}
}
Logger.InfoFormat("Stoppping watcher executer thread for consumer {0}", consumerIdString);
});
this.watcherExecutorThread.Name = consumerIdString + "_watcher_executor";
this.watcherExecutorThread.Start();
}
public void Run()
{
try
{
myLock.WriterLock.Lock();
c.Await();
myLock.WriterLock.Unlock();
}
catch (ThreadInterruptedException)
{
Assert.Fail("Should not throw an exception.");
}
}
public void Run()
{
try
{
myLock.WriterLock.Lock();
c.Await(Delays.Medium);
myLock.WriterLock.Unlock();
Assert.Fail("Should throw an exception");
}
catch (ThreadInterruptedException)
{
}
}
[Test] public void SignalAllWakesUpAllThreads([Values(true, false)] bool isFair)
{
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
ThreadStart cAwait = delegate { using (_lock.Lock()) c.Await(); };
ThreadManager.StartAndAssertRegistered("T", cAwait, cAwait);
Thread.Sleep(Delays.Short);
_lock.Lock();
c.SignalAll();
_lock.Unlock();
ThreadManager.JoinAndVerify();
}
[Test] public void AwaitNanosIsInterruptible([Values(true, false)] bool isFair)
{
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
Thread t = ThreadManager.StartAndAssertRegistered(
"T1",
() => Assert.Throws <ThreadInterruptedException>(
() => { using (_lock.Lock()) c.Await(new TimeSpan(0, 0, 0, 1)); }));
Thread.Sleep(Delays.Short);
t.Interrupt();
ThreadManager.JoinAndVerify();
}
[Test] public void AwaitReturnsWhenSignalled([Values(true, false)] bool isFair)
{
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
ThreadManager.StartAndAssertRegistered(
"T1",
() => { using (_lock.Lock()) c.Await(); });
Thread.Sleep(Delays.Short);
_lock.Lock();
c.Signal();
_lock.Unlock();
ThreadManager.JoinAndVerify();
}
/// <summary>
/// This method will remove and return the item in the front of the queue if one exists, or
/// it will block the current thread until there is an item to dequeue.
/// </summary>
/// <returns>
/// The <c>T</c> item in the front of the queue.
/// </returns>
public T Dequeue()
{
_lock.Lock();
try {
while (_queue.Count == 0)
{
_notEmpty.Await();
}
return(_queue.Dequeue());
}
finally {
_lock.Unlock();
}
}
/// <summary>
/// <inheritDoc/>
///
/// </summary>
public override void Run()
{
try
{
while (doRun)
{
// Wait for a request
IBiConsumer <StanfordCoreNLPClient.Backend, IConsumer <StanfordCoreNLPClient.Backend> > request;
StanfordCoreNLPClient.Backend annotator;
stateLock.Lock();
try
{
while (queue.IsEmpty())
{
enqueued.Await();
if (!doRun)
{
return;
}
}
// Get the actual request
request = queue.Poll();
// We have a request
// Find a free annotator
while (freeAnnotators.IsEmpty())
{
newlyFree.Await();
}
annotator = freeAnnotators.Poll();
}
finally
{
stateLock.Unlock();
}
// We have an annotator
// Run the annotation
request.Accept(annotator, null);
}
}
catch (Exception e)
{
// ASYNC: we've freed this annotator
// add it back to the queue and register it as available
// If the queue is empty, and all the annotators have returned, we're done
// Annotator is running (in parallel, most likely)
throw new Exception(e);
}
}
public void Await_IllegalMonitor()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
try
{
c.Await();
Assert.Fail("Should throw an exception.");
}
catch (SynchronizationLockException)
{
}
}
/// <summary>
/// This method adds an item to the queue.
/// </summary>
/// <param name="item">
/// The item to push into the queue.
/// </param>
public void Enqueue(T item)
{
_lock.Lock();
try {
while (_buffer.Count == _capacity)
{
_notFull.Await();
}
_buffer.Enqueue(item);
_notEmpty.Signal();
}
finally {
_lock.Unlock();
}
}
/// <summary>
/// This method will remove and return the item in the front of the queue if one exists, or
/// it will block the current thread until there is an item to dequeue.
/// </summary>
/// <returns>
/// The <c>T</c> item in the front of the queue.
/// </returns>
public T Dequeue()
{
_lock.Lock();
try {
while (_buffer.Count == 0)
{
_notEmpty.Await();
}
T result = _buffer.Dequeue();
_notFull.Signal();
return(result);
}
finally {
_lock.Unlock();
}
}
[Test] public void AwaitTimeoutWithoutSignal([Values(true, false)] bool isFair)
{
TimeSpan timeToWait = Delays.Short;
_lock = new ReentrantLock(isFair);
ICondition c = _lock.NewCondition();
_lock.Lock();
Stopwatch sw = new Stopwatch();
sw.Start();
bool result = c.Await(timeToWait);
sw.Stop();
Assert.IsFalse(result);
Assert.That(sw.Elapsed + TimeSpan.FromMilliseconds(0.5), Is.Not.LessThan(timeToWait));
_lock.Unlock();
}
/// <summary>
/// <inheritDoc/>
/// This method creates an async call to the server, and blocks until the server
/// has finished annotating the object.
/// </summary>
public override void Annotate(Annotation annotation)
{
ILock Lock = new ReentrantLock();
ICondition annotationDone = Lock.NewCondition();
Annotate(Java.Util.Collections.Singleton(annotation), 1, null);
try
{
Lock.Lock();
annotationDone.Await();
}
catch (Exception)
{
// Only wait for one callback to complete; only annotating one document
log.Info("Interrupt while waiting for annotation to return");
}
finally
{
Lock.Unlock();
}
}
public void ExtWait(ExtMutex mutex)
{
m_cond.Await();
}