/// <exception cref="System.Exception"/>
public virtual E Take()
{
int startIdx = this.multiplexer.GetAndAdvanceCurrentIndex();
takeLock.LockInterruptibly();
try
{
// Wait while queue is empty
for (; ;)
{
BlockingQueue <E> q = this.GetFirstNonEmptyQueue(startIdx);
if (q != null)
{
// Got queue, so return if we can poll out an object
E e = q.Poll();
if (e != null)
{
return(e);
}
}
notEmpty.Await();
}
}
finally
{
takeLock.Unlock();
}
}
/// <summary>
/// Retrieves and removes the head of this queue, waiting up to the
/// specified wait time if necessary for an element to become available.
/// </summary>
/// <param name="element">
/// Set to the head of this queue. <c>default(T)</c> if queue is empty.
/// </param>
/// <param name="duration">How long to wait before giving up.</param>
/// <returns>
/// <c>false</c> if the queue is still empty after waited for the time
/// specified by the <paramref name="duration"/>. Otherwise <c>true</c>.
/// </returns>
public override bool Poll(TimeSpan duration, out T element)
{
ReentrantLock currentLock = _lock;
currentLock.LockInterruptibly();
try
{
TimeSpan durationToWait = duration;
DateTime deadline = DateTime.Now.Add(durationToWait);
while (!_wrapped.Poll(out element))
{
if (durationToWait.Ticks <= 0)
{
element = default(T);
return(false);
}
try
{
_notEmptyCondition.Await(durationToWait);
durationToWait = deadline.Subtract(DateTime.Now);
}
catch (ThreadInterruptedException)
{
_notEmptyCondition.Signal();
throw;
}
}
_notFullCondition.Signal();
return(true);
}
finally
{
currentLock.Unlock();
}
}
/// <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 currentLock = _lock;
currentLock.LockInterruptibly();
try
{
try
{
T element;
while (!_wrapped.Poll(out element))
{
_notEmptyCondition.Await();
}
_notFullCondition.Signal();
return(element);
}
catch (ThreadInterruptedException)
{
_notEmptyCondition.Signal();
throw;
}
}
finally
{
currentLock.Unlock();
}
}
/// <summary>
/// Inserts the specified element into this queue, waiting if necessary
/// for space to become available.
/// </summary>
/// <param name="element">the element to add</param>
/// <exception cref="System.ArgumentNullException">
/// If the specified element is <see langword="null"/> and this queue
/// does not permit <see langword="null"/> elements.
/// </exception>
/// <exception cref="System.ArgumentException">
/// If some property of the supplied <paramref name="element"/> prevents
/// it from being added to this queue.
/// </exception>
public override void Put(T element)
{
ReentrantLock currentLock = _lock;
currentLock.LockInterruptibly();
try
{
try
{
while (!_wrapped.Offer(element))
{
_notFullCondition.Await();
}
_notEmptyCondition.Signal();
}
catch (ThreadInterruptedException)
{
_notFullCondition.Signal();
throw;
}
}
finally
{
currentLock.Unlock();
}
}
/// <summary>
/// Retrieves and removes the head of this queue, waiting up to the
/// specified wait time if necessary for an element to become available.
/// </summary>
/// <param name="timeout">how long to wait before giving up</param>
/// <param name="element"></param>
/// <returns>
/// the head of this queue, or <see lang="default(T)"/> if the
/// specified waiting time elapses before an element is available.
/// </returns>
public override bool Poll(TimeSpan timeout, out T element)
{
ReentrantLock rl = _lock;
rl.LockInterruptibly();
try {
DateTime deadline = DateTime.Now + timeout;
for (; ;)
{
if (_innerQueue.Poll(out element))
{
return(true);
}
if (timeout.TotalMilliseconds <= 0)
{
return(false);
}
try {
notEmpty.Await(timeout);
timeout = deadline - DateTime.Now;
}
catch (ThreadInterruptedException) {
notEmpty.Signal(); // propagate to non-interrupted thread
throw;
}
}
}
finally {
rl.Unlock();
}
}
/// <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();
}
}