/// <summary> 
 /// Obtains and ignores the next task that the <paramref name="executor"/>
 /// would otherwise execute, if one is immediately available,
 /// and then retries execution of task <paramref name="runnable"/>, unless the <paramref name="executor"/>
 /// is shut down, in which case task <paramref name="runnable"/> is instead discarded.
 /// </summary>
 /// <param name="runnable">the <see cref="Spring.Threading.IRunnable"/> task requested to be executed</param>
 /// <param name="executor">the <see cref="Spring.Threading.Execution.ThreadPoolExecutor"/> attempting to execute this task</param>
 public virtual void RejectedExecution(IRunnable runnable, ThreadPoolExecutor executor)
 {
     if (executor.IsShutdown) return;
     IRunnable head;
     executor.Queue.Poll(out head);
     executor.Execute(runnable);
 }

        /// <summary>
        /// The constructor.
        /// </summary>
        /// <param name="cacheHostInformationPoller">The cache host information poller.</param>
        /// <param name="memCache">The mem cache to use for storing objects.</param>
        /// <param name="clientToCacheServiceHost">The client to cache service host.</param>
        /// <param name="cacheManagerClient">The cache manager client.</param>
        public CacheHostEngine(IRunnable cacheHostInformationPoller, MemCache memCache, ServiceHost clientToCacheServiceHost)
        {
            // Sanitize
            if (cacheHostInformationPoller == null)
            {
                throw new ArgumentNullException("cacheHostInformationPoller");
            }
            if (memCache == null)
            {
                throw new ArgumentNullException("memCache");
            }
            if (clientToCacheServiceHost == null)
            {
                throw new ArgumentNullException("clientToCacheServiceHost");
            }

            // Set the cache host information poller
            _cacheHostInformationPoller = cacheHostInformationPoller;

            // Set the mem cache container instance
            MemCacheContainer.Instance = memCache;

            // Initialize the service hosts
            _clientToCacheServiceHost = clientToCacheServiceHost;
        }

		public Thread NewThread (IRunnable r)
		{
			Thread t = new Thread (r);
			t.SetDaemon (true);
			t.Start ();
			return t;
		}

        /**
         * Builds the task.
         * 
         * @param runnable
         *            The wrapped Runnable object.
         * @throws InvalidPatternException
         *             If the supplied pattern is not valid.
         */
        public RunnableTask(IRunnable runnable)
        {
            if (runnable == null)
                throw new ArgumentNullException("runnable", "runnable is null.");

            this._runnable = runnable;
        }

		public override void Sync(IRunnable runnable)
		{
			lock (_bin)
			{
				base.Sync(runnable);
			}
		}

	public static void postOnAnimation(View view, IRunnable runnable) {
		if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.JellyBean) {
			SDK16.postOnAnimation(view, runnable);
		} else {
			view.PostDelayed(runnable, 16);
		}
	}

 private Object produce(IRunnable runnable, Object result)
 {
     var producers = runnableManager.GetProducers(runnable);
     var converter = producers.FirstOrDefault(c => c.IsConvertable(result));
     if (converter == null) return result;
     return converter.Convert(result);
 }

        // ===========================================================
        // Methods
        // ===========================================================

        public void PostRunnable(/* final */ IRunnable pRunnable)
        {
            lock (_methodLock)
            {
                this.mRunnables.Add(pRunnable);
            }
        }

 public void SetUp()
 {
     _queue = MockRepository.GenerateStub<IBlockingQueue<IRunnable>>();
     _runnable = MockRepository.GenerateMock<IRunnable>();
     _callerRunsPolicy = new ThreadPoolExecutor.CallerRunsPolicy();
     _threadPoolExecutor = new ThreadPoolExecutor(1, 1, TimeSpan.FromSeconds(1), _queue);
 }

 private Object consume(IRunnable runnable, Object parameter)
 {
     var consumers = runnableManager.GetConsumers(runnable);
     var converter = consumers.FirstOrDefault(c => c.IsConvertable(parameter));
     if (converter == null) return ExecuteRunnable(runnable, parameter);
     return converter.Convert(parameter, param => ExecuteRunnable(runnable, param));
 }

 public void SetUp()
 {
     _queue = MockRepository.GenerateStub<IBlockingQueue<IRunnable>>();
     _runnable = MockRepository.GenerateMock<IRunnable>();
     _discardOldestPolicy = new ThreadPoolExecutor.DiscardOldestPolicy();
     _threadPoolExecutor = Mockery.GeneratePartialMock<ThreadPoolExecutor>(1, 1, TimeSpan.FromSeconds(1), _queue);
 }

 public override void Queue(IRunnable runnable)
 {
     using (RWLock.AsReader(_lock))
       {
     SelectQueue(_lock, _queues, runnable).Enqueue(runnable);
       }
 }

 public static void PostOnAnimation(View view, IRunnable runnable)
 {
     if ((int)Android.OS.Build.VERSION.SdkInt >= (int)Android.OS.Build.VERSION_CODES.JellyBean) {
         PostOnAnimationJellyBean(view, runnable);
     } else {
         view.PostDelayed(runnable, SIXTY_FPS_INTERVAL);
     }
 }

 public void Execute(IRunnable command)
 {
     if (!this.IsAcceptingNewTasks)
     {
         throw new RejectedExecutionException();
     }
     this.Unwrap().Execute(command);
 }

 /// <summary> Returns wrapped runnable that ensures that if an exception occurs
 /// during the execution, the specified exception handler is invoked.
 /// </summary>
 /// <param name="runnable">runnable for which exceptions are to be intercepted
 /// </param>
 /// <param name="handler">the exception handler to call when exception occurs
 /// during execution of the given runnable
 /// </param>
 /// <returns> wrapped runnable
 /// </returns>
 /// <exception cref="System.ArgumentNullException">If either parameter is <c>null</c></exception>
 public static IRunnable AssignExceptionHandler(IRunnable runnable, UncaughtExceptionHandlerDelegate handler)
 {
     if ( runnable == null )
         throw new ArgumentNullException("runnable", "Runnable cannot be null");
     if ( handler == null )
         throw new ArgumentNullException("handler", "Handler cannot be null");
     return new AnonymousClassRunnable(runnable, handler);
 }

 public override void Execute(IRunnable command)
 {
     if (command == null)
     {
         throw new NullReferenceException("command");
     }
     this.tasks.Enqueue(command);
 }

        Thread(IRunnable runnable, ThreadGroup grp, string name)
        {
            _thread = new System.Threading.Tasks.Task(InternalRun);

            this._runnable = runnable ?? this;
            _tgroup = grp ?? _defaultGroup;
            _tgroup.Add (this);
        }

        public static void RunRunnable(IRunnable runnable)
        {
            Thread thread = new Thread(runnable.Run);
            thread.IsBackground = true;
            thread.Priority = ThreadPriority.Lowest;

            thread.Start();
        }

        /// <summary>
        /// Role Service Constructor
        /// </summary>
        /// <param name="run">Task Manager</param>
        public TaskService(IRunnable run)
        {
            if (null == run)
            {
                throw new ArgumentNullException("run");
            }

            this.run = run;
        }

 public static Thread ExecuteAfter(string threadName, long timeInMillis, IRunnable
     runnable)
 {
     Thread t = new _Thread_96(timeInMillis, runnable);
     t.SetName(threadName);
     t.SetDaemon(true);
     t.Start();
     return t;
 }