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

 //================================================================
 //Getter and Setter
 //================================================================
 //================================================================
 //Methodes
 //================================================================
 public void post(Runnable run)
 {
     if (run != null)
     {
         runnables.Add(run);
     }
 }

			public Sharpen.Thread NewThread(Runnable taskBody)
			{
				Sharpen.Thread thr = this.baseFactory.NewThread(taskBody);
				thr.SetName("JGit-AlarmQueue");
				thr.SetDaemon(true);
				return thr;
			}

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

        private schedule(Runnable task, long delay, TimeUnit unit)
        {
            Preconditions.checkState(isOpen.get(), "CloseableExecutorService is closed");

            InternalFutureTask<void> futureTask = new InternalFutureTask<void>(new FutureTask<void>(task, null));
            scheduledExecutorService.schedule(futureTask, delay, unit);
            return futureTask;
        }

 public static Exception tryCatch(Runnable runnable) {
   try {
     runnable.run();
     return null;
   } catch (Exception exception) {
     return exception;
   }
 }

		private void StartPlayingHandler()
		{
			var handler = new Handler();
			var runnable = new Runnable(() => { handler.Post(OnPlaying); });
			if (!_executorService.IsShutdown)
			{
				_scheduledFuture = _executorService.ScheduleAtFixedRate(runnable, 100, 1000, TimeUnit.Milliseconds);
			}
		}

 public ClassRoadie(RunNotifier notifier, TestClass testClass, Description description, Runnable runnable)
 {
   base.\u002Ector();
   ClassRoadie classRoadie = this;
   this.fNotifier = notifier;
   this.fTestClass = testClass;
   this.fDescription = description;
   this.fRunnable = runnable;
 }

 public void RemoveItem(Runnable Item)
 {
     for (int i = Item.ExecutionIndex; i < (Count - 1); i++)
     {
         Items[i] = Items[i + 1];
         Items[i].ExecutionIndex = i;
     }
     Count--;
 }

 public void AddItem(Runnable Item)
 {
     if ((Items.Length - Count) < 10)
         IncreaseItemsSize();
     var index = ++Count - 1;
     Items[index] = Item;
     Items[index].ExecutionIndex = index;
     Compiler.OutItem(Item, this);
 }

 public static void enqueueFrame(Runnable frame)
 {
     lock(frameQueue){
         if (frameQueue.Count > MAX_BUFFER){
             frameQueue.Dequeue();
         }
         frameQueue.Enqueue(frame);
         Debug.Log("largo de la cola de los frames = " + frameQueue.Count);
     }
 }

 public int Execute()
 {
     string[] tokens = configuration.GetItem<Settings>().Runner.Split(',');
     if (tokens.Length > 1) {
         configuration.GetItem<ApplicationUnderTest>().AddAssembly(tokens[1]);
     }
     Runnable = new BasicProcessor().Create(tokens[0]).GetValue<Runnable>();
     ExecuteInApartment();
     return result;
 }

		Thread (Runnable runnable, ThreadGroup grp, string name)
		{
			cancelTokenSource = new CancellationTokenSource ();
			task = new Task (InternalRun, cancelTokenSource.Token, TaskCreationOptions.LongRunning);

			Runnable = runnable ?? this;
			tgroup = grp ?? defaultGroup;
			tgroup.Add (this);
			Name = name ?? "Unknown";
		}

        private scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)
        {
            Preconditions.checkState(isOpen.get(), "CloseableExecutorService is closed");

//JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
//ORIGINAL LINE: java.util.concurrent.ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(task, initialDelay, delay, unit);
            ScheduledFuture < ? >
            scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(task, initialDelay, delay, unit);
            return new InternalScheduledFutureTask(this, scheduledFuture);
        }

		Thread (Runnable runnable, ThreadGroup grp, string name)
		{
			thread = new System.Threading.Thread (new ThreadStart (InternalRun));
			
			this.runnable = runnable ?? this;
			tgroup = grp ?? defaultGroup;
			tgroup.Add (this);
			if (name != null)
				thread.Name = name;
		}

			// An Executor that can be used to execute tasks in parallel.
			// An Executor that executes tasks one at a time in serial order.  This
			// serialization is global to a particular process.
			public virtual void Execute(Runnable r)
			{
				lock (this)
				{
					mTasks.Offer(new _Runnable_58(this, r));
					if (mActive == null)
					{
						ScheduleNext();
					}
				}
			}

        private void PostQueue(Runnable runnable)
        {
            lock (mQueue)
            {
                mQueue.Enqueue(runnable);
            }

            if (!IsNotify)
            {
                IsNotify = true;

                Task task = new Task(Run);
                task.Start();
            }
        }

 /**
  * Submit a runnable task to the executor.
  */
 public void Submit(Runnable task) {
     Logger.Trace("Submit(task={})", task);
     // Synchronise on the queue lock...
     lock(queueLock) {
         // Sanity check before adding the task
         if(!shutdownRequested) {
             // Enqueue the new runnable task
             queue.Enqueue(task);
             // Fire a notification to the synchronisation object to notify any waiters
             Logger.Trace("Notify queue of new task...");
             Monitor.Pulse(queueLock);
             Logger.Trace("...notified queue of new task.");
         }
         else {
             throw new InvalidOperationException("Can not submit a task when the queue has been shut down");
         }
     }
 }

		internal void InternalExecute (Runnable r, bool checkShutdown)
		{
			lock (pendingTasks) {
				if (shutdown && checkShutdown)
					throw new InvalidOperationException ();
				if (runningThreads < corePoolSize) {
					StartPoolThread ();
				}
				else if (freeThreads > 0) {
					freeThreads--;
				}
				else if (runningThreads < maxPoolSize) {
					StartPoolThread ();
				}
				pendingTasks.Enqueue (r);
				ST.Monitor.PulseAll (pendingTasks);
			}
		}

 protected static void CheckException(Runnable callbk, string name, string msg)
 {
     try
     {
       callbk();
       LogMessage(msg + ": CheckException failure: no exception detected");
       Environment.Exit(1);
     }
     catch(Exception e)
     {
       if(!e.GetType().Name.Equals(name))
       {
     LogMessage(msg + ": CheckException failure: wrong exception type");
     LogMessage("Expected: " + name);
     LogMessage("Actual: " + e.GetType().Name);
     Environment.Exit(1);
       }
     }
 }