sealed class Runner : MarshalByRefObject

		/*

		{

			ManualResetEvent wait;

		Timer Scheduler

			AutoResetEvent start_event;

		---------------

			TimerCallback callback;

		Author: Rafael Ferreira (raf@ophion.org)

			object state;

			int dueTime;

		The code below implements a single thread scheduler that fires

			int period;

		events using the runtime's built-in thread pool.

			bool disposed;

			bool aborted;

			public Runner (TimerCallback callback, object state, AutoResetEvent start_event)

		Key Features:

			{

			Single thread scheduler:

				this.callback = callback;

				A single thread handles firing all timer jobs thus allowing a 

				this.state = state;

				much greater number of Timers to be defined

				this.start_event = start_event;

			Lazy init:

				this.wait = new ManualResetEvent (false);

				Timer scheduler is only started after the first System.Threading.Timer is created

			}

			Early termination:

				Timer scheduler thread dies if there are no more timer jobs in its Job queue

		In a nutshell the scheduler works like this:

			1 - The main scheduler thread (TimerScheduler) wakes up and finds out what time it is

			2 - The scheduler iterates over the list of timer jobs (Jobs) to find out when the next job is

			as well as fires all timers that were scheduled to run now or in the past

			3 - The Scheduler then calculates the mutiplier for its sleep algorithm. The multiplier

			is basically MSEC_UNTIL_NEXT_JOB / TIME_SLICE where TIME_SLICE is the minimum amount of 

			time the scheduler thread is allowed to sleep for

			4 - Sleep for multiplier * TIME_SLICE

			5 - Goto 1

			public int DueTime {

		Possible improvements:

				get { return dueTime; }

			* Convert the big for-loop into a sorted data structure. This will speed up the time

				set { dueTime = value; }

			it takes the scheduler to iterate over the timer jobs and lower CPU usage under insane 

			amounts of Timers 

		Possible issues:

			* Overflow issues with the multiplier

			* Race conditions with lazy-init of the scheduler thread.

		Note:

			* MONO_TIMER_DEBUG environment variable can be used to turn on the scheduler's debug log

			* MONO_TIMER_USETP environment variable can be used to force the timer scheduler to use 

			the CLI's built in thread pool

			* sync_obj is used to make signaling the scheduler class sane so only one signal is sent at a

			time and a decision can be made on the signal so signals are "batched" or discarded 

		*/

		// timer metadata:

		internal long NextRun;

		internal long LastRun;

		internal long Period;

		internal bool Enabled;

		internal TimerCallback Callback = null;

		internal int ID;

		internal object State = null;

		// flag that turns on "verbose logging"

		static bool debug_enabled = false;

		// flag that tells scheduler to use the cli's thread pool

		static bool use_threadpool = false;

		// mininum sleep time

		const int TIME_SLICE = 10 ; // 5 msec

		// next Timer ID;

		static int next_id = 0;

		// timer scheduler - there can only be one

		static Thread scheduler = null;

		// used to enforce thread safety

		static object sync_obj = new object();

		static Hashtable Jobs =  new Hashtable();

		static bool scheduler_ready = false;

		// this enum is used to signal the scheduler thread of the reason for the Abort() call

		// abort() is used to signal the timer thread since Interrupt() is not implemented

		enum AbortSignals { TimerAdded, TimerRemoved, TimerChanged };

		sealed class Runner: MarshalByRefObject

		{

			Timer timer;

			public Runner(Timer t) {

				this.timer = t;

			public int Period {

		void SetProperties (int dueTime, int period)

				get { return period; }

		{

				set { period = value == 0 ? Timeout.Infinite : value; }

			if (dueTime == Timeout.Infinite) {

				//disables the job

				if (debug_enabled)

					log("disabling timer " + ID);

				Enabled = false;

			}else {

				NextRun = DateTime.Now.Ticks + TimeSpan.TicksPerMillisecond * dueTime;

				Enabled = true;

			bool WaitForDueTime ()

			if (debug_enabled)

			{

				log(String.Format("timer configured, id {2} delay {0} msec period {1} msec", dueTime, period, ID));

				if (dueTime > 0) {

		}

					bool signaled;

		// prorperly handles signaling the scheduler thread

					do {

		// it will retry for 500 msec (.5 sec) if it can't properly signal scheduler

						wait.Reset ();

		// NOT THREAD SAFE

						signaled = wait.WaitOne (dueTime, false);

		void SendSchedulerSignal (AbortSignals signal) 

					} while (signaled == true && !disposed && !aborted);

		{

			for (int i = 0; i < 100; i++) {

					if (!signaled)

				// we don't start a new scheduler if the signal is TimerRemoved

						callback (state);

				if (scheduler == null) {

					log("Scheduler not currently running... new scheduler will be initiated");

					scheduler = new Thread( new ThreadStart(SchedulerThread));

					scheduler.IsBackground = true;

					scheduler.Start();

					return;

				} 

					if (disposed)

				if (scheduler.ThreadState == ThreadState.AbortRequested || scheduler.ThreadState == ThreadState.Aborted) {

						return false;

					return;

				return true;

				if (scheduler_ready) {

			}

					// we batch send Abort() calls

					// Abort is used since Thread.Interrupt is not supported.

					scheduler.Abort(signal);

					return;

				}

				if (debug_enabled)

					log("could not properly signal timer-scheduler, waiting...");

			public void Abort ()

				Thread.Sleep(5); 

			{

				lock (this) {

					aborted = true;

					wait.Set ();

				}

			public void Dispose ()

			throw new Exception("Could not properly abort timer-scheduler thread");

			{

				lock (this) {

					disposed = true;

		}

					Abort ();

				}

			}

			public void Start ()

		public void SchedulerThread () 

			{

		{

				while (!disposed && start_event.WaitOne ()) {

			Thread.CurrentThread.Name = "Timer-Scheduler";

					if (disposed)

			long tick = 0;

						return;

			long next_job = Int64.MaxValue;

			Timer tj = null;

			int multiplier = 1;

			// big scary for-loop that iterates over the jobs

			while(Jobs.Count > 0) {

				if (!scheduler_ready)  {

					scheduler_ready=true;

					aborted = false;

					if (debug_enabled)

						log("Scheduler is ready");

				}

					if (dueTime == Timeout.Infinite)

				try {

						continue;

					tick = DateTime.Now.Ticks;

					if (!WaitForDueTime ())

					// tries to lock the job queue:

						return;

					Monitor.Enter(Jobs);

					if (aborted || (period == Timeout.Infinite))

					foreach (DictionaryEntry entry in Jobs) {

						continue;

						tj = entry.Value as Timer;

					bool signaled = false;

						if (tj.Enabled == false) {

					while (true) {

							continue;

						if (disposed)

						}

							return;

						if ( tj.NextRun <= tick) {

							if (debug_enabled)

								log("Firing job " + tj.ID);

							// Firing job 

							dispatch(tj);

							if (tj.Period == - 1) {

								// it is a run-once job, so we disable it

								tj.Enabled = false;

							}

							else {

								tj.NextRun = tick + tj.Period;

							}

							tj.LastRun = tick;

						if (aborted)

							// we reset the next_job to the max possible value so the real next job

							break;

							// can be figured out

							next_job = Int64.MaxValue;

						try {

							wait.Reset ();

						} catch (ObjectDisposedException) {

							// FIXME: There is some race condition

							//        here when the thread is being

							//        aborted on exit.

							return;

						signaled = wait.WaitOne (period, false);

					// no other jobs are available and all timers

					// are disabled

					if (next_job == Int64.MaxValue) {

						if (debug_enabled)

							log("no active timers found, going into infinite sleep");

						Thread.Sleep(Timeout.Infinite);

					}else {

						multiplier = (int) ((next_job - tick) / TimeSpan.TicksPerMillisecond);

						multiplier = multiplier / TIME_SLICE;

						if (multiplier > 0 ) {

							//TODO there are some edgy race conditions between the abort signal and telling a thread 

							// to sleep

							if (debug_enabled)

								log("gong to sleep for " + multiplier + " times the time slice");

						if (aborted || disposed)

							Thread.Sleep(multiplier * TIME_SLICE);

							break;

						}

					}

				} catch (ThreadAbortException ex) {

					if (ex.ExceptionState is AbortSignals) {

						if (debug_enabled)

							log(String.Format("abort signal received: {0}",ex.ExceptionState));

						if (!signaled) {

						switch((AbortSignals)ex.ExceptionState) {

							callback (state);

							default:

						} else if (!WaitForDueTime ()) {

								Thread.ResetAbort();

							return;

								break;

		Runner runner;

		internal void log (string str)

		AutoResetEvent start_event;

		{

		Thread t;

			if (debug_enabled)

				Console.Error.WriteLine(String.Format("{0}.{1} TIMER SCHEDULER: {2}",DateTime.Now,DateTime.Now.Millisecond,str));

		}

			start_event = new AutoResetEvent (false);

			if (!debug_enabled) {

			runner = new Runner (callback, state, start_event);

				if(Environment.GetEnvironmentVariable("MONO_TIMER_DEBUG") != null)

			Change (dueTime, period);

					debug_enabled = true;

			t = new Thread (new ThreadStart (runner.Start));

			}

			t.IsBackground = true;

			t.Start ();

			if (!use_threadpool) {

				if(Environment.GetEnvironmentVariable("MONO_TIMER_USETP") != null) {

					if(debug_enabled)

						log("timer will dispatch using the thread pool");

					use_threadpool = true;

				}

			}			

			ID = Interlocked.Increment(ref next_id);

			// first run take into consideration the delay metric only

			SetProperties(dueTime,period);

			Callback = callback;

			State = state;

			// lock job Q

			lock(Jobs) {

				Jobs.Add(ID,this);

			}

			lock(sync_obj) {

				SendSchedulerSignal(AbortSignals.TimerAdded);

			}

			if (runner == null)

			// modifying the job is actually quicker (lock wise) than doing a Remove / Add combo

				return false;

			lock (Jobs) {

				if (!Jobs.Contains(ID)) {

					return(false);

				}

				SetProperties(dueTime,period);

				if (debug_enabled)

					log("job " + ID +" changed");

			start_event.Reset ();

			}

			runner.Abort ();

			lock (sync_obj) {

			runner.DueTime = dueTime;

				SendSchedulerSignal(AbortSignals.TimerChanged);

			runner.Period = period;

			}

			start_event.Set ();

			if (t != null && t.IsAlive) {

			lock (Jobs) {

				if (t != Thread.CurrentThread)

				if (Jobs.Contains(ID)) { 

					t.Abort ();

					Jobs.Remove(ID);

				t = null;

				}

			if (runner != null) {

			lock (sync_obj) {

				runner.Dispose ();

				SendSchedulerSignal(AbortSignals.TimerRemoved);

				runner = null;

	public class TimerTest : Assertion {

	[TestFixture]

	public class TimerTest {

		// this bucket is used to avoid non-theadlocal issues

		class Bucket {

			public int count;

		}

		[SetUp]

		public void setup() {

			//creating a timer that will never run just to make sure the

			// scheduler is warm for the unit tests

			// this makes fair for the "DueTime" test since it 

			// doesn't have to wait for the scheduler thread to be 

			// created. 

			new Timer(null,null,Timeout.Infinite,0);

		}

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), null, 200, Timeout.Infinite);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 200, Timeout.Infinite);

			AssertEquals ("t0", 0, counter);

			Assert.AreEqual (0, bucket.count);

			AssertEquals ("t1", 1, counter);

			Assert.AreEqual (1, bucket.count);

			AssertEquals ("t2", 1, counter);

			Assert.AreEqual (1, bucket.count);

			Thread.Sleep (500);

			Thread.Sleep (1000);

			Assert ("t3", counter > 20);

			Assert.IsTrue(bucket.count > 20);

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), null, 1, 1);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 1, 1);

			int c = counter;

			int c = bucket.count;

			Assert ("t1", c > 20);

			Assert.IsTrue(c > 20);

			Assert ("t2", counter <= c + 6);

			Assert.IsTrue(bucket.count <= c + 6);

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), null, 0, Timeout.Infinite);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 0, Timeout.Infinite);

			AssertEquals (1, counter);

			Assert.AreEqual (1, bucket.count);

			AssertEquals (2, counter);

			Assert.AreEqual (2, bucket.count);

		{

		{	

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (CallbackTestDispose), null, 10, 10);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 10, 10);

			int c = counter;

			int c = bucket.count;

			Assert (counter > 5);

			Assert.IsTrue(bucket.count > 5);

			AssertEquals (c, counter);

			Assert.AreEqual (c, bucket.count);

			Timer t = new Timer (new TimerCallback (CallbackTestDispose), null, 10, 10);

			Timer t = new Timer (new TimerCallback (Callback), null, 10, 10);

		[Category ("NotWorking")]

		public void TestHeavyCreationLoad() {

			int i = 0;

			Bucket b = new Bucket();

			while (i < 500) {

				new Timer(new TimerCallback(Callback),b,10,Timeout.Infinite);

				i++;

			}

			// 1000 * 10 msec = 10,000 msec or 10 sec - if everything goes well

			Thread.Sleep(12*500);

			Assert.AreEqual(500,b.count);

		}

		[Test]

		public void TestQuickDisposeDeadlockBug() {

			int i = 0;

			Bucket b = new Bucket();

			ArrayList timers = new ArrayList();

			while (i < 500) {

				Timer t = new Timer(new TimerCallback(Callback),b,10,Timeout.Infinite);

				timers.Add(t);

				i++;

				t.Dispose();

			}

			Thread.Sleep(11*500);

		}

		[Test]

		public void TestInt32MaxDelay() {

			Bucket b = new Bucket();

			new Timer(new TimerCallback(Callback),b,Int32.MaxValue,Timeout.Infinite);

			Thread.Sleep(50);

			Assert.AreEqual(0,b.count);

		}

		[Test]

		public void TestInt32MaxPeriod() {

			Bucket b = new Bucket();

			new Timer(new TimerCallback(Callback),b,0,Int32.MaxValue);

			Thread.Sleep(50);

			Assert.AreEqual(1,b.count);

		}

		[Test]

		public void TestNegativeDelay() {

			Bucket b = new Bucket();

			try {

				new Timer(new TimerCallback(Callback),b,-10,Timeout.Infinite);

			} catch (ArgumentOutOfRangeException) {

				return;

			}

			Assert.Fail();

		}

		[Test]

		public void TestNegativePeriod() {

			Bucket b = new Bucket();

			try {

				new Timer(new TimerCallback(Callback),b,0,-10);

			} catch (ArgumentOutOfRangeException) {

				return;

			}

			Assert.Fail();

		}

		[Test]

		public void TestDelayZeroPeriodZero() {

			Bucket b = new Bucket();

			new Timer(new TimerCallback(Callback),b,0,0);

			Thread.Sleep(50);

			Assert.IsTrue(b.count > 45);

		}

		[Category("NotWorking")]

			counter = 0;

			t1 = new Timer (new TimerCallback (CallbackTestDisposeOnCallback), null, 0, 10);

			Timer t1 = null;

			t1 = new Timer (new TimerCallback (CallbackTestDisposeOnCallback), t1, 0, 10);

			AssertNull (t1);

			Assert.IsNull(t1);

			if (++counter == 3) {

			((Timer)foo).Dispose();

				t1.Dispose ();

				t1 = null;

			}

		private void CallbackTestDispose (object foo)

		{

			counter++;

		}

			counter++;

			Bucket b = foo as Bucket;

			b.count++;