C#多線程編程系列（四）- 使用線程池

時間  2019-11-11
標籤 c# 多線程 編程 系列 使用 線程 欄目 C# 简体版
原文   原文鏈接

目錄git

1.1 簡介

在本章中，主要介紹線程池(ThreadPool)的使用；在C#中它叫System.Threading.ThreadPool，在使用線程池以前首先咱們得明白一個問題，那就是爲何要使用線程池。其主要緣由是建立一個線程的代價是昂貴的，建立一個線程會消耗不少的系統資源。編程

那麼線程池是如何解決這個問題的呢？線程池在初始時會自動建立必定量的線程供程序調用，使用時，開發人員並不直接分配線程，而是將須要作的工做放入線程池工做隊列中，由線程池分配已有的線程進行處理，等處理完畢後線程不是被銷燬，而是從新回到線程池中，這樣節省了建立線程的開銷。c#

可是在使用線程池時，須要注意如下幾點，這將很是重要。設計模式

  • 線程池不適合處理長時間運行的做業，或者處理須要與其它線程同步的做業。
  • 避免將線程池中的工做線程分配給I/O首先的任務，這種任務應該使用TPL模型。
  • 如非必須，不要手動設置線程池的最小線程數和最大線程數，CLR會自動的進行線程池的擴張和收縮，手動干預每每讓性能更差。

1.2 在線程池中調用委託

本節展現的是如何在線程池中如何異步的執行委託，而後將介紹一個叫異步編程模型(Asynchronous Programming Model，簡稱APM)的異步編程方式。安全

在本節及之後，爲了下降代碼量，在引用程序集聲明位置默認添加了using static System.Console和using static System.Threading.Thead聲明，這樣聲明可讓咱們在程序中少些一些意義不大的調用語句。多線程

演示代碼以下所示，使用了普通建立線程和APM方式來執行同一個任務。閉包

static void Main(string[] args)
{
    int threadId = 0;

    RunOnThreadPool poolDelegate = Test;

    var t = new Thread(() => Test(out threadId));
    t.Start();
    t.Join();

    WriteLine($"手動建立線程 Id: {threadId}");

    // 使用APM方式 進行異步調用  異步調用會使用線程池中的線程
    IAsyncResult r = poolDelegate.BeginInvoke(out threadId, Callback, "委託異步調用");
    r.AsyncWaitHandle.WaitOne();

    // 獲取異步調用結果
    string result = poolDelegate.EndInvoke(out threadId, r);

    WriteLine($"Thread - 線程池工做線程Id: {threadId}");
    WriteLine(result);

    Console.ReadLine();
}

// 建立帶一個參數的委託類型
private delegate string RunOnThreadPool(out int threadId);

private static void Callback(IAsyncResult ar)
{
    WriteLine("Callback - 開始運行Callback...");
    WriteLine($"Callback - 回調傳遞狀態: {ar.AsyncState}");
    WriteLine($"Callback - 是否爲線程池線程: {CurrentThread.IsThreadPoolThread}");
    WriteLine($"Callback - 線程池工做線程Id: {CurrentThread.ManagedThreadId}");
}

private static string Test(out int threadId)
{
    string isThreadPoolThread = CurrentThread.IsThreadPoolThread ? "ThreadPool - ": "Thread - ";

    WriteLine($"{isThreadPoolThread}開始運行...");
    WriteLine($"{isThreadPoolThread}是否爲線程池線程: {CurrentThread.IsThreadPoolThread}");
    Sleep(TimeSpan.FromSeconds(2));
    threadId = CurrentThread.ManagedThreadId;
    return $"{isThreadPoolThread}線程池工做線程Id: {threadId}";
}

運行結果以下圖所示，其中以Thread開頭的爲手動建立的線程輸出的信息，而TheadPool爲開始線程池任務輸出的信息，Callback爲APM模式運行任務結束後，執行的回調方法，能夠清晰的看到，Callback的線程也是線程池的工做線程。異步

1533523675523

在上文中，使用BeginOperationName/EndOperationName方法和.Net中的IAsyncResult對象的方式被稱爲異步編程模型(或APM模式)，這樣的方法被稱爲異步方法。使用委託的BeginInvoke方法來運行該委託，BeginInvoke接收一個回調函數，該回調函數會在任務處理完成後背調用，而且能夠傳遞一個用戶自定義的狀態給回調函數。async

如今這種APM編程方式用的愈來愈少了，更推薦使用任務並行庫(Task Parallel Library，簡稱TPL)來組織異步API。異步編程

1.3 向線程池中放入異步操做

本節將介紹如何將異步操做放入線程池中執行，而且如何傳遞參數給線程池中的線程。本節中主要用到的是ThreadPool.QueueUserWorkItem()方法，該方法可將須要運行的任務經過委託的形式傳遞給線程池中的線程，而且容許傳遞參數。

使用比較簡單，演示代碼以下所示。演示了線程池使用中如何傳遞方法和參數，最後須要注意的是使用了Lambda表達式和它的閉包機制。

static void Main(string[] args)
{
    const int x = 1;
    const int y = 2;
    const string lambdaState = "lambda state 2";

    // 直接將方法傳遞給線程池
    ThreadPool.QueueUserWorkItem(AsyncOperation);
    Sleep(TimeSpan.FromSeconds(1));

    // 直接將方法傳遞給線程池 而且 經過state傳遞參數
    ThreadPool.QueueUserWorkItem(AsyncOperation, "async state");
    Sleep(TimeSpan.FromSeconds(1));

    // 使用Lambda表達式將任務傳遞給線程池 而且經過 state傳遞參數
    ThreadPool.QueueUserWorkItem(state =>
    {
        WriteLine($"Operation state: {state}");
        WriteLine($"工做線程 id: {CurrentThread.ManagedThreadId}");
        Sleep(TimeSpan.FromSeconds(2));
    }, "lambda state");

    // 使用Lambda表達式將任務傳遞給線程池 經過 **閉包** 機制傳遞參數
    ThreadPool.QueueUserWorkItem(_ =>
    {
        WriteLine($"Operation state: {x + y}, {lambdaState}");
        WriteLine($"工做線程 id: {CurrentThread.ManagedThreadId}");
        Sleep(TimeSpan.FromSeconds(2));
    }, "lambda state");

    ReadLine();
}

private static void AsyncOperation(object state)
{
    WriteLine($"Operation state: {state ?? "(null)"}");
    WriteLine($"工做線程 id: {CurrentThread.ManagedThreadId}");
    Sleep(TimeSpan.FromSeconds(2));
}

運行結果以下圖所示。

1533537253353

1.4 線程池與並行度

在本節中，主要是使用普通建立線程和使用線程池內的線程在任務量比較大的狀況下有什麼區別，咱們模擬了一個場景，建立了不少不一樣的線程，而後分別使用普通建立線程方式和線程池方式看看有什麼不一樣。

static void Main(string[] args)
{
    const int numberOfOperations = 500;
    var sw = new Stopwatch();
    sw.Start();
    UseThreads(numberOfOperations);
    sw.Stop();
    WriteLine($"使用線程執行總用時: {sw.ElapsedMilliseconds}");

    sw.Reset();
    sw.Start();
    UseThreadPool(numberOfOperations);
    sw.Stop();
    WriteLine($"使用線程池執行總用時: {sw.ElapsedMilliseconds}");

    Console.ReadLine();
}

static void UseThreads(int numberOfOperations)
{
    using (var countdown = new CountdownEvent(numberOfOperations))
    {
        WriteLine("經過建立線程調度工做");
        for (int i = 0; i < numberOfOperations; i++)
        {
            var thread = new Thread(() =>
            {
                Write($"{CurrentThread.ManagedThreadId},");
                Sleep(TimeSpan.FromSeconds(0.1));
                countdown.Signal();
            });
            thread.Start();
        }
        countdown.Wait();
        WriteLine();
    }
}

static void UseThreadPool(int numberOfOperations)
{
    using (var countdown = new CountdownEvent(numberOfOperations))
    {
        WriteLine("使用線程池開始工做");
        for (int i = 0; i < numberOfOperations; i++)
        {
            ThreadPool.QueueUserWorkItem(_ =>
            {
                Write($"{CurrentThread.ManagedThreadId},");
                Sleep(TimeSpan.FromSeconds(0.1));
                countdown.Signal();
            });
        }
        countdown.Wait();
        WriteLine();
    }
}

執行結果以下，可見使用原始的建立線程執行，速度很是快。只花了2秒鐘，可是建立了500多個線程，而使用線程池相對來講比較慢，花了9秒鐘，可是隻建立了不多的線程，爲操做系統節省了線程和內存空間，但花了更多的時間。

1533540572298

1.5 實現一個取消選項

在以前的文章中有提到，若是須要終止一個線程的執行，那麼可使用Abort()方法，可是有諸多的緣由並不推薦使用Abort()方法。

這裏推薦的方式是使用協做式取消(cooperative cancellation)，這是一種可靠的技術來安全取消再也不須要的任務。其主要用到CancellationTokenSource和CancellationToken兩個類，具體用法見下面演示代碼。

如下延時代碼主要是實現了使用CancellationToken和CancellationTokenSource來實現任務的取消。可是任務取消後能夠進行三種操做，分別是：直接返回、拋出ThrowIfCancellationRequesed異常和執行回調。詳細請看代碼。

static void Main(string[] args)
{
    // 使用CancellationToken來取消任務  取消任務直接返回
    using (var cts = new CancellationTokenSource())
    {
        CancellationToken token = cts.Token;
        ThreadPool.QueueUserWorkItem(_ => AsyncOperation1(token));
        Sleep(TimeSpan.FromSeconds(2));
        cts.Cancel();
    }

    // 取消任務 拋出 ThrowIfCancellationRequesed 異常
    using (var cts = new CancellationTokenSource())
    {
        CancellationToken token = cts.Token;
        ThreadPool.QueueUserWorkItem(_ => AsyncOperation2(token));
        Sleep(TimeSpan.FromSeconds(2));
        cts.Cancel();
    }

    // 取消任務 並 執行取消後的回調函數
    using (var cts = new CancellationTokenSource())
    {
        CancellationToken token = cts.Token;
        token.Register(() => { WriteLine("第三個任務被取消，執行回調函數。"); });
        ThreadPool.QueueUserWorkItem(_ => AsyncOperation3(token));
        Sleep(TimeSpan.FromSeconds(2));
        cts.Cancel();
    }

    ReadLine();
}

static void AsyncOperation1(CancellationToken token)
{
    WriteLine("啓動第一個任務.");
    for (int i = 0; i < 5; i++)
    {
        if (token.IsCancellationRequested)
        {
            WriteLine("第一個任務被取消.");
            return;
        }
        Sleep(TimeSpan.FromSeconds(1));
    }
    WriteLine("第一個任務運行完成.");
}

static void AsyncOperation2(CancellationToken token)
{
    try
    {
        WriteLine("啓動第二個任務.");

        for (int i = 0; i < 5; i++)
        {
            token.ThrowIfCancellationRequested();
            Sleep(TimeSpan.FromSeconds(1));
        }
        WriteLine("第二個任務運行完成.");
    }
    catch (OperationCanceledException)
    {
        WriteLine("第二個任務被取消.");
    }
}

static void AsyncOperation3(CancellationToken token)
{
    WriteLine("啓動第三個任務.");
    for (int i = 0; i < 5; i++)
    {
        if (token.IsCancellationRequested)
        {
            WriteLine("第三個任務被取消.");
            return;
        }
        Sleep(TimeSpan.FromSeconds(1));
    }
    WriteLine("第三個任務運行完成.");
}

運行結果以下所示，符合預期結果。

1533547890589

1.6 在線程池中使用等待事件處理器及超時

本節將介紹如何在線程池中使用等待任務和如何進行超時處理，其中主要用到ThreadPool.RegisterWaitForSingleObject()方法，該方法容許傳入一個WaitHandle對象，和須要執行的任務、超時時間等。經過使用這個方法，可完成線程池狀況下對超時任務的處理。

演示代碼以下所示，運行了兩次使用ThreadPool.RegisterWaitForSingleObject()編寫超時代碼的RunOperations()方法，可是所傳入的超時時間不一樣，因此形成一個必然超時和一個不會超時的結果。

static void Main(string[] args)
{
    // 設置超時時間爲 5s WorkerOperation會延時 6s 確定會超時
    RunOperations(TimeSpan.FromSeconds(5));

    // 設置超時時間爲 7s 不會超時
    RunOperations(TimeSpan.FromSeconds(7));
}

static void RunOperations(TimeSpan workerOperationTimeout)
{
    using (var evt = new ManualResetEvent(false))
    using (var cts = new CancellationTokenSource())
    {
        WriteLine("註冊超時操做...");
        // 傳入同步事件  超時處理函數  和 超時時間
        var worker = ThreadPool.RegisterWaitForSingleObject(evt
            , (state, isTimedOut) => WorkerOperationWait(cts, isTimedOut)
            , null
            , workerOperationTimeout
            , true);

        WriteLine("啓動長時間運行操做...");
        ThreadPool.QueueUserWorkItem(_ => WorkerOperation(cts.Token, evt));

        Sleep(workerOperationTimeout.Add(TimeSpan.FromSeconds(2)));

        // 取消註冊等待的操做
        worker.Unregister(evt);

        ReadLine();
    }
}

static void WorkerOperation(CancellationToken token, ManualResetEvent evt)
{
    for (int i = 0; i < 6; i++)
    {
        if (token.IsCancellationRequested)
        {
            return;
        }
        Sleep(TimeSpan.FromSeconds(1));
    }
    evt.Set();
}

static void WorkerOperationWait(CancellationTokenSource cts, bool isTimedOut)
{
    if (isTimedOut)
    {
        cts.Cancel();
        WriteLine("工做操做超時並被取消.");
    }
    else
    {
        WriteLine("工做操做成功.");
    }
}

運行結果以下圖所示，與預期結果相符。

1533556752088

1.7 使用計時器

計時器是FCL提供的一個類，叫System.Threading.Timer，可要結果與建立週期性的異步操做。該類使用比較簡單。

如下的演示代碼使用了定時器，並設置了定時器延時啓動時間和週期時間。

static void Main(string[] args)
{
    WriteLine("按下回車鍵，結束定時器...");
    DateTime start = DateTime.Now;

    // 建立定時器
    _timer = new Timer(_ => TimerOperation(start), null
        , TimeSpan.FromSeconds(1)
        , TimeSpan.FromSeconds(2));
    try
    {
        Sleep(TimeSpan.FromSeconds(6));

        _timer.Change(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(4));

        ReadLine();
    }
    finally
    {
        //實現了IDispose接口  要及時釋放
        _timer.Dispose();
    }
}

static Timer _timer;

static void TimerOperation(DateTime start)
{
    TimeSpan elapsed = DateTime.Now - start;
    WriteLine($"離 {start} 過去了 {elapsed.Seconds} 秒. " +
              $"定時器線程池 線程 id: {CurrentThread.ManagedThreadId}");
}

運行結果以下所示，可見定時器根據所設置的週期時間循環的調用TimerOperation()方法。

1533557619004

1.8 使用BackgroundWorker組件

本節主要介紹BackgroundWorker組件的使用，該組件實際上被用於Windows窗體應用程序(Windows Forms Application，簡稱 WPF)中，經過它實現的代碼能夠直接與UI控制器交互，更加自認和好用。

演示代碼以下所示，使用BackgroundWorker來實現對數據進行計算，而且讓其支持報告工做進度，支持取消任務。

static void Main(string[] args)
{
    var bw = new BackgroundWorker();
    // 設置可報告進度更新
    bw.WorkerReportsProgress = true;
    // 設置支持取消操做
    bw.WorkerSupportsCancellation = true;

    // 須要作的工做
    bw.DoWork += Worker_DoWork;
    // 工做處理進度
    bw.ProgressChanged += Worker_ProgressChanged;
    // 工做完成後處理函數
    bw.RunWorkerCompleted += Worker_Completed;

    bw.RunWorkerAsync();

    WriteLine("按下 `C` 鍵 取消工做");
    do
    {
        if (ReadKey(true).KeyChar == 'C')
        {
            bw.CancelAsync();
        }

    }
    while (bw.IsBusy);
}

static void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    WriteLine($"DoWork 線程池 線程 id: {CurrentThread.ManagedThreadId}");
    var bw = (BackgroundWorker)sender;
    for (int i = 1; i <= 100; i++)
    {
        if (bw.CancellationPending)
        {
            e.Cancel = true;
            return;
        }
        if (i % 10 == 0)
        {
            bw.ReportProgress(i);
        }

        Sleep(TimeSpan.FromSeconds(0.1));
    }

    e.Result = 42;
}

static void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    WriteLine($"已完成{e.ProgressPercentage}%. " +
              $"處理線程 id: {CurrentThread.ManagedThreadId}");
}

static void Worker_Completed(object sender, RunWorkerCompletedEventArgs e)
{
    WriteLine($"完成線程池線程 id: {CurrentThread.ManagedThreadId}");
    if (e.Error != null)
    {
        WriteLine($"異常 {e.Error.Message} 發生.");
    }
    else if (e.Cancelled)
    {
        WriteLine($"操做已被取消.");
    }
    else
    {
        WriteLine($"答案是 : {e.Result}");
    }
}

運行結果以下所示。

1533558846212

在本節中，使用了C#中的另一個語法，叫事件(event)。固然這裏的事件不一樣於以前在線程同步章節中提到的事件，這裏是觀察者設計模式的體現，包括事件源、訂閱者和事件處理程序。所以，除了異步APM模式意外，還有基於事件的異步模式(Event-based Asynchronous Pattern，簡稱 EAP)。

參考書籍

本文主要參考瞭如下幾本書，在此對這些做者表示由衷的感謝大家提供了這麼好的資料。

  1. 《CLR via C#》
  2. 《C# in Depth Third Edition》
  3. 《Essential C# 6.0》
  4. 《Multithreading with C# Cookbook Second Edition》
  5. 《C#多線程編程實戰》

源碼下載點擊連接 示例源碼下載

筆者水平有限，若是錯誤歡迎各位批評指正！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程