首頁 > 軟體

C#非同步的世界(上)

2021-04-26 19:00:50

前言

新進階的程式設計師可能對async、await用得比較多，卻對之前的非同步瞭解甚少。本人就是此類，因此打算回顧學習下非同步的進化史。

本文主要是回顧async非同步模式之前的非同步，下篇文章再來重點分析async非同步模式。

APM

APM 非同步程式設計模型，Asynchronous Programming Model

早在C#1的時候就有了APM。雖然不是很熟悉，但是多少還是見過的。就是那些類是BeginXXX和EndXXX的方法，且BeginXXX返回值是IAsyncResult介面。

在正式寫APM範例之前我們先給出一段同步程式碼：

//1、同步方法
private void button1_Click(object sender, EventArgs e)
{          
    Debug.WriteLine("【Debug】執行緒ID:" + Thread.CurrentThread.ManagedThreadId);

    var request = WebRequest.Create("https://github.com/");//為了更好的演示效果，我們使用網速比較慢的外網
    request.GetResponse();//傳送請求    

    Debug.WriteLine("【Debug】執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
    label1.Text = "執行完畢！";
}

【說明】為了更好的演示非同步效果，這裡我們使用winform程式來做範例。（因為winform始終都需要UI執行緒渲染介面，如果被UI執行緒佔用則會出現「假死」狀態）

【效果圖】

看圖得知：

我們在執行方法的時候頁面出現了「假死」，拖不動了。

我們看到列印結果，方法呼叫前和呼叫後執行緒ID都是9（也就是同一個執行緒）

下面我們再來演示對應的非同步方法：（BeginGetResponse、EndGetResponse所謂的APM非同步模型）

private void button2_Click(object sender, EventArgs e)
{
    //1、APM 非同步程式設計模型，Asynchronous Programming Model
    //C#1[基於IAsyncResult介面實現BeginXXX和EndXXX的方法]             
    Debug.WriteLine("【Debug】主執行緒ID:" + Thread.CurrentThread.ManagedThreadId);

    var request = WebRequest.Create("https://github.com/");
    request.BeginGetResponse(new AsyncCallback(t =>//執行完成後的回撥
    {
        var response = request.EndGetResponse(t);
        var stream = response.GetResponseStream();//獲取返回資料流 

        using (StreamReader reader = new StreamReader(stream))
        {
            StringBuilder sb = new StringBuilder();
            while (!reader.EndOfStream)
            {
                var content = reader.ReadLine();
                sb.Append(content);
            }
            Debug.WriteLine("【Debug】" + sb.ToString().Trim().Substring(0, 100) + "...");//只取返回內容的前100個字元 
            Debug.WriteLine("【Debug】非同步執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
            label1.Invoke((Action)(() => { label1.Text = "執行完畢！"; }));//這裡跨執行緒存取UI需要做處理
        }
    }), null);

    Debug.WriteLine("【Debug】主執行緒ID:" + Thread.CurrentThread.ManagedThreadId); 
}

【效果圖】

看圖得知：

  • 啟用非同步方法並沒有是UI介面卡死
  • 非同步方法啟動了另外一個ID為12的執行緒

上面程式碼執行順序：

前面我們說過，APM的BebinXXX必須返回IAsyncResult介面。那麼接下來我們分析IAsyncResult介面：

首先我們看：

確實返回的是IAsyncResult介面。那IAsyncResult到底長的什麼樣子？：

並沒有想象中的那麼複雜嘛。我們是否可以嘗試這實現這個介面，然後顯示自己的非同步方法呢？

首先定一個類MyWebRequest，然後繼承IAsyncResult：（下面是基本的虛擬碼實現）

public class MyWebRequest : IAsyncResult
{
    public object AsyncState
    {
        get { throw new NotImplementedException(); }
    }

    public WaitHandle AsyncWaitHandle
    {
        get { throw new NotImplementedException(); }
    }

    public bool CompletedSynchronously
    {
        get { throw new NotImplementedException(); }
    }

    public bool IsCompleted
    {
        get { throw new NotImplementedException(); }
    }
}

這樣肯定是不能用的，起碼也得有個存回撥函數的屬性吧，下面我們稍微改造下：

然後我們可以自定義APM非同步模型了：（成對的Begin、End）

public IAsyncResult MyBeginXX(AsyncCallback callback)
{
    var asyncResult = new MyWebRequest(callback, null);
    var request = WebRequest.Create("https://github.com/");
    new Thread(() =>  //重新啟用一個執行緒
    {
        using (StreamReader sr = new StreamReader(request.GetResponse().GetResponseStream()))
        {
            var str = sr.ReadToEnd();
            asyncResult.SetComplete(str);//設定非同步結果
        }

    }).Start();
    return asyncResult;//返回一個IAsyncResult
}

public string MyEndXX(IAsyncResult asyncResult)
{
    MyWebRequest result = asyncResult as MyWebRequest;
    return result.Result;
}

呼叫如下:

private void button4_Click(object sender, EventArgs e)
 {
     Debug.WriteLine("【Debug】主執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
     MyBeginXX(new AsyncCallback(t =>
     {
         var result = MyEndXX(t);
         Debug.WriteLine("【Debug】" + result.Trim().Substring(0, 100) + "...");
         Debug.WriteLine("【Debug】非同步執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
     }));
     Debug.WriteLine("【Debug】主執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
 }

效果圖：

我們看到自己實現的效果基本上和系統提供的差不多。

  • 啟用非同步方法並沒有是UI介面卡死
  • 非同步方法啟動了另外一個ID為11的執行緒

【總結】

個人覺得APM非同步模式就是啟用另外一個執行緒執行耗時任務，然後通過回撥函數執行後續操作。

APM還可以通過其他方式獲取值，如：

while (!asyncResult.IsCompleted)//迴圈，直到非同步執行完成 (輪詢方式)
{
    Thread.Sleep(100);
}
var stream2 = request.EndGetResponse(asyncResult).GetResponseStream();

或

asyncResult.AsyncWaitHandle.WaitOne();//阻止執行緒，直到非同步完成 （阻塞等待）
var stream2 = request.EndGetResponse(asyncResult).GetResponseStream();

補充：如果是普通方法，我們也可以通過委託非同步：（BeginInvoke、EndInvoke）

public void MyAction()
 {
     var func = new Func<string, string>(t =>
     {
         Thread.Sleep(2000);
         return "name:" + t + DateTime.Now.ToString();
     });
 
     var asyncResult = func.BeginInvoke("張三", t =>
     {
         string str = func.EndInvoke(t);
         Debug.WriteLine(str);
     }, null); 
 }

EAP

EAP 基於事件的非同步模式，Event-based Asynchronous Pattern

此模式在C#2的時候隨之而來。

先來看個EAP的例子：

private void button3_Click(object sender, EventArgs e)
 {            
     Debug.WriteLine("【Debug】主執行緒ID:" + Thread.CurrentThread.ManagedThreadId);

     BackgroundWorker worker = new BackgroundWorker();
     worker.DoWork += new DoWorkEventHandler((s1, s2) =>
     {
         Thread.Sleep(2000);
         Debug.WriteLine("【Debug】非同步執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
     });//註冊事件來實現非同步
     worker.RunWorkerAsync(this);
     Debug.WriteLine("【Debug】主執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
 }

【效果圖】（同樣不會阻塞UI介面）

【特徵】

  • 通過事件的方式註冊回撥函數
  • 通過 XXXAsync方法來執行非同步呼叫

例子很簡單，但是和APM模式相比，是不是沒有那麼清晰透明。為什麼可以這樣實現？事件的註冊是在幹嘛？為什麼執行RunWorkerAsync會觸發註冊的函數？

感覺自己又想多了...

我們試著反編譯看看原始碼：

只想說，這麼玩，有意思嗎？

TAP

TAP 基於任務的非同步模式，Task-based Asynchronous Pattern

到目前為止，我們覺得上面的APM、EAP非同步模式好用嗎？好像沒有發現什麼問題。再仔細想想...如果我們有多個非同步方法需要按先後順序執行，並且需要(在主程序)得到所有返回值。

首先定義三個委託：

public Func<string, string> func1()
{
    return new Func<string, string>(t =>
    {
        Thread.Sleep(2000);
        return "name:" + t;
    });
}
public Func<string, string> func2()
{
    return new Func<string, string>(t =>
    {
        Thread.Sleep(2000);
        return "age:" + t;
    });
}
public Func<string, string> func3()
{
    return new Func<string, string>(t =>
    {
        Thread.Sleep(2000);
        return "sex:" + t;
    });
}

然後按照一定順序執行：

public void MyAction()
{
    string str1 = string.Empty, str2 = string.Empty, str3 = string.Empty;
    IAsyncResult asyncResult1 = null, asyncResult2 = null, asyncResult3 = null;
    asyncResult1 = func1().BeginInvoke("張三", t =>
    {
        str1 = func1().EndInvoke(t);
        Debug.WriteLine("【Debug】非同步執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
        asyncResult2 = func2().BeginInvoke("26", a =>
        {
            str2 = func2().EndInvoke(a);
            Debug.WriteLine("【Debug】非同步執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
            asyncResult3 = func3().BeginInvoke("男", s =>
            {
                str3 = func3().EndInvoke(s);
                Debug.WriteLine("【Debug】非同步執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
            }, null);
        }, null);
    }, null);

    asyncResult1.AsyncWaitHandle.WaitOne();
    asyncResult2.AsyncWaitHandle.WaitOne();
    asyncResult3.AsyncWaitHandle.WaitOne();
    Debug.WriteLine(str1 + str2 + str3);
}

除了難看、難讀一點好像也沒什麼 。不過真的是這樣嗎？

asyncResult2是null?

由此可見在完成第一個非同步操作之前沒有對asyncResult2進行賦值，asyncResult2執行非同步等待的時候報異常。那麼如此我們就無法控制三個非同步函數，按照一定順序執行完成後再拿到返回值。（理論上還是有其他辦法的，只是會然程式碼更加複雜）

是的，現在該我們的TAP登場了。

只需要呼叫Task類的靜態方法Run，即可輕輕鬆鬆使用非同步。

獲取返回值：

var task1 = Task<string>.Run(() =>
{
    Thread.Sleep(1500);
    Console.WriteLine("【Debug】task1 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
    return "張三";
});
//其他邏輯            
task1.Wait();
var value = task1.Result;//獲取返回值
Console.WriteLine("【Debug】主 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);

現在我們處理上面多個非同步按序執行：

Console.WriteLine("【Debug】主 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
string str1 = string.Empty, str2 = string.Empty, str3 = string.Empty;
var task1 = Task.Run(() =>
{
    Thread.Sleep(500);
    str1 = "姓名：張三,";
    Console.WriteLine("【Debug】task1 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
}).ContinueWith(t =>
{
    Thread.Sleep(500);
    str2 = "年齡：25,";
    Console.WriteLine("【Debug】task2 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
}).ContinueWith(t =>
{
    Thread.Sleep(500);
    str3 = "愛好：妹子";
    Console.WriteLine("【Debug】task3 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);
});

Thread.Sleep(2500);//其他邏輯程式碼

task1.Wait();

Debug.WriteLine(str1 + str2 + str3);
Console.WriteLine("【Debug】主 執行緒ID:" + Thread.CurrentThread.ManagedThreadId);

[效果圖]

我們看到，結果都得到了，且是非同步按序執行的。且程式碼的邏輯思路非常清晰。如果你感受還不是很大，那麼你現象如果是100個非同步方法需要非同步按序執行呢？用APM的非同步回撥，那至少也得非同步回撥巢狀100次。那程式碼的複雜度可想而知。

延伸思考

  • WaitOne完成等待的原理
  • 非同步為什麼會提升效能
  • 執行緒的使用數量和CPU的使用率有必然的聯絡嗎

問題1：WaitOne完成等待的原理

在此之前，我們先來簡單的瞭解下多執行緒訊號控制AutoResetEvent類。

var _asyncWaitHandle = new AutoResetEvent(false);
_asyncWaitHandle.WaitOne();

此程式碼會在WaitOne的地方會一直等待下去。除非有另外一個執行緒執行AutoResetEvent的set方法。

var _asyncWaitHandle = new AutoResetEvent(false);
_asyncWaitHandle.Set();
_asyncWaitHandle.WaitOne();

如此，到了WaitOne就可以直接執行下去。沒有有任何等待。

現在我們對APM 非同步程式設計模型中的WaitOne等待是不是知道了點什麼呢。我們回頭來實現之前自定義非同步方法的非同步等待。

public class MyWebRequest : IAsyncResult
{
    //非同步回撥函數（委託）
    private AsyncCallback _asyncCallback;
    private AutoResetEvent _asyncWaitHandle;
    public MyWebRequest(AsyncCallback asyncCallback, object state)
    {
        _asyncCallback = asyncCallback;
        _asyncWaitHandle = new AutoResetEvent(false);
    }
    //設定結果
    public void SetComplete(string result)
    {
        Result = result;
        IsCompleted = true;
        _asyncWaitHandle.Set();
        if (_asyncCallback != null)
        {
            _asyncCallback(this);
        }
    }
    //非同步請求返回值
    public string Result { get; set; }
    //獲取使用者定義的物件，它限定或包含關於非同步操作的資訊。
    public object AsyncState
    {
        get { throw new NotImplementedException(); }
    }
    // 獲取用於等待非同步操作完成的 System.Threading.WaitHandle。
    public WaitHandle AsyncWaitHandle
    {
        //get { throw new NotImplementedException(); }

        get { return _asyncWaitHandle; }
    }
    //獲取一個值，該值指示非同步操作是否同步完成。
    public bool CompletedSynchronously
    {
        get { throw new NotImplementedException(); }
    }
    //獲取一個值，該值指示非同步操作是否已完成。
    public bool IsCompleted
    {
        get;
        private set;
    }
}

紅色程式碼就是新增的非同步等待。

【執行步驟】

問題2：非同步為什麼會提升效能

比如同步程式碼：

Thread.Sleep(10000);//假設這是個存取資料庫的方法
Thread.Sleep(10000);//假設這是個存取翻牆網站的方法

這個程式碼需要20秒。

如果是非同步：

var task = Task.Run(() =>
{
    Thread.Sleep(10000);//假設這是個存取資料庫的方法
});
Thread.Sleep(10000);//假設這是個存取翻牆網站的方法
task.Wait();

如此就只要10秒了。這樣就節約了10秒。

如果是：

var task = Task.Run(() =>
{
    Thread.Sleep(10000);//假設這是個存取資料庫的方法
}); 
task.Wait();

非同步執行中間沒有耗時的程式碼那麼這樣的非同步將是沒有意思的。

或者：

var task = Task.Run(() =>
{
    Thread.Sleep(10000);//假設這是個存取資料庫的方法
}); 
task.Wait();
Thread.Sleep(10000);//假設這是個存取翻牆網站的方法

把耗時任務放在非同步等待後，那這樣的程式碼也是不會有效能提升的。

還有一種情況：

如果是單核CPU進行高密集運算操作，那麼非同步也是沒有意義的。(因為運算是非常耗CPU,而網路請求等待不耗CPU)

問題3：執行緒的使用數量和CPU的使用率有必然的聯絡嗎

答案是否。

還是拿單核做假設。

情況1：

long num = 0;
while (true)
{
    num += new Random().Next(-100,100);
    //Thread.Sleep(100);
}

單核下，我們只啟動一個執行緒，就可以讓你CPU爆滿。

啟動八次，八程序CPU基本爆滿。

情況2：

一千多個執行緒，而CPU的使用率竟然是0。由此，我們得到了之前的結論，執行緒的使用數量和CPU的使用率沒有必然的聯絡。

雖然如此，但是也不能毫無節制的開啟執行緒。因為：

  • 開啟一個新的執行緒的過程是比較耗資源的。（可是使用執行緒池，來降低開啟新執行緒所消耗的資源）
  • 多執行緒的切換也是需要時間的。
  • 每個執行緒佔用了一定的記憶體儲存執行緒上下文資訊。

以上就是C#非同步的世界(上)的詳細內容，更多關於C#非同步的世界的資料請關注it145.com其它相關文章！


相關文章

IT145.com E-mail:sddin#qq.com