using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace MutiThreadSample.Transport
{
    /// <summary>
    /// 搬運(yùn)工
    /// </summary>
    public class Mover
    {
        /// <summary>
        /// 總數(shù)
        /// </summary>
        public static int GoodsTotal { get; set; }
        /// <summary>
        /// 間隔時(shí)間
        /// </summary>
        public static int IntervalTime { get; set; }
        /// <summary>
        /// 名稱
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 單位時(shí)間搬運(yùn)量
        /// </summary>
        public int LaborAmount { get; set; }
        /// <summary>
        /// 搬運(yùn)
        /// </summary>
        public void Move()
        {
            while (GoodsTotal > 0)
            {
                GoodsTotal -= LaborAmount;
                Console.WriteLine("搬運(yùn)者：{0} 于 {1} 搬運(yùn)貨物 {2}",this.Name,DateTime.Now.Millisecond,this.LaborAmount);
                Thread.Sleep(IntervalTime);
                Console.WriteLine("搬運(yùn)者：{0} Continue",this.Name);
            }
        }
        /// <summary>
        /// 搬運(yùn)
        /// </summary>
        /// <param name="interval">時(shí)間間隔</param>
        public void Move(object interval)
        {
            int tempInterval = 0;
            if (!int.TryParse(interval.ToString(), out tempInterval))
            {
                tempInterval = IntervalTime;
            }           
            while (GoodsTotal > 0)
            {
                GoodsTotal -= LaborAmount;
                Console.WriteLine("搬運(yùn)者：{0} 于 {1} 搬運(yùn)貨物 {2}", this.Name, DateTime.Now.Millisecond, this.LaborAmount);
                Thread.Sleep(tempInterval);
            }
        }
     }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace MutiThreadSample.Transport
{
    /// <summary>
    /// 測(cè)試搬運(yùn)
    /// </summary>
    public class TestMove
    {
        /// <summary>
        /// 搬運(yùn)
        /// </summary>
        public static void Move()
        {
            //測(cè)試搬運(yùn)工
            Mover.GoodsTotal = 200;
            Mover.IntervalTime = 10;
            Mover m1 = new Mover() { Name = "Tom", LaborAmount = 5 };
            Mover m2 = new Mover() { Name = "Jim", LaborAmount = 10 };
            Mover m3 = new Mover() { Name = "Lucy", LaborAmount = 20 };

            List<Mover> movers = new List<Mover>();
            movers.Add(m1);
            //movers.Add(m2);
            //movers.Add(m3);

            if (movers != null && movers.Count > 0)
            {
                foreach (Mover m in movers)
                {                   
                    Thread thread = new Thread(new ThreadStart(m.Move));
                    thread.Start();
                }
            }

            //Main Thread continue
            // validate Thread.Sleep()
            //int i =0;
            //int j = 0;
            //while (i < 10)
            //{
            //    while(j<10000000)
            //    {
            //        j++;               
            //    }
            //    Console.WriteLine("CurrentThread:{0}", Thread.CurrentThread.Name);
            //    i++;
            //}

        }

        /// <summary>
        /// 搬運(yùn)
        /// </summary>
        public static void MoveWithParamThread()
        {
            //測(cè)試搬運(yùn)工
            Mover.GoodsTotal = 1000;
            Mover.IntervalTime = 100;
            Mover m1 = new Mover() { Name = "Tom", LaborAmount = 5 };
            Mover m2 = new Mover() { Name = "Jim", LaborAmount = 10 };
            Mover m3 = new Mover() { Name = "Lucy", LaborAmount = 20 };

            List<Mover> movers = new List<Mover>();
            movers.Add(m1);
            movers.Add(m2);
            movers.Add(m3);

            if (movers != null && movers.Count > 0)
            {
                foreach (Mover m in movers)
                {
                    Thread thread = new Thread(new ParameterizedThreadStart(m.Move));
                    thread.Start(10);
                }
            }
        }
    }
}

using System;
using System.Threading;

namespace MutiThreadSample
{
    /// <summary>
    /// 創(chuàng)建線程的方式
    /// </summary>
    class CreateThread
    {
        /// <summary>
        /// 不帶參數(shù)的委托
        /// </summary>
        public void CreateThreadWithThreadStart()
        {
            Thread thread = new Thread(new ThreadStart(ThreadCallBack));
            thread.Start();
        }
        /// <summary>
        /// 帶參數(shù)的委托
        /// </summary>
        public void CreateThreadWithParamThreadStart()
        {
            Thread thread = new Thread(new ParameterizedThreadStart(ThreadCallBackWithParam));
            thread.Start();
        }
        /// <summary>
        /// 匿名函數(shù)
        /// </summary>
        public void CreateThreadWithAnonymousFunction()
        {
            Thread thread = new Thread(delegate()
            {
                Console.WriteLine("進(jìn)入子線程1");
                for (int i = 1; i < 4; ++i)
                {
                    Thread.Sleep(50);
                    Console.WriteLine("/t+++++++子線程1+++++++++");
                }
                Console.WriteLine("退出子線程1");
            });
            thread.Start();
        }
        /// <summary>
        /// 直接賦值委托
        /// </summary>
        public void CreateThreadWithCallBack()
        {
            Thread _hThread = new Thread(ThreadCallBack);
            _hThread.Start();

        }
        /// <summary>
        /// 無參數(shù)的方法調(diào)用
        /// </summary>
        public void ThreadCallBack()
        {
            // Do Something
        }
        /// <summary>
        /// 帶參數(shù)的方法
        /// </summary>
        /// <param name="obj"></param>
        public void ThreadCallBackWithParam(object obj)
        {
            // Do Something
        } 
    }
}

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        // Create an event to signal the timeout count threshold in the
        // timer callback.
        AutoResetEvent autoEvent     = new AutoResetEvent(false);

        StatusChecker  statusChecker = new StatusChecker(10);

        // Create an inferred delegate that invokes methods for the timer.
        TimerCallback tcb = statusChecker.CheckStatus;

        // Create a timer that signals the delegate to invoke
        // CheckStatus after one second, and every 1/4 second
        // thereafter.
        Console.WriteLine("{0} Creating timer./n",
            DateTime.Now.ToString("h:mm:ss.fff"));
        Timer stateTimer = new Timer(tcb, autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every
        // 1/2 second.
        autoEvent.WaitOne(5000, false);
        stateTimer.Change(0, 500);
        Console.WriteLine("/nChanging period./n");

        // When autoEvent signals the second time, dispose of
        // the timer.
        autoEvent.WaitOne(5000, false);
        stateTimer.Dispose();
        Console.WriteLine("/nDestroying timer.");
    }
}

class StatusChecker
{
    private int invokeCount;
    private int  maxCount;

    public StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.",
            DateTime.Now.ToString("h:mm:ss.fff"),
            (++invokeCount).ToString());

        if(invokeCount == maxCount)
        {
            // Reset the counter and signal Main.
            invokeCount  = 0;
            autoEvent.Set();
        }
    }
}

using System;
using System.Threading;

namespace MutiThreadSample.ThreadType
{
    class ThreadTypeTest
    {
        /// <summary>
        /// 測(cè)試前臺(tái)線程
        /// </summary>
        public static void Test()
        {
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ThreadStart(ThreadFunc));
                thread.Start();
            }
        }
        /// <summary>
        /// 測(cè)試后臺(tái)線程
        /// </summary>
        public static void TestBackgroundThread()
        {
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ThreadStart(ThreadFunc));
                thread.IsBackground = true;
                thread.Start();
            }
        }
        public static void ThreadFunc()
        {
            Thread.Sleep(0);
            DateTime start = DateTime.Now;
            while ((DateTime.Now - start).Seconds < 20);//可以停頓的時(shí)間長一點(diǎn)，效果更加明顯
        }
    }
}