Beispiel #1
0
 /// <summary>
 /// Try to de-queue from the Channel with a timeout period.
 /// </summary>
 /// <returns>
 /// Returns Boolean, representing whether or not data was de-queued from the Channel.
 /// </returns>
 /// <param name="milliseconds">
 /// Specifies the timeout period for de-queueing.
 /// </param>
 /// <param name="result">
 /// Data that was de-queued from the Channel.
 /// </param>
 /// <exception cref="System.Threading.ThreadInterruptedException">
 /// Thrown when de-queueing is interrupted.
 /// </exception>
 public virtual bool TryDequeue(int milliseconds, out T result)
 {
     // Catch cases which mean infinite timeout period
     if (milliseconds < -1)
     {
         milliseconds = -1;
     }
     // Can de-queue happen
     if (_access.TryAcquire(milliseconds))
     {
         try
         {
             result = _queue.Dequeue();
             return(true);
         }
         catch (ThreadInterruptedException)
         {
             // Catch the exception if it is thrown and force release then throw
             _access.ForceRelease();
             throw;
         }
     }
     // Otherwise, assign the out variable the value of the default type, T, and return false
     else
     {
         result = default(T);
         return(false);
     }
 }
        /// <summary>
        /// Try to en-queue to the BoundedChannel with a timeout period.
        /// </summary>
        /// <returns>
        /// Returns Boolean, representing whether or not data was en-queued to the BoundedChannel.
        /// </returns>
        /// <param name="data">
        /// Specifies the data to be en-queued to the BoundedChannel.
        /// </param>
        /// <param name="milliseconds">
        /// Specifies the timeout period for en-queueing.
        /// </param>
        /// <exception cref="System.Threading.ThreadInterruptedException">
        /// Thrown when en-queueing is interrupted.
        /// </exception>
        public bool TryEnqueue(T data, int milliseconds)
        {
            // Catch cases which mean infinite timeout period
            if (milliseconds < -1)
            {
                milliseconds = -1;
            }

            // If a token has successfully been acquired from the BoundedChannel's boundary Semaphore, en-queue the data with base.Enqueue and assign bool true
            if (_upperBoundary.TryAcquire(milliseconds))
            {
                try
                {
                    // An interrupt may occure here
                    base.Enqueue(data);
                }
                catch (ThreadInterruptedException)
                {
                    // Catch the interrupt, force release into the boundary and throw the caught exception
                    _upperBoundary.ForceRelease();
                    throw;
                }
                return(true);
            }
            return(false);
        }
    private static void SemaphoreTestAcquire()
    {
        switch (new Random().Next(2))
        {
        case 0:
        {
            int maxWaitTime = new Random().Next(4000);
            Console.WriteLine(Thread.CurrentThread.Name + ": I'm going to wait " + maxWaitTime + " milliseconds to acquire.");
            try
            {
                if (_testSemaphore.TryAcquire(maxWaitTime))
                {
                    Console.WriteLine("\n\t" + Thread.CurrentThread.Name + ": I managed to acquire!\n");
                }
                else
                {
                    Console.WriteLine("\t" + Thread.CurrentThread.Name + ": I've waited long enough.");
                    Console.WriteLine("\t" + "\t" + Thread.CurrentThread.Name + ": Now let's get back to acquiring.");
                }
            }
            catch (ThreadInterruptedException)
            {
                Console.WriteLine("\n\t" + Thread.CurrentThread.Name + ": I was interrupted!\n");
            }
            break;
        }

        case 1:
        {
            Console.WriteLine(Thread.CurrentThread.Name + ": I'm going to wait infinitely to acquire.");
            _requiresInterrupt = true;
            try
            {
                if (_testSemaphore.TryAcquire(-1))
                {
                    Console.WriteLine("\n\t" + Thread.CurrentThread.Name + ": I managed to acquire!\n");
                }
            }
            catch (ThreadInterruptedException)
            {
                Console.WriteLine("\n\t" + Thread.CurrentThread.Name + ": I was interrupted!\n");
            }
            break;
        }
        }
    }
Beispiel #4
0
    private static void SemaphoreTestAcquire()
    {
        int maxWaitTime = new Random().Next(4000);

        Console.WriteLine(Thread.CurrentThread.Name + ": I'm going to wait " + maxWaitTime + " milliseconds to acquire.");

        if (_testSemaphore.TryAcquire(maxWaitTime))
        {
            Console.WriteLine("\n\t" + Thread.CurrentThread.Name + ": I managed to acquire!\n");
        }
        else
        {
            Console.WriteLine("\t" + Thread.CurrentThread.Name + ": I've waited long enough and should be interrupted.");
            Console.WriteLine("\t" + "\t" + Thread.CurrentThread.Name + ": Now let's get back to acquiring.");
        }
    }