多線程編程學習筆記——使用非同步IO（一）

假設以下場景，如果在客戶端運行程式，最的事情之一是有一個響應的用戶界面。這意味著無論應用程式發生什麼，所有的用戶界面元素都要保持快速運行，用戶能夠從應用程式得到快速響應。達到這一點並不容易！如果你嘗試在Windows系統中打開記事本並載入一個有幾兆大小的文檔，應用程式視窗將交結一段的時間，因為整個... ...

接上文多線程編程學習筆記——使用併發集合（一）

接上文多線程編程學習筆記——使用併發集合（二）

接上文多線程編程學習筆記——使用併發集合（三）

假設以下場景，如果在客戶端運行程式，最的事情之一是有一個響應的用戶界面。這意味著無論應用程式發生什麼，所有的用戶界面元素都要保持快速運行，用戶能夠從應用程式得到快速響應。達到這一點並不容易！如果你嘗試在Windows系統中打開記事本並載入一個有幾兆大小的文檔，應用程式視窗將交結一段的時間，因為整個文件要先從硬碟中載入，然後程式才能開始處理用戶輸入。

這是一個非常重要的問題，在這種情況下，唯一方案是無論如何都要避免阻塞UI純種。這反過來意味著為了防止阻塞UI線程，每個與UI有關的API必須只被允許非同步調用。這是Windows操作系統重新升級API的關鍵原因，其幾乎把每個方法替換為非同步方式。但是應用程式使用多線程來達到此目的會影響性能嗎？當然會。然而考慮到只有一個用戶，那麼這是划算的。如果應用程式可以使用電腦的所有能力從而變得更加高效，而且這種能力只為運行程式的唯一用戶服務，這是好事。

接下來看看第二種情況。如果程式運行在伺服器端，則是完全不同的情形。可伸縮性是最高優先順序，這意味著單個用戶消耗越少的資源越好。如果為每個用戶創建多個線程，則可伸縮性並不好。以高效的方式來平衡應用程式資源的消耗是個非常複雜的問題。例如，在ASP.NET中，我們使用工作線程池來服務客戶端請求。這個池的工作線程是有限的，所以不得不最小化每個工作線程的使用時間以便達到高伸縮性。這意味著需要把工作線程越快越好地放回到池中，從而可以服務下一個請求。如果我們啟動了一個需要計算的非同步操作，則整個工作流程會很低效。首先從線程池中取出一個工作線程用以服務客戶端請求。然後取出另一個工作線程並開始處理非同步操作。現在有兩個工作線程都在處理請求，如果第一個線程能做些有用的事則非常好。可惜，通常情況下，我們簡單等待非同步操作完成，但是我們卻消費了兩個工作線程，而不是一個。在這個場景中，非同步比同步執行實際上更糟糕！我們不需要使用所有CPU核心，因為我們已經在服務很多客戶端，它們已經使用了CPU的所有計算能力。我們無須保持第一個線程響應，因為這沒有用戶界面。那麼為什麼我們應該在服務端使用非同步呢？

答案是只有非同步輸入/輸出操作才應用使用非同步。目前，現代電腦通過有一個磁碟驅動器來存儲文件，一塊網卡來通過網路發送與接收數據。所有這些設備都有自己的晶元，以非常底層的方式來管理輸入/輸出操作併發信號給操作系統。這種執行I/O任務的方式被稱為I/O線程。

在ASP.NET中，一旦有一個非同步的I/O操作在工作線程開始時，它會被立即返回到線程池中。當這個操作繼續運行時，這個線程可以服務其他的客戶端。最終，當操作發出信號完成時，ASP.NET基礎設施從線程池中獲取一個空閑的工作線程，然後會完成這個操作。

一、非同步使用文件

本救命學習如何使用非同步的方式讀寫一個文件。

1.示例代碼如下。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ThreadIODemo
{
    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine("--開始 使用 非同步 I/O 線程 -- ");
            var t = ReadWriteAsyncIO();
            t.GetAwaiter().GetResult();
            Console.Read();
        }

        const int BUFFER_SIZE = 4096;

        async static Task ReadWriteAsyncIO()
        {

            using (var fs = new FileStream("test1.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None, BUFFER_SIZE))
            {

                Console.WriteLine("1. 使用 I/O 線程 是否非同步：{0}",fs.IsAsync);
                byte[] buffer = Encoding.UTF8.GetBytes(CreateFileContent());

                var writeTask = Task.Factory.FromAsync(fs.BeginWrite, fs.EndWrite, buffer, 0, buffer.Length, null);
                await writeTask;

            }

            using (var fs = new FileStream("test2.txt", FileMode.Create, FileAccess.ReadWrite, FileShare.None,
 BUFFER_SIZE, FileOptions.Asynchronous))
            {

                Console.WriteLine("2. 使用 I/O 線程 是否非同步：{0}",fs.IsAsync);
                byte[] buffer = Encoding.UTF8.GetBytes(CreateFileContent());
                var writeTask = Task.Factory.FromAsync(fs.BeginWrite, fs.EndWrite, buffer, 0, buffer.Length, null);
                await writeTask;
            }

 

            using (var fs = File.Create("test3.txt", BUFFER_SIZE, FileOptions.Asynchronous))
            {

                using (var sw = new StreamWriter(fs))
                {
                    Console.WriteLine("3. 使用 I/O 線程 是否非同步：{0}",fs.IsAsync);
                    await sw.WriteAsync(CreateFileContent());
                }
            }

            using (var sw = new StreamWriter("test4.txt", true))
            {

                Console.WriteLine("4. 使用 I/O 線程 是否非同步：{0}",((FileStream)sw.BaseStream).IsAsync);
                await sw.WriteAsync(CreateFileContent());
            }

            System.Threading.Thread.Sleep(1000);
            Console.WriteLine("開始非同步讀取文件"); 

            Task<long>[] readTasks = new Task<long>[4];
            for (int i = 0; i < 4; i++)
            {

                readTasks[i] = SumFileContent(string.Format("test{0}.txt",i + 1));

            }

            long[] sums = await Task.WhenAll(readTasks);
            Console.WriteLine("所有文件中的和值：{0}", sums.Sum()); 

            Console.WriteLine("開始刪除文件");
            Task[] delTasks = new Task[4];
            for (int i = 0; i < 4; i++)
            {

                string filename = string.Format("test{0}.txt",i + 1);
                delTasks[i] = SimulateAsynchronousDelete(filename);

            }

            await Task.WhenAll(delTasks);
            Console.WriteLine("刪除文件結束");
        } 

        static string CreateFileContent()
        {
            var sb = new StringBuilder();
            for (int i = 0; i < 100000; i++)
            {
                sb.AppendFormat("{0}", new Random(i).Next(0, 99999));
                sb.AppendLine();
            }
            return sb.ToString();
        }

        async static Task<long> SumFileContent(string filename)
        {
            using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.None, BUFFER_SIZE, FileOptions.Asynchronous))
            using (var sr = new StreamReader(fs))
            {

                long sum = 0;
                while (sr.Peek() > -1)
                {
                    string line = await sr.ReadLineAsync();
                    sum += long.Parse(line);
                }
                return sum;
            }
        } 

        static Task SimulateAsynchronousDelete(string filename)
        {
            return Task.Run(() => File.Delete(filename));
        }

    }
}

2.程式運行結果，如下圖。

當程式運行時，我們以不同的方式創建了4個文件，並寫入一些隨機數據。

在第一個例子中，使用的是FileStream類以及其方式，將非同步編程模式API轉換成任務。

在第二個例子中，使用的是FileStream類以及其方式，不過在構造的時候提供了FileStream.Asynchronous參數。

在第三個例子使用了一些簡化的API，比如File.Create方法和StreamWrite類。它也使用I/O線程，我們可以使用Stream.iSaSYNC屬性來檢查。

在第四個例子說明瞭過分簡化也不好。這裡我們藉助非同步委托調用來模擬非同步I/O，其實並沒有使用非同步I/O。

然後並行地非同步地從所有文件中讀取數據，統計每個文件內容，然後求總和。

最後，刪除所有文件。