C#異步的世界【上】。本站提示廣大學習愛好者：（C#異步的世界【上】）文章只能為提供參考，不一定能成為您想要的結果。以下是C#異步的世界【上】正文
新進階的順序員能夠對async、await用得比擬多，卻對之前的異步理解甚少。自己就是此類，因而計劃回憶學習下異步的退化史。
本文次要是回憶async異步形式之前的異步，下篇文章再來重點剖析async異步形式。
APMAPM 異步編程模型，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線程占用則會呈現“假死”形態）
【效果圖】
看圖得知：
上面我們再來演示對應的異步辦法：（BeginGetResponse、EndOfStream 所謂的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);
}
【效果圖】
看圖得知：
下面代碼執行順序：
後面我們說過，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);
}
效果圖：
我們看到自己完成的效果根本上和零碎提供的差不多。
【總結】
團體覺得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界面）
【特征】
例子很復雜，但是和APM形式相比，是不是沒有那麼明晰通明。為什麼可以這樣完成？事情的注冊是在干嘛？為什麼執行RunWorkerAsync會觸發注冊的函數？
覺得自己又想多了...
我們試著反編譯看看源碼：
只想說，這麼玩，有意思嗎？
TAPTAP 基於義務的異步形式，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);//假定這是個訪問FQ網站的辦法
這個代碼需求20秒。
假如是異步：
var task = Task.Run(() =>
{
Thread.Sleep(10000);//假定這是個訪問數據庫的辦法
});
Thread.Sleep(10000);//假定這是個訪問FQ網站的辦法
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);//假定這是個訪問FQ網站的辦法
把耗時義務放在異步等候後，那這樣的代碼也是不會有功能提升的。
還有一種狀況：
假如是單核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的運用率沒有必定的聯絡。
雖然如此，但是也不能毫無節制的開啟線程。由於：
demo：http://pan.baidu.com/s/1slOxgnF
原文鏈接：http://www.cnblogs.com/zhaopei/p/async_one.html
關於異步編程理解不深，文中極有能夠多處錯誤描繪和觀念。
感激廣闊園友的指正。
本著互相討論的目的，絕無想要誤導大家的意思。
【引薦】
http://www.cnblogs.com/wisdomqq/archive/2012/03/26/2412349.html
