C# Runnable类代码示例

		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;
		}