C#多線程編程

C#多線程編程

 

1、使用線程的理由

一、可使用線程將代碼同其餘代碼隔離，提升應用程序的可靠性。

二、可使用線程來簡化編碼。

三、可使用線程來實現併發執行。

2、基本知識

一、進程與線程：進程做爲操做系統執行程序的基本單位，擁有應用程序的資源，進程包含線程，進程的資源被線程共享，線程不擁有資源。

二、前臺線程和後臺線程：經過Thread類新建線程默認爲前臺線程。當全部前臺線程關閉時，全部的後臺線程也會被直接終止，不會拋出異常。

三、掛起（Suspend）和喚醒（Resume）：因爲線程的執行順序和程序的執行狀況不可預知，因此使用掛起和喚醒容易發生死鎖的狀況，在實際應用中應該儘可能少用。

四、阻塞線程：Join，阻塞調用線程，直到該線程終止。

五、終止線程：Abort：拋出 ThreadAbortException 異常讓線程終止，終止後的線程不可喚醒。Interrupt：拋出 ThreadInterruptException 異常讓線程終止，經過捕獲異常能夠繼續執行。

六、線程優先級：AboveNormal BelowNormal Highest Lowest Normal，默認爲Normal。

3、線程的使用

線程函數經過委託傳遞，能夠不帶參數，也能夠帶參數（只能有一個參數），能夠用一個類或結構體封裝參數。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(new ThreadStart(TestMethod));
            Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));
            t1.IsBackground = true;
            t2.IsBackground = true;
            t1.Start();
            t2.Start("hello");
            Console.ReadKey();
        }

        public static void TestMethod()
        {
            Console.WriteLine("不帶參數的線程函數");
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine("帶參數的線程函數，參數爲：{0}", datastr);
        }
    } 
}

4、線程池

因爲線程的建立和銷燬須要耗費必定的開銷，過多的使用線程會形成內存資源的浪費，出於對性能的考慮，因而引入了線程池的概念。線程池維護一個請求隊列，線程池的代碼從隊列提取任務，而後委派給線程池的一個線程執行，線程執行完不會被當即銷燬，這樣既能夠在後臺執行任務，又能夠減小線程建立和銷燬所帶來的開銷。

線程池線程默認爲後臺線程（IsBackground）。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //將工做項加入到線程池隊列中，這裏能夠傳遞一個線程參數
            ThreadPool.QueueUserWorkItem(TestMethod, "Hello");
            Console.ReadKey();
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine(datastr);
        }
    }
}

5、Task類

使用ThreadPool的QueueUserWorkItem()方法發起一次異步的線程執行很簡單，可是該方法最大的問題是沒有一個內建的機制讓你知道操做何時完成，有沒有一個內建的機制在操做完成後得到一個返回值。爲此，可使用System.Threading.Tasks中的Task類。

構造一個Task<TResult>對象，併爲泛型TResult參數傳遞一個操做的返回類型。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            t.Wait();
            Console.WriteLine(t.Result);
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //結果太大，拋出異常
            return sum;
        }
    }
}

一個任務完成時，自動啓動一個新任務。
一個任務完成後，它能夠啓動另外一個任務，下面重寫了前面的代碼，不阻塞任何線程。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            //t.Wait();
            Task cwt = t.ContinueWith(task => Console.WriteLine("The result is {0}",t.Result));
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //結果溢出，拋出異常
            return sum;
        }
    }
}

6、委託異步執行

委託的異步調用：BeginInvoke() 和 EndInvoke()

namespace Test
{
    public delegate string MyDelegate(object data);
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate mydelegate = new MyDelegate(TestMethod);
            IAsyncResult result = mydelegate.BeginInvoke("Thread Param", TestCallback, "Callback Param");

            //異步執行完成
            string resultstr = mydelegate.EndInvoke(result);
        }

        //線程函數
        public static string TestMethod(object data)
        {
            string datastr = data as string;
            return datastr;
        }

        //異步回調函數
        public static void TestCallback(IAsyncResult data)
        {
            Console.WriteLine(data.AsyncState);
        }
    }
}

7、線程同步

　　1）原子操做（Interlocked）：全部方法都是執行一次原子讀取或一次寫入操做。

　　2）lock()語句：避免鎖定public類型，不然實例將超出代碼控制的範圍，定義private對象來鎖定。

　　3）Monitor實現線程同步

　　　　經過Monitor.Enter() 和 Monitor.Exit()實現排它鎖的獲取和釋放，獲取以後獨佔資源，不容許其餘線程訪問。

　　　　還有一個TryEnter方法，請求不到資源時不會阻塞等待，能夠設置超時時間，獲取不到直接返回false。

　　4）ReaderWriterLock

　　　　當對資源操做讀多寫少的時候，爲了提升資源的利用率，讓讀操做鎖爲共享鎖，多個線程能夠併發讀取資源，而寫操做爲獨佔鎖，只容許一個線程操做。

　　5）事件（Event）類實現同步

　　　　事件類有兩種狀態，終止狀態和非終止狀態，終止狀態時調用WaitOne能夠請求成功，經過Set將時間狀態設置爲終止狀態。

　　　　1）AutoResetEvent（自動重置事件）

　　　　2）ManualResetEvent（手動重置事件）

　　6）信號量（Semaphore）

　　　　　　信號量是由內核對象維護的int變量，爲0時，線程阻塞，大於0時解除阻塞，當一個信號量上的等待線程解除阻塞後，信號量計數+1。

　　　　　　線程經過WaitOne將信號量減1，經過Release將信號量加1，使用很簡單。

　　7）互斥體（Mutex）

　　　　　　獨佔資源，用法與Semaphore類似。

 　 8）跨進程間的同步

　　　　　　經過設置同步對象的名稱就能夠實現系統級的同步，不一樣應用程序經過同步對象的名稱識別不一樣同步對象。