Managed Bitmaps 2

using System;
using System.Collections.Generic;
using System.Threading;
using Pfz.Caching;

namespace Pfz.Threading
{
	/// <summary>
	/// Class that creates a thread to run Actions as messages. It only creates 
	/// one thread to process all messages. Use it only when you know you want to
	/// process many messages asynchronously, but don't want (or can't) use ThreadPool 
	/// threads.
	/// <typeparam name="T">The type of the actions this executor invokes.</typeparam>
	/// </summary>
	public sealed class ActionRunner<T>:
		ThreadSafeDisposable
	{
		private ManualResetEvent fManualResetEvent = new ManualResetEvent(false);
		private volatile Queue<KeyValuePair<Action<T>, T>> fQueue = new Queue<KeyValuePair<Action<T>, T>>();
		
		/// <summary>
		/// Creates a new action runner.
		/// </summary>
		public ActionRunner()
		{
			try
			{
				GCUtils.Collected += p_Collected;
				UnlimitedThreadPool.Run(p_Run);
			}
			catch
			{
				Dispose();
				throw;
			}
		}
		
		/// <summary>
		/// Frees all used resources.
		/// </summary>
		/// <param name="disposing"></param>
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				fManualResetEvent.Set();
				GCUtils.Collected -= p_Collected;
			}
			
			base.Dispose(disposing);
		}
		private void p_Collected()
		{
			try
			{
				AbortSafe.Lock
				(
					DisposeLock,
					delegate
					{
						if (WasDisposed)
						{
							GCUtils.Collected -= p_Collected;
							return;
						}
						
						fQueue = new Queue<KeyValuePair<Action<T>, T>>(fQueue);
					}
				);
			}
			catch
			{
			}
		}
		
		private void p_Run()
		{
			var thread = Thread.CurrentThread;
			while(true)
			{
				thread.IsBackground = true;
				fManualResetEvent.WaitOne();
				thread.IsBackground = false;

				while(true)
				{
					KeyValuePair<Action<T>, T> pair = new KeyValuePair<Action<T>,T>();
					
					bool mustBreak = false;
					bool mustReturn = false;
					
					AbortSafe.UnabortableLock
					(
						DisposeLock,
						delegate
						{
							if (WasDisposed)
							{
								fManualResetEvent.Close();
								mustReturn = true;
								return;
							}

							var queue = fQueue;
							if (queue.Count == 0)
							{
								fManualResetEvent.Reset();
								mustBreak = true;
								return;
							}
								
							pair = queue.Dequeue();
						}
					);
					
					if (mustReturn)
						return;
					
					if (mustBreak)
						break;
					
					pair.Key(pair.Value);
				}
			}
		}
		
		/// <summary>
		/// Runs the given action.
		/// </summary>
		/// <param name="action">The action to run.</param>
		/// <param name="value">The value for the given action.</param>
		public void Run(Action<T> action, T value)
		{
			if (action == null)
				throw new ArgumentNullException("action");
				
			AbortSafe.UnabortableLock
			(
				DisposeLock,
				delegate
				{
					CheckUndisposed();
					
					var pair = new KeyValuePair<Action<T>, T>(action, value);
					fQueue.Enqueue(pair);
				}
			);
			
			fManualResetEvent.Set();
		}
	}
}