The Moth

        // declarations

        private Thread mSendNextThread;            // worker thread

        private bool mStayAlive;    // for controlling the thread termination

        private Queue mQue;                        // buffer of jobs

        private ManualResetEvent mWaitEvent;// signal the thread to wake up

        // Initialisation logic

        public void Start(){

            Console.WriteLine("*********");

            Console.WriteLine("Start");

            mQue = new Queue();

            mWaitEvent = new ManualResetEvent(false);

            mStayAlive = true;

            mSendNextThread = new Thread(new ThreadStart(OnMyOwnThread));

            mSendNextThread.Start();

        }

        // Tear down logic

        public void Stop(){

            Console.WriteLine("Stop request");

            lock (mQue.SyncRoot){

                mQue.Clear();

                // kill the thread

                mWaitEvent.Reset();

                Thread.Sleep(10);

                mStayAlive = false;

                mWaitEvent.Set();

                Thread.Sleep(10);

                mSendNextThread = null;

            }

            Console.WriteLine("Stopped");

        }

        // queue more jobs

        public void MoreInput(object someInput){

            Console.WriteLine("More Input: " + someInput.ToString());

            lock (mQue.SyncRoot){

                mQue.Enqueue(someInput);

            }

            mWaitEvent.Set();

        }

        // process jobs

        public void OnMyOwnThread(){

            while (mStayAlive){

                if (mWaitEvent.WaitOne()){

                    mWaitEvent.Reset();

                    while (mQue.Count > 0){    //Whether we do the looping depends

                                            //on the specifics of DoWork

                        if (!mStayAlive){

                            break;

                        }

                        this.DoWork2();

                        mWaitEvent.Reset();

                    }

                }

            }

            Console.WriteLine("Thread exiting");

        }

        private void DoWork2(){

            object queObj = null;

            lock (mQue.SyncRoot){

                if (mQue.Count > 0){

                    queObj = mQue.Dequeue();

                }

            }

            // do some long processing with this job/input

            if (queObj != null){

                Console.WriteLine("Processing: " + queObj.ToString());

                Thread.Sleep(300);//LONG PROCESSING

                Console.WriteLine("Processed " + Environment.TickCount.ToString());

            }

        }

        /// <summary>

        /// This function opens a handle to an existing message queue based on 

        /// a message queue handle.

        /// </summary>

        /// <param name="hSrcProc">[in] Handle to a source process that owns the 

        /// hMsgQ message queue handle. </param>

        /// <param name="hMsgQ">[in] Handle to a message queue returned by the 

        /// CreateMsgQueue function.</param>

        /// <param name="lpOptions">[in] Pointer to an MSGQUEUEOPTIONS structure 

        /// that sets the properties of the message queue.</param>

        /// <returns>Returns a handle to a message queue, or returns NULL if the 

        /// queue could not be opened.</returns>

        [DllImport("coredll.dll", SetLastError=true)]

        public static extern IntPtr OpenMsgQueue(IntPtr hSrcProc, IntPtr hMsgQ,    

            MsgQueueOptions lpOptions);

    Private Function DoWork2() As Boolean

        ' If I don't have a requester then I can't do anything with the input 

        ' so ignore it (and don't obtain the lock!)

        Dim req As ForMyPending = Nothing

        req = Me.FindFreeRequester

        If req Is Nothing Then

            Return False

        End If

        ' Get the next object from the queue

        Dim queObj As ForMyQueue = Nothing

        SyncLock mQue.SyncRoot

            If mQue.Count > 0 Then

                queObj = DirectCast(mQue.Dequeue(), ForMyQueue)

            End If

        End SyncLock

        ' Deal with the next object from the queue without holding the lock!

        If Not queObj Is Nothing Then

            If queObj.ReqArgs.MaxNumResponses <> 0 Then'chance for client to cancel

                req.Deleg = queObj.Deleg

                If req.Requester.Request(queObj.ReqArgs, queObj.State) = False Then

                    If Not req.Deleg Is Nothing Then

                        req.Deleg.Invoke(Me, ReplyArgs.Empty)'failed

                        req.Deleg = Nothing'otherwise it wil never be reused again!

                    End If

                End If

            End If

        End If

        Return True

    End Function