2. 程式人生 > >C#多線程和異步——Task和async/await詳解

C#多線程和異步——Task和async/await詳解

阿新 • • 發佈：2019-05-09
推廣 pre 問題 rect nco start 成了 logs too

閱讀目錄

  • 一、什麽是異步
  • 二、Task介紹
    • 1 Task創建和運行
    • 2 Task的阻塞方法(Wait/WaitAll/WaitAny)
    • 3 Task的延續操作(WhenAny/WhenAll/ContinueWith)
    • 4 Task的任務取消(CancellationTokenSource)
  • 三、異步方法(async/await)

回到頂部

一、什麽是異步

　　同步和異步主要用於修飾方法。當一個方法被調用時，調用者需要等待該方法執行完畢並返回才能繼續執行，我們稱這個方法是同步方法；當一個方法被調用時立即返回，並獲取一個線程執行該方法內部的業務，調用者不用等待該方法執行完畢，我們稱這個方法為異步方法。

　　異步的好處在於非阻塞(調用線程不會暫停執行去等待子線程完成)，因此我們把一些不需要立即使用結果、較耗時的任務設為異步執行，可以提高程序的運行效率。net4.0在ThreadPool的基礎上推出了Task類，微軟極力推薦使用Task來執行異步任務，現在C#類庫中的異步方法基本都用到了Task；net5.0推出了async/await，讓異步編程更為方便。本篇主要介紹Task、async/await相關的內容，其他異步操作的方式會在下一篇介紹。

回到頂部

二、Task介紹

　　Task是在ThreadPool的基礎上推出的，我們簡單了解下ThreadPool。ThreadPool中有若幹數量的線程，如果有任務需要處理時，會從線程池中獲取一個空閑的線程來執行任務，任務執行完畢後線程不會銷毀，而是被線程池回收以供後續任務使用。當線程池中所有的線程都在忙碌時，又有新任務要處理時，線程池才會新建一個線程來處理該任務，如果線程數量達到設置的最大值，任務會排隊，等待其他任務釋放線程後再執行。線程池能減少線程的創建，節省開銷，看一個ThreadPool的栗子吧

技術分享圖片 
        static void Main(string[] args)
        {
            for (int i = 1; i <=10; i++)
            {
                //ThreadPool執行任務
                ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => {
                    Console.WriteLine($"第{obj}個執行任務");
                }),i);
            }
            Console.ReadKey();
        }
技術分享圖片

　　上邊的代碼通過ThreadPool執行了10個任務，執行結果為：

技術分享圖片

　　ThreadPool相對於Thread來說可以減少線程的創建，有效減小系統開銷；但是ThreadPool不能控制線程的執行順序，我們也不能獲取線程池內線程取消/異常/完成的通知，即我們不能有效監控和控制線程池中的線程。

1 Task創建和運行

　　我們知道了ThreadPool的弊端：我們不能控制線程池中線程的執行順序，也不能獲取線程池內線程取消/異常/完成的通知。net4.0在ThreadPool的基礎上推出了Task，Task擁有線程池的優點，同時也解決了使用線程池不易控制的弊端。

首先看一下怎麽去創建並運行一個Task，Task的創建和執行方式有如下三種：

技術分享圖片 
        static void Main(string[] args)
        {
            //1.new方式實例化一個Task，需要通過Start方法啟動
            Task task = new Task(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine($"hello, task1的線程ID為{Thread.CurrentThread.ManagedThreadId}");
            });
            task.Start();

            //2.Task.Factory.StartNew(Action action)創建和啟動一個Task
            Task task2 = Task.Factory.StartNew(() =>
              {
                  Thread.Sleep(100);
                  Console.WriteLine($"hello, task2的線程ID為{ Thread.CurrentThread.ManagedThreadId}");
              });

            //3.Task.Run(Action action)將任務放在線程池隊列，返回並啟動一個Task
            Task task3 = Task.Run(() =>
              {
                  Thread.Sleep(100);
                  Console.WriteLine($"hello, task3的線程ID為{ Thread.CurrentThread.ManagedThreadId}");
              });
            Console.WriteLine("執行主線程！");
            Console.ReadKey();
        }
技術分享圖片

執行結果如下：

技術分享圖片

　　我們看到先打印"執行主線程"，然後再打印各個任務，說明了Task不會阻塞主線程。上邊的栗子Task都沒有返回值，我們也可以創建有返回值的Task<TResult>，用法和沒有返回值的基本一致,我們簡單修改一下上邊的栗子，代碼如下：

技術分享圖片 
        static void Main(string[] args)
        {
            ////1.new方式實例化一個Task，需要通過Start方法啟動
            Task<string> task = new Task<string>(() =>
            {
                return $"hello, task1的ID為{Thread.CurrentThread.ManagedThreadId}";
            });
            task.Start();

            ////2.Task.Factory.StartNew(Func func)創建和啟動一個Task
           Task<string> task2 =Task.Factory.StartNew<string>(() =>
            {
                return $"hello, task2的ID為{ Thread.CurrentThread.ManagedThreadId}";
            });

            ////3.Task.Run(Func func)將任務放在線程池隊列，返回並啟動一個Task
           Task<string> task3= Task.Run<string>(() =>
            {
                return $"hello, task3的ID為{ Thread.CurrentThread.ManagedThreadId}";
            });

            Console.WriteLine("執行主線程！");
            Console.WriteLine(task.Result);
            Console.WriteLine(task2.Result);
            Console.WriteLine(task3.Result);
            Console.ReadKey();
        }
技術分享圖片

　　註意task.Resut獲取結果時會阻塞線程，即如果task沒有執行完成，會等待task執行完成獲取到Result，然後再執行後邊的代碼，程序運行結果如下：

技術分享圖片

　 上邊的所有栗子中Task的執行都是異步的，不會阻塞主線程。有些場景下我們想讓Task同步執行怎麽辦呢？Task提供了 task.RunSynchronously()用於同步執行Task任務，代碼如下：

技術分享圖片 
        static void Main(string[] args)
        {
            Task task = new Task(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine("執行Task結束!");
            });
            //同步執行，task會阻塞主線程
            task.RunSynchronously();
            Console.WriteLine("執行主線程結束！");
            Console.ReadKey();
        }
技術分享圖片

執行結果如下：

技術分享圖片

2 Task的阻塞方法(Wait/WaitAll/WaitAny)

1 Thread阻塞線程的方法

　　使用Thread時，我們知道用thread.Join()方法即可阻塞主線程。看一個例子：

技術分享圖片 
        static void Main(string[] args)
        {
            Thread th1 = new Thread(() => {
                Thread.Sleep(500);
                Console.WriteLine("線程1執行完畢！");
            });
            th1.Start();
            Thread th2 = new Thread(() => {
                Thread.Sleep(1000);
                Console.WriteLine("線程2執行完畢！");
            });
            th2.Start();
            //阻塞主線程
            th1.Join();
            th2.Join();
            Console.WriteLine("主線程執行完畢！");
            Console.ReadKey();
        }
技術分享圖片

　　如果註釋掉兩個Join，執行結果是：先打印【主線程執行完畢】，而添加兩個Join方法後執行結果如下，實現了線程阻塞：

技術分享圖片

2 Task的Wait/WaitAny/WaitAll方法

　　Thread的Join方法可以阻塞調用線程，但是有一些弊端：①如果我們要實現很多線程的阻塞時，每個線程都要調用一次Join方法；②如果我們想讓所有的線程執行完畢(或者任一線程執行完畢)時，立即解除阻塞，使用Join方法不容易實現。Task提供了 Wait/WaitAny/WaitAll 方法，可以更方便地控制線程阻塞。

task.Wait() 表示等待task執行完畢，功能類似於thead.Join()； Task.WaitAll(Task[] tasks) 表示只有所有的task都執行完成了再解除阻塞； Task.WaitAny(Task[] tasks) 表示只要有一個task執行完畢就解除阻塞，看一個栗子：

技術分享圖片 
        static void Main(string[] args)
        {
            Task task1 = new Task(() => {
                Thread.Sleep(500);
                Console.WriteLine("線程1執行完畢！");
            });
            task1.Start();
            Task task2 = new Task(() => {
                Thread.Sleep(1000);
                Console.WriteLine("線程2執行完畢！");
            });
            task2.Start();
            //阻塞主線程。task1,task2都執行完畢再執行主線程
　　　　　　　//執行【task1.Wait();task2.Wait();】可以實現相同功能
            Task.WaitAll(new Task[]{ task1,task2});
            Console.WriteLine("主線程執行完畢！");
            Console.ReadKey();
        }
技術分享圖片

　　執行結果如下：

技術分享圖片

　　如果將栗子中的WaitAll換成WaitAny，那麽任一task執行完畢就會解除線程阻塞，執行結果是：先打印【線程1執行完畢】，然後打印【主線程執行完畢】，最後打印【線程2執行完畢】

3 Task的延續操作(WhenAny/WhenAll/ContinueWith)

　　上邊的Wait/WaitAny/WaitAll方法返回值為void，這些方法單純的實現阻塞線程。我們現在想讓所有task執行完畢(或者任一task執行完畢)後，開始執行後續操作，怎麽實現呢？這時就可以用到WhenAny/WhenAll方法了，這些方法執行完成返回一個task實例。 task.WhenAll(Task[] tasks) 表示所有的task都執行完畢後再去執行後續的操作， task.WhenAny(Task[] tasks) 表示任一task執行完畢後就開始執行後續操作。看一個栗子：

技術分享圖片 
        static void Main(string[] args)
        {
            Task task1 = new Task(() => {
                Thread.Sleep(500);
                Console.WriteLine("線程1執行完畢！");
            });
            task1.Start();
            Task task2 = new Task(() => {
                Thread.Sleep(1000);
                Console.WriteLine("線程2執行完畢！");
            });
            task2.Start();
            //task1，task2執行完了後執行後續操作
            Task.WhenAll(task1, task2).ContinueWith((t) => {
                Thread.Sleep(100);
                Console.WriteLine("執行後續操作完畢！");
            });

            Console.WriteLine("主線程執行完畢！");
            Console.ReadKey();
        }
技術分享圖片

　　執行結果如下，我們看到WhenAll/WhenAny方法不會阻塞主線程，當使用WhenAll方法時所有的task都執行完畢才會執行後續操作；如果把栗子中的WhenAll替換成WhenAny，則只要有一個線程執行完畢就會開始執行後續操作，這裏不再演示。

技術分享圖片

　　上邊的栗子也可以通過 Task.Factory.ContinueWhenAll(Task[] tasks, Action continuationAction) 和 Task.Factory.ContinueWhenAny(Task[] tasks, Action continuationAction) 來實現 ，修改上邊栗子代碼如下，執行結果不變。

技術分享圖片 
       static void Main(string[] args)
        {
            Task task1 = new Task(() => {
                Thread.Sleep(500);
                Console.WriteLine("線程1執行完畢！");
            });
            task1.Start();
            Task task2 = new Task(() => {
                Thread.Sleep(1000);
                Console.WriteLine("線程2執行完畢！");
            });
            task2.Start();
            //通過TaskFactroy實現
            Task.Factory.ContinueWhenAll(new Task[] { task1, task2 }, (t) =>
            {
                Thread.Sleep(100);
                Console.WriteLine("執行後續操作");
            });

            Console.WriteLine("主線程執行完畢！");
            Console.ReadKey();
        }
技術分享圖片

4 Task的任務取消(CancellationTokenSource)

1 Thread取消任務執行

　　在Task前我們執行任務采用的是Thread,Thread怎麽取消任務呢？一般流程是：設置一個變量來控制任務是否停止，如設置一個變量isStop，然後線程輪詢查看isStop，如果isStop為true就停止，代碼如下：

技術分享圖片 
        static void Main(string[] args)
        {
            bool isStop = false;
            int index = 0;
            //開啟一個線程執行任務
            Thread th1 = new Thread(() =>
              {
                  while (!isStop)
                  {
                      Thread.Sleep(1000);
                      Console.WriteLine($"第{++index}次執行，線程運行中...");
                  }
              });
            th1.Start();
            //五秒後取消任務執行
            Thread.Sleep(5000);
            isStop = true;
            Console.ReadKey();
        }
技術分享圖片

2 Task取消任務執行

　　Task中有一個專門的類 CancellationTokenSource 來取消任務執行，還是使用上邊的例子，我們修改代碼如下，程序運行的效果不變。

技術分享圖片 
        static void Main(string[] args)
        {
            CancellationTokenSource source = new CancellationTokenSource();
            int index = 0;
            //開啟一個task執行任務
            Task task1 = new Task(() =>
              {
                  while (!source.IsCancellationRequested)
                  {
                      Thread.Sleep(1000);
                      Console.WriteLine($"第{++index}次執行，線程運行中...");
                  }
              });
            task1.Start();
            //五秒後取消任務執行
            Thread.Sleep(5000);
            //source.Cancel()方法請求取消任務，IsCancellationRequested會變成true
            source.Cancel();
            Console.ReadKey();
        }
技術分享圖片

　　 CancellationTokenSource的功能不僅僅是取消任務執行，我們可以使用 source.CancelAfter(5000) 實現5秒後自動取消任務，也可以通過 source.Token.Register(Action action) 註冊取消任務觸發的回調函數，即任務被取消時註冊的action會被執行。 看一個栗子：

技術分享圖片 
        static void Main(string[] args)
        {
            CancellationTokenSource source = new CancellationTokenSource();
            //註冊任務取消的事件
            source.Token.Register(() =>
            {
                Console.WriteLine("任務被取消後執行xx操作！");
            });

            int index = 0;
            //開啟一個task執行任務
            Task task1 = new Task(() =>
              {
                  while (!source.IsCancellationRequested)
                  {
                      Thread.Sleep(1000);
                      Console.WriteLine($"第{++index}次執行，線程運行中...");
                  }
              });
            task1.Start();
            //延時取消，效果等同於Thread.Sleep(5000);source.Cancel();
            source.CancelAfter(5000);
            Console.ReadKey();
        }
技術分享圖片

　　執行結果如下，第5次執行在取消回調後打印，這是因為，執行取消的時候第5次任務已經通過了while()判斷，任務已經執行中了：

技術分享圖片

　　 最後看上一篇跨線程的栗子，點擊按鈕啟動一個任務，給tetxtbox賦值，我們把Thread改成Task，代碼如下：

技術分享圖片 
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void mySetValueBtn_Click(object sender, EventArgs e)
        {
            Task.Run(() =>
            {
                Action<int> setValue = (i) => { myTxtbox.Text = i.ToString(); };
                for (int i = 0; i < 1000000; i++)
                {
                    myTxtbox.Invoke(setValue,i);
                }
            });
        }
    }
技術分享圖片

　　運行界面如下，賦值的task不會阻塞UI線程：

技術分享圖片

回到頂部

三、異步方法(async/await)

　　在C#5.0中出現的 async和await ，讓異步編程變得更簡單。我們看一個獲取文件內容的栗子：

技術分享圖片 
    class Program
    {
        static void Main(string[] args)
        {
            string content = GetContentAsync(Environment.CurrentDirectory + @"/test.txt").Result;
            //調用同步方法
            //string content = GetContent(Environment.CurrentDirectory + @"/test.txt");
            Console.WriteLine(content);
            Console.ReadKey();
        }
        //異步讀取文件內容
        async static Task<string> GetContentAsync(string filename)
        {
            
            FileStream fs = new FileStream(filename, FileMode.Open);
            var bytes = new byte[fs.Length];
            //ReadAync方法異步讀取內容，不阻塞線程
            Console.WriteLine("開始讀取文件");
            int len = await fs.ReadAsync(bytes, 0, bytes.Length);
            string result = Encoding.UTF8.GetString(bytes);
            return result;
        }
        //同步讀取文件內容
        static string GetContent(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Open);
            var bytes = new byte[fs.Length];
            //Read方法同步讀取內容，阻塞線程
            int len =  fs.Read(bytes, 0, bytes.Length);
            string result = Encoding.UTF8.GetString(bytes);
            return result;
        }
    }
技術分享圖片

　　test.txt內容是【hello world！】執行結果為：

技術分享圖片

　　上邊的栗子也寫出了同步讀取的方式，將main函數中的註釋去掉即可同步讀取文件內容。我們可以看到異步讀取代碼和同步讀取代碼基本一致。async/await讓異步編碼變得更簡單，我們可以像寫同步代碼一樣去寫異步代碼。註意一個小問題：異步方法中方法簽名返回值為Task<TResult>，代碼中的返回值為TResult。上邊栗子中GetContentAsync的簽名返回值為Task<string>，而代碼中返回值為string。牢記這一細節對我們分析異步代碼很有幫助。通過上邊的栗子我們知道aysnc/await的用法十分簡單，那麽aynsc標記的異步方法是怎樣執行的呢？什麽時候創建的任務線程？再看一個簡單的栗子：

技術分享圖片 
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(">>>>>>>>>>>>>>>>主線程啟動");
            Task<string> task = GetStringAsync1();
            Console.WriteLine("<<<<<<<<<<<<<<<<主線程結束");
            Console.WriteLine($"GetStringAsync1執行結果：{task.Result}");
        }

        static async Task<string> GetStringAsync1()
        {
            Console.WriteLine(">>>>>>>>GetStringAsync1方法啟動");
            string str = await GetStringAsync2();
            Console.WriteLine("<<<<<<<<GetStringAsync1方法結束");
            return str;
        }
        static async Task<string> GetStringAsync2()
        {
            Console.WriteLine(">>>>>>>>GetStringAsync2方法啟動");
            string str = await GetStringFromTask();
            Console.WriteLine("<<<<<<<<GetStringAsync2方法結束");
            return str;
        }

        static Task<string> GetStringFromTask()
        {
            Console.WriteLine(">>>>GetStringFromTask方法啟動");
            Task<string> task = new Task<string>(() =>
             {
                 Console.WriteLine(">>任務線程啟動");
                 Thread.Sleep(1000);
                 Console.WriteLine("<<任務線程結束");
                 return "hello world";
             });
            task.Start();
            Console.WriteLine("<<<<GetStringFromTask方法結束");
            return task;
        }
    }
技術分享圖片

　　使用async/await時，主線程和執行同步代碼一樣，是一路執行到底的，執行到await時也沒有返回main函數，而是創建了一個空閑的任務後繼續往下執行，當所有的調用的方法都執行完畢後再返回main函數。主線程執行到task.Start()才創建任務線程，真正開始執行異步任務。當異步方法async Task<T>A()需要另一個異步方法async Task<T>B()的結果時，A()會等待B()完成異步任務再繼續向下執行。程序執行結果如下：

技術分享圖片

　　小結：到這裏Task，async/await的簡單使用已經基本結束了，一些高級特性等到工作遇到了再去研究。通過上邊的介紹，我們知道async/await是基於Task的，而Task是對ThreadPool的封裝改進，主要是為了更有效的控制線程池中的線程(ThreadPool中的線程，我們很難通過代碼控制其執行順序，任務延續和取消等等)；ThreadPool基於Thread的，主要目的是減少Thread創建數量和管理Thread的成本。async/await Task是C#中更先進的，也是微軟大力推廣的特性，我們在開發中可以嘗試使用Task來替代Thread/ThreadPool，處理本地IO和網絡IO任務是盡量使用async/await來提高任務執行效率。

C#多線程和異步——Task和async/await詳解

相關推薦

C# 多線程之異步回調

clean leg 多線程 pan ons sync line lee 回調 using System; using System.Collections.Generic; using System.Linq; using System.Runtime.Remoting.

C#多線程與異步的區別

編譯 網絡 pool delegate con quest invoke 順序 回調 隨著擁有多個硬線程CPU（超線程、雙核）的普及，多線程和異步操作等並發程序設計方法也受到了更多的關註和討論。本文主要是想與園中各位高手一同探討一下如何使用並發來最大化程序的性能。 　　多線

C#多線程和異步——Task和async/await詳解

推廣 pre 問題 rect nco start 成了 logs too 閱讀目錄 一、什麽是異步 二、Task介紹 1 Task創建和運行 2 Task的阻塞方法(Wait/WaitAll/WaitAny) 3 Task的延續操作(WhenAny/W

c#多線程（二）——同步和異步

沒有 之前 什麽 adk 返回 con bsp cti csu 1、什麽是異步 　　如果一個程序調用某個方法，等待其執行所有處理後才繼續執行，我們稱這樣的方法是同步的。 　　如果一個程序調用某個方法，在該方法處理完成之前就返回到調用方法，則這個方法是異步的。 異步的好處在於

C#多線程之旅(1)——介紹和基本概念

隔離 cnblogs 影響 3-0 同時 ima 並行 logic mes 閱讀目錄 一、多線程介紹 二、Join 和Sleep 三、線程怎樣工作 四、線程和進程 五、線程的使用和誤用 原文地址：C#多線程之旅(1)——介紹和基本概念 C#多線程之旅目錄： C#

python學習筆記之四-多進程&多線程&異步非阻塞

running executor 服務器 RoCE 進行 break python buffer 創建 ProcessPoolExecutor對multiprocessing進行了高級抽象，暴露出簡單的統一接口。 異步非阻塞 爬蟲 對於異步IO請求的本質則是【非阻塞So

C#多線程和異步（三）——一些異步編程模式

img rar 效率 釋放 http 調用 完成 引用 iar 一、任務並行庫 　　任務並行庫（Task Parellel Library）是BCL中的一個類庫，極大地簡化了並行編程，這裏以Parallel.For和Parallel.ForEach為例。在C#中for/fo

C#多線程編程（1）--線程，線程池和Task

gpo 第一次 span via 任務隊列 返回值 異步 如果 是你 　　新開了一個多線程編程系列，該系列主要講解C#中的多線程編程。　 利用多線程的目的有2個: 一是防止UI線程被耗時的程序占用，導致界面卡頓；二是能夠利用多核CPU的資源，提高運行效率。 　　我沒有

[深入學習C#]C#實現多線程的方式：Task——任務

ren avr 利用 run 如何 創建 其中 continue rep 簡介 　　.NET 4包含新名稱空間System.Threading.Tasks，它 包含的類抽象出了線程功能。 在後臺使用ThreadPool。 任務表示應完成的某個單元的工作。 這個單元的工作可以

C#多線程之 ManualResetEvent和AutoResetEvent

允許 container 參數 ber dex threads thread res esp 初次體驗 ManualResetEvent和AutoResetEvent主要負責多線程編程中的線程同步；以下一段是引述網上和MSDN的解析： 在.Net多線程編程中,AutoR

C#多線程和高並發

tps 似的 反序 ans otn mage 位置 .cn prot 在任何 TCP Server 的實現中，一定存在一個 Accept Socket Loop，用於接收 Client 端的 Connect 請求以建立 TCP Connection。 在任何 TCP Se

C#多線程學習(三) 生產者和消費者

... new col 線程 簡單的 ons finally 訪問 read 前面說過，每個線程都有自己的資源，但是代碼區是共享的，即每個線程都可以執行相同的函數。這可能帶來的問題就是幾個線程同時執行一個函數，導致數據的混亂，產生不可預料的結果，因此我們必須避免這種情況的發

C# 多線程學習（五）線程同步和沖突解決

執行 負責 void RF 運行 ner 有效 als 效果 from:https://blog.csdn.net/codedoctor/article/details/74358257 首先先說一個線程不同步的例子吧，以下為售票員的模擬售票，多個售票員出售100張門票，

c#多線程（一）——基礎概念和基本使用

err inf nag -c 完成 KS 是否 only () 一、多線程相關的基本概念 進程（Process）：是系統中的一個基本概念。 一個正在運行的應用程序在操作系統中被視為一個進程，包含著一個運行程序所需要的資源，進程可以包括一個或多個線程 。進程之間是相對獨立的，

C#異步編程（一）線程及異步編程基礎

public 訪問 疊加 ade 上下 closed clear stat sum 　　最近試著做了幾個.NET CORE的demo，看了些源碼，感覺異步編程在Core裏面已經成為主流，而對這塊我還沒有一個系統的總結，所以就出現了這篇文字，接下來幾篇文章，我會總結下異步編程

C#多線程的幾種方法

task start invoke 數組 erl method 並行計算 bsp nbsp 1、Theard2、TheardPool 線程池3、Task 在Theard上做了優化和改進，建議使用 .start();4、Task.Factory.Start(method)

Windows 下 C/C++ 多線程編程入門參考範例

tail emc repr com std using tle rom amp [c-sharp] view plaincopy #include <windows.h> #include <iostream> using n

C#多線程之旅(3)

它的 logs 更新 nth 使用 targe result 右下角 介紹 閱讀目錄 代碼下載 一、介紹 二、通過TPL進入線程池 三、不用TPL進入到線程池 v博客前言 先交代下背景，寫《C#多線程之旅》這個系列文章主要是因為以下幾個原因：1.多線程在C/S和

C++ 多線程

編程 details c++多線程 tails detail csdn 線程 col http 【C++多線程編程】Boost線程庫　　http://blog.csdn.net/yockie/article/details/26985187 【C++並發實戰1】　　　　　　

《C#多線程編程實現方式》

所有 cal 優先級 lin threading 內核對象 gin 執行 多個 一、使用線程的理由 1、可以使用線程將代碼同其他代碼隔離，提高應用程序的可靠性。 2、可以使用線程來簡化編碼。 3、可以使用線程來實現並發執行。 二、基本知識 1、進程與線程：進程作為操作系