{"id":7089,"date":"2023-09-28T08:40:26","date_gmt":"2023-09-28T00:40:26","guid":{"rendered":"https:\/\/i007.vip:15443\/wordpress\/?p=7089"},"modified":"2023-09-28T08:40:26","modified_gmt":"2023-09-28T00:40:26","slug":"c-task%e8%af%a6%e8%a7%a3","status":"publish","type":"post","link":"https:\/\/i007.cc\/wordpress\/archives\/7089","title":{"rendered":"C# Task\u8be6\u89e3"},"content":{"rendered":"

cc from<\/a><\/p>\n

 <\/p>\n

\u5c0f\u84dd\u6ce2<\/p>\n

\u4e8e 2023-03-03 16:25:53 \u53d1\u5e03<\/p>\n

3991
\n\u6536\u85cf 26
\n\u6587\u7ae0\u6807\u7b7e\uff1a c# \u5f00\u53d1\u8bed\u8a00
\n\u7248\u6743
\n1\u3001Task\u4ea7\u751f\u80cc\u666f
\nTask\u51fa\u73b0\u4e4b\u524d\uff0c\u5fae\u8f6f\u7684\u591a\u7ebf\u7a0b\u5904\u7406\u65b9\u5f0f\u6709\uff1aThread\u2192ThreadPool\u2192\u59d4\u6258\u7684\u5f02\u6b65\u8c03\u7528\uff0c\u867d\u7136\u4e5f\u53ef\u4ee5\u57fa\u672c\u4e1a\u52a1\u9700\u8981\u7684\u591a\u7ebf\u7a0b\u573a\u666f\uff0c\u4f46\u5b83\u4eec\u5728\u591a\u4e2a\u7ebf\u7a0b\u7684\u7b49\u5f85\u5904\u7406\u65b9\u9762\u3001\u8d44\u6e90\u5360\u7528\u65b9\u9762\u3001\u7ebf\u7a0b\u5ef6\u7eed\u548c\u963b\u585e\u65b9\u9762\u3001\u7ebf\u7a0b\u7684\u53d6\u6d88\u65b9\u9762\u7b49\u90fd\u663e\u5f97\u6bd4\u8f83\u7b28\u62d9\uff0c\u5728\u9762\u5bf9\u590d\u6742\u7684\u4e1a\u52a1\u573a\u666f\u4e0b\uff0c\u663e\u5f97\u6709\u70b9\u6349\u895f\u89c1\u8098\u4e86\u3002<\/p>\n

ThreadPool\u76f8\u6bd4Thread\u6765\u8bf4\u5177\u5907\u4e86\u5f88\u591a\u4f18\u52bf\uff0c\u4f46\u662fThreadPool\u5374\u53c8\u5b58\u5728\u4e00\u4e9b\u4f7f\u7528\u4e0a\u7684\u4e0d\u65b9\u4fbf\u3002\u6bd4\u5982\uff1a<\/p>\n

ThreadPool\u4e0d\u652f\u6301\u7ebf\u7a0b\u7684\u53d6\u6d88\u3001\u5b8c\u6210\u3001\u5931\u8d25\u901a\u77e5\u7b49\u4ea4\u4e92\u6027\u64cd\u4f5c\uff1b
\nThreadPool\u4e0d\u652f\u6301\u7ebf\u7a0b\u6267\u884c\u7684\u5148\u540e\u6b21\u5e8f\uff1b
\n\u6b63\u662f\u5728\u8fd9\u79cd\u80cc\u666f\u4e0b\uff0cTask\u5e94\u8fd0\u800c\u751f\u3002Task\u662f\u5fae\u8f6f\u5728.Net 4.0\u65f6\u4ee3\u63a8\u51fa\u6765\u7684\uff0c\u4e5f\u662f\u5fae\u8f6f\u6781\u529b\u63a8\u8350\u7684\u4e00\u79cd\u591a\u7ebf\u7a0b\u7684\u5904\u7406\u65b9\u5f0f\uff0cTask\u770b\u8d77\u6765\u50cf\u4e00\u4e2aThread\uff0c\u5b9e\u9645\u4e0a\uff0c\u5b83\u662f\u5728ThreadPool\u7684\u57fa\u7840\u4e0a\u8fdb\u884c\u7684\u5c01\u88c5\uff0cTask\u7684\u63a7\u5236\u548c\u6269\u5c55\u6027\u5f88\u5f3a\uff0c\u5728\u7ebf\u7a0b\u7684\u5ef6\u7eed\u3001\u963b\u585e\u3001\u53d6\u6d88\u3001\u8d85\u65f6\u7b49\u65b9\u9762\u8fdc\u80dc\u4e8eThread\u548cThreadPool\u3002\u4ee5\u4e0b\u662f\u4e00\u4e2a\u7b80\u5355\u7684\u4efb\u52a1\u793a\u4f8b\uff1a<\/p>\n

static void Main(string[] args)
\n{
\nTask t = new Task(() =>
\n{
\nConsole.WriteLine(“\u4efb\u52a1\u5f00\u59cb\u5de5\u4f5c\u2026\u2026”);
\nThread.Sleep(5000); \/\/\u6a21\u62df\u5de5\u4f5c\u8fc7\u7a0b
\n});
\nt.Start();
\nt.ContinueWith(task =>
\n{
\nConsole.WriteLine(“\u4efb\u52a1\u5b8c\u6210\uff0c\u5b8c\u6210\u65f6\u5019\u7684\u72b6\u6001\u4e3a\uff1a”);
\nConsole.WriteLine(“IsCanceled={0}\\tIsCompleted={1}\\tIsFaulted={2}”,
\ntask.IsCanceled, task.IsCompleted, task.IsFaulted);
\n});
\nConsole.ReadKey();
\n}
\n2\u3001Task\u4f7f\u7528\u65b9\u6cd5
\n2.1\u3000\u521b\u5efa\u548c\u542f\u52a8\u4efb\u52a1
\n2.1.1 \u65e0\u8fd4\u56de\u503c\u7684\u65b9\u5f0f<\/p>\n

\u65b9\u5f0f1:\u8c03\u7528Start\u65b9\u6cd5<\/p>\n

var t1 = new Task(() => TaskMethod(“Task 1”));
\nt1.Start();
\nTask.WaitAll(t1);\/\/\u7b49\u5f85\u6240\u6709\u4efb\u52a1\u7ed3\u675f
\n\u4efb\u52a1\u7684\u72b6\u6001\uff1aStart\u4e4b\u524d\u4e3aCreated\uff0c\u4e4b\u540e\u4e3aWaitingToRun<\/p>\n

\u65b9\u5f0f2:\u9759\u6001\u65b9\u6cd5Run<\/p>\n

Task.Run(() => TaskMethod(“Task 2”));
\n\u65b9\u5f0f3:TaskFactory\u5de5\u5382<\/p>\n

\/\/ \u65b9\u6cd51. TaskFactory\u5de5\u5382
\nTaskFactory taskFactory = new TaskFactory() ;
\ntaskFactory.StartNew(() => TaskMethod(“Task 3”));
\n\/\/ \u65b9\u6cd52. Task.Factory\u5c5e\u6027
\nTask.Factory.StartNew(() => TaskMethod(“Task 3”));
\n\/\/\u6216\u8005
\nvar t3=Task.Factory.StartNew(() => TaskMethod(“Task 3”));
\nTask.WaitAll(t3);
\n\u4efb\u52a1\u7684\u72b6\u6001\uff1aStart\u4e4b\u524d\u4e3aRunning\uff0c\u4e4b\u540e\u4e3aRunning<\/p>\n

static void Main(string[] args)
\n{
\nvar t1 = new Task(() => TaskMethod(“Task 1”));
\nvar t2 = new Task(() => TaskMethod(“Task 2”));
\nt2.Start();
\nt1.Start();
\nTask.WaitAll(t1, t2);
\nTask.Run(() => TaskMethod(“Task 3”));
\nTask.Factory.StartNew(() => TaskMethod(“Task 4”));
\n\/\/\u6807\u8bb0\u4e3a\u957f\u65f6\u95f4\u8fd0\u884c\u4efb\u52a1,\u5219\u4efb\u52a1\u4e0d\u4f1a\u4f7f\u7528\u7ebf\u7a0b\u6c60,\u800c\u5728\u5355\u72ec\u7684\u7ebf\u7a0b\u4e2d\u8fd0\u884c\u3002
\nTask.Factory.StartNew(() => TaskMethod(“Task 5”), TaskCreationOptions.LongRunning);<\/p>\n

#region \u5e38\u89c4\u7684\u4f7f\u7528\u65b9\u5f0f
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u4e1a\u52a1\u5904\u7406.”);
\n\/\/\u521b\u5efa\u4efb\u52a1
\nTask task = new Task(() =>
\n{
\nConsole.WriteLine(“\u4f7f\u7528`System.Threading.Tasks.Task`\u6267\u884c\u5f02\u6b65\u64cd\u4f5c.”);
\nfor (int i = 0; i < 10; i++)
\n{
\nConsole.WriteLine(i);
\n}
\n});
\n\/\/\u542f\u52a8\u4efb\u52a1,\u5e76\u5b89\u6392\u5230\u5f53\u524d\u4efb\u52a1\u961f\u5217\u7ebf\u7a0b\u4e2d\u6267\u884c\u4efb\u52a1(System.Threading.Tasks.TaskScheduler)
\ntask.Start();
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u5176\u4ed6\u5904\u7406”);
\ntask.Wait();
\n#endregion<\/p>\n

Thread.Sleep(TimeSpan.FromSeconds(1));
\nConsole.ReadLine();
\n}<\/p>\n

static void TaskMethod(string name)
\n{
\nConsole.WriteLine(“Task {0} is running on a thread id {1}. Is thread pool thread: {2}”,
\nname, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
\n}
\n\u65b9\u5f0f4:RunSynchronously\u540c\u6b65\u542f\u52a8<\/p>\n

Task\u5b9e\u4f8b\u5316\u540e\u8c03\u7528\u540c\u6b65\u65b9\u6cd5RunSynchronously\uff0c\u8fdb\u884c\u7ebf\u7a0b\u542f\u52a8\u3002(PS: \u7c7b\u4f3c\u59d4\u6258\u5f00\u542f\u7ebf\u7a0b\uff0cBeginInvoke\u662f\u5f02\u6b65\uff0c\u800cInvoke\u662f\u540c\u6b65)<\/p>\n

var task = new Task(() => TaskMethod(“Task 1”));
\ntask.RunSynchronously();
\nasync\/await\u7684\u5b9e\u73b0\u65b9\u5f0f<\/p>\n

using System;
\nusing System.Threading;
\nusing System.Threading.Tasks;<\/p>\n

namespace ConsoleApp1
\n{
\nclass Program
\n{
\nasync static void AsyncFunction()
\n{
\nawait Task.Delay(1);
\nConsole.WriteLine(“\u4f7f\u7528`System.Threading.Tasks.Task`\u6267\u884c\u5f02\u6b65\u64cd\u4f5c.”);
\nfor (int i = 0; i < 10; i++)
\n{
\nConsole.WriteLine(string.Format(“AsyncFunction:i={0}”, i));
\n}
\n}<\/p>\n

public static void Main()
\n{
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u4e1a\u52a1\u5904\u7406.”);
\nAsyncFunction();
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u5176\u4ed6\u5904\u7406”);
\nfor (int i = 0; i < 10; i++)
\n{
\nConsole.WriteLine(string.Format(“Main:i={0}”, i));
\n}
\nConsole.ReadLine();
\n}
\n}
\n}
\n2.1.2 \u5e26\u8fd4\u56de\u503c\u7684\u65b9\u5f0f<\/p>\n

\u65b9\u5f0f4:<\/p>\n

Task<int> task = CreateTask(“Task 1”);
\ntask.Start();
\nint result = task.Result;
\nusing System;
\nusing System.Threading;
\nusing System.Threading.Tasks;<\/p>\n

namespace ConsoleApp1
\n{
\nclass Program
\n{
\nstatic Task<int> CreateTask(string name)
\n{
\nreturn new Task<int>(() => TaskMethod(name));
\n}<\/p>\n

static void Main(string[] args)
\n{
\nTaskMethod(“Main Thread Task”);
\nTask<int> task = CreateTask(“Task 1”);
\ntask.Start();
\nint result = task.Result;
\nConsole.WriteLine(“Task 1 Result is: {0}”, result);<\/p>\n

task = CreateTask(“Task 2”);
\ntask.RunSynchronously(); \/\/\u8be5\u4efb\u52a1\u4f1a\u8fd0\u884c\u5728\u4e3b\u7ebf\u7a0b\u4e2d
\nresult = task.Result;
\nConsole.WriteLine(“Task 2 Result is: {0}”, result);<\/p>\n

task = CreateTask(“Task 3”);
\nConsole.WriteLine(task.Status);
\ntask.Start();<\/p>\n

while (!task.IsCompleted)
\n{
\nConsole.WriteLine(task.Status);
\nThread.Sleep(TimeSpan.FromSeconds(0.5));
\n}<\/p>\n

Console.WriteLine(task.Status);
\nresult = task.Result;
\nConsole.WriteLine(“Task 3 Result is: {0}”, result);<\/p>\n

#region \u5e38\u89c4\u4f7f\u7528\u65b9\u5f0f
\n\/\/\u521b\u5efa\u4efb\u52a1
\nTask<int> getsumtask = new Task<int>(() => Getsum());
\n\/\/\u542f\u52a8\u4efb\u52a1,\u5e76\u5b89\u6392\u5230\u5f53\u524d\u4efb\u52a1\u961f\u5217\u7ebf\u7a0b\u4e2d\u6267\u884c\u4efb\u52a1(System.Threading.Tasks.TaskScheduler)
\ngetsumtask.Start();
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u5176\u4ed6\u5904\u7406”);
\ngetsumtask.Wait(); \/\/\u7b49\u5f85\u4efb\u52a1\u7684\u5b8c\u6210\u6267\u884c\u8fc7\u7a0b
\nConsole.WriteLine(“\u4efb\u52a1\u6267\u884c\u7ed3\u679c\uff1a{0}”, getsumtask.Result.ToString());\/\/\u83b7\u5f97\u4efb\u52a1\u7684\u6267\u884c\u7ed3\u679c
\n#endregion
\n}<\/p>\n

static int TaskMethod(string name)
\n{
\nConsole.WriteLine(“Task {0} is running on a thread id {1}. Is thread pool thread: {2}”,
\nname, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
\nThread.Sleep(TimeSpan.FromSeconds(2));
\nreturn 42;
\n}<\/p>\n

static int Getsum()
\n{
\nint sum = 0;
\nConsole.WriteLine(“\u4f7f\u7528`Task`\u6267\u884c\u5f02\u6b65\u64cd\u4f5c.”);
\nfor (int i = 0; i < 100; i++)
\n{
\nsum += i;
\n}
\nreturn sum;
\n}
\n}
\n}
\nusing System;
\nusing System.Threading.Tasks;<\/p>\n

namespace ConsoleApp1
\n{
\nclass Program
\n{
\npublic static void Main()
\n{
\nvar ret1 = AsyncGetsum();
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u5176\u4ed6\u5904\u7406”);
\nfor (int i = 1; i <= 3; i++)
\nConsole.WriteLine(“Call Main()”);
\nint result = ret1.Result; \/\/\u963b\u585e\u4e3b\u7ebf\u7a0b
\nConsole.WriteLine(“\u4efb\u52a1\u6267\u884c\u7ed3\u679c\uff1a{0}”, result);
\n}<\/p>\n

async static Task<int> AsyncGetsum()
\n{
\nawait Task.Delay(1);
\nint sum = 0;
\nConsole.WriteLine(“\u4f7f\u7528`Task`\u6267\u884c\u5f02\u6b65\u64cd\u4f5c.”);
\nfor (int i = 0; i < 100; i++)
\n{
\nsum += i;
\n}
\nreturn sum;
\n}
\n}
\n}
\n2.2\u3000\u7ebf\u7a0b\u7b49\u5f85\u3001\u5ef6\u7eed\u548c\u7ec4\u5408
\n2.2.1 Task\u7684\u7ebf\u7a0b\u7b49\u5f85\u548c\u5ef6\u7eed\u4e3b\u8981\u4ee5\u4e0b\u51e0\u7c7b\uff1a<\/p>\n

Wait\uff1a\u9488\u5bf9\u5355\u4e2aTask\u7684\u5b9e\u4f8b\uff0c\u53ef\u4ee5task1.wait\u8fdb\u884c\u7ebf\u7a0b\u7b49\u5f85
\nWaitAny\uff1a\u7ebf\u7a0b\u5217\u8868\u4e2d\u4efb\u4f55\u4e00\u4e2a\u7ebf\u7a0b\u6267\u884c\u5b8c\u6bd5\u5373\u53ef\u6267\u884c\uff08\u963b\u585e\u4e3b\u7ebf\u7a0b\uff09
\nWaitAll\uff1a\u7ebf\u7a0b\u5217\u8868\u4e2d\u6240\u6709\u7ebf\u7a0b\u6267\u884c\u5b8c\u6bd5\u65b9\u53ef\u6267\u884c\uff08\u963b\u585e\u4e3b\u7ebf\u7a0b\uff09
\nWhenAny\uff1a\u4e0eContinueWith\u914d\u5408,\u7ebf\u7a0b\u5217\u8868\u4e2d\u4efb\u4f55\u4e00\u4e2a\u6267\u884c\u5b8c\u6bd5\uff0c\u5219\u7ee7\u7eedContinueWith\u4e2d\u7684\u4efb\u52a1\uff08\u5f00\u542f\u65b0\u7ebf\u7a0b\uff0c\u4e0d\u963b\u585e\u4e3b\u7ebf\u7a0b\uff09
\nWhenAll\uff1a\u4e0eContinueWith\u914d\u5408,\u7ebf\u7a0b\u5217\u8868\u4e2d\u6240\u6709\u7ebf\u7a0b\u6267\u884c\u5b8c\u6bd5\uff0c\u5219\u7ee7\u7eedContinueWith\u4e2d\u7684\u4efb\u52a1\uff08\u5f00\u542f\u65b0\u7ebf\u7a0b\uff0c\u4e0d\u963b\u585e\u4e3b\u7ebf\u7a0b\uff09
\nContinueWith\uff1a\u4e0eWhenAny\u6216WhenAll\u914d\u5408\u4f7f\u7528
\nContinueWhenAny\uff1a\u7b49\u4ef7\u4e8eTask\u7684WhenAny+ContinueWith
\nContinueWhenAll\uff1a\u7b49\u4ef7\u4e8eTask\u7684WhenAll+ContinueWith
\npublic static void Main()
\n{
\n\/\/\u521b\u5efa\u4e00\u4e2a\u4efb\u52a1
\nTask<int> task = new Task<int>(() =>
\n{
\nint sum = 0;
\nConsole.WriteLine(“\u4f7f\u7528`Task`\u6267\u884c\u5f02\u6b65\u64cd\u4f5c.”);
\nfor (int i = 0; i < 100; i++)
\n{
\nsum += i;
\n}
\nreturn sum;
\n});
\n\/\/\u542f\u52a8\u4efb\u52a1,\u5e76\u5b89\u6392\u5230\u5f53\u524d\u4efb\u52a1\u961f\u5217\u7ebf\u7a0b\u4e2d\u6267\u884c\u4efb\u52a1(System.Threading.Tasks.TaskScheduler)
\ntask.Start();
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u6267\u884c\u5176\u4ed6\u5904\u7406”);
\n\/\/\u4efb\u52a1\u5b8c\u6210\u65f6\u6267\u884c\u5904\u7406\u3002
\nTask cwt = task.ContinueWith(t =>
\n{
\nConsole.WriteLine(“\u4efb\u52a1\u5b8c\u6210\u540e\u7684\u6267\u884c\u7ed3\u679c\uff1a{0}”, t.Result.ToString());
\n});
\ntask.Wait();
\ncwt.Wait();<\/p>\n

Action<string,int> log = (name,time) =>
\n{
\nConsole.WriteLine($”{name}\u4efb\u52a1\u5f00\u59cb…”);
\nThread.Sleep(time);
\nConsole.WriteLine($”{name}\u4efb\u52a1\u7ed3\u675f!”);
\n};
\nList<Task> tasks = new List<Task>
\n{
\nTask.Run(() => log(“\u5f20\u4e09”,3000)),
\nTask.Run(() => log(“\u674e\u56db”,1000)),
\nTask.Run(() => log(“\u738b\u4e94”,2000))
\n};
\n\/\/\u4ee5\u4e0b\u8bed\u53e5\u9010\u4e2a\u6d4b\u8bd5\u6548\u679c
\nTask.WaitAny(tasks.ToArray());
\nTask.WaitAll(tasks.ToArray());
\nTask.WhenAny(tasks.ToArray()).ContinueWith(x => Console.WriteLine(“\u67d0\u4e2aTask\u6267\u884c\u5b8c\u6bd5”));
\nTask.WhenAll(tasks.ToArray()).ContinueWith(x => Console.WriteLine(“\u6240\u6709Task\u6267\u884c\u5b8c\u6bd5”));
\nTask.Factory.ContinueWhenAny(tasks.ToArray(), x => Console.WriteLine(“\u67d0\u4e2aTask\u6267\u884c\u5b8c\u6bd5”));
\nTask.Factory.ContinueWhenAll(tasks.ToArray(), x => Console.WriteLine(“\u6240\u6709Task\u6267\u884c\u5b8c\u6bd5”));
\nConsole.Read();
\n}
\n2.2.2 \u4efb\u52a1\u7684\u4e32\u884c<\/p>\n

static void Main(string[] args)
\n{
\nConcurrentStack<int> stack = new ConcurrentStack<int>();<\/p>\n

\/\/t1\u5148\u4e32\u884c
\nvar t1 = Task.Factory.StartNew(() =>
\n{
\nstack.Push(1);
\nstack.Push(2);
\n});<\/p>\n

\/\/t2,t3\u5e76\u884c\u6267\u884c
\nvar t2 = t1.ContinueWith(t =>
\n{
\nint result;
\nstack.TryPop(out result);
\nConsole.WriteLine(“Task t2 result={0},Thread id {1}”, result, Thread.CurrentThread.ManagedThreadId);
\n});<\/p>\n

\/\/t2,t3\u5e76\u884c\u6267\u884c
\nvar t3 = t1.ContinueWith(t =>
\n{
\nint result;
\nstack.TryPop(out result);
\nConsole.WriteLine(“Task t3 result={0},Thread id {1}”, result, Thread.CurrentThread.ManagedThreadId);
\n});<\/p>\n

\/\/\u7b49\u5f85t2\u548ct3\u6267\u884c\u5b8c
\nTask.WaitAll(t2, t3);<\/p>\n

\/\/t4\u4e32\u884c\u6267\u884c
\nvar t4 = Task.Factory.StartNew(() =>
\n{
\nConsole.WriteLine(“\u5f53\u524d\u96c6\u5408\u5143\u7d20\u4e2a\u6570\uff1a{0},Thread id {1}”, stack.Count, Thread.CurrentThread.ManagedThreadId);
\n});
\nt4.Wait();
\n}
\n2.2.3 \u5b50\u4efb\u52a1<\/p>\n

public static void Main()
\n{
\nTask<string[]> parent = new Task<string[]>(state =>
\n{
\nConsole.WriteLine(state);
\nstring[] result = new string[2];
\n\/\/\u521b\u5efa\u5e76\u542f\u52a8\u5b50\u4efb\u52a1
\nnew Task(() => { result[0] = “\u6211\u662f\u5b50\u4efb\u52a11”; }, TaskCreationOptions.AttachedToParent).Start();
\nnew Task(() => { result[1] = “\u6211\u662f\u5b50\u4efb\u52a12”; }, TaskCreationOptions.AttachedToParent).Start();
\nreturn result;
\n}, “\u6211\u662f\u7236\u4efb\u52a1\uff0c\u5e76\u5728\u6211\u7684\u5904\u7406\u8fc7\u7a0b\u4e2d\u521b\u5efa\u591a\u4e2a\u5b50\u4efb\u52a1\uff0c\u6240\u6709\u5b50\u4efb\u52a1\u5b8c\u6210\u4ee5\u540e\u6211\u624d\u4f1a\u7ed3\u675f\u6267\u884c”);
\n\/\/\u4efb\u52a1\u5b8c\u6210\u540e\u6267\u884c
\nparent.ContinueWith(t =>
\n{
\nArray.ForEach(t.Result, r => Console.WriteLine(r));
\n});
\nparent.Start(); \/\/\u542f\u52a8\u7236\u4efb\u52a1
\nparent.Wait();\/\/\u7b49\u5f85\u4efb\u52a1\u7ed3\u675fWait\u53ea\u80fd\u7b49\u5f85\u7236\u7ebf\u7a0b\u7ed3\u675f,\u6ca1\u529e\u6cd5\u7b49\u5230\u7236\u7ebf\u7a0b\u7684ContinueWith\u7ed3\u675f
\nConsole.ReadLine();
\n}
\n2.2.4 \u52a8\u6001\u5e76\u884c<\/p>\n

TaskCreationOptions.AttachedToParent\u7236\u4efb\u52a1\u7b49\u5f85\u6240\u6709\u5b50\u4efb\u52a1\u5b8c\u6210\u540e\u6574\u4e2a\u4efb\u52a1\u624d\u7b97\u5b8c\u6210<\/p>\n

class Node
\n{
\npublic Node Left { get; set; }
\npublic Node Right { get; set; }
\npublic string Text { get; set; }
\n}<\/p>\n

class Program
\n{
\nstatic Node GetNode()
\n{
\nNode root = new Node
\n{
\nLeft = new Node
\n{
\nLeft = new Node{ Text = “L-L” },
\nRight = new Node{ Text = “L-R” },
\nText = “L”
\n},
\nRight = new Node
\n{
\nLeft = new Node{ Text = “R-L” },
\nRight = new Node{ Text = “R-R” },
\nText = “R”
\n},
\nText = “Root”
\n};
\nreturn root;
\n}<\/p>\n

static void Main(string[] args)
\n{
\nNode root = GetNode();
\nDisplayTree(root);
\n}<\/p>\n

static void DisplayTree(Node root)
\n{
\nvar task = Task.Factory.StartNew(() => DisplayNode(root),
\nCancellationToken.None,
\nTaskCreationOptions.None,
\nTaskScheduler.Default);
\ntask.Wait();
\n}<\/p>\n

static void DisplayNode(Node current)
\n{<\/p>\n

if (current.Left != null)
\nTask.Factory.StartNew(() => DisplayNode(current.Left),
\nCancellationToken.None,
\nTaskCreationOptions.AttachedToParent,
\nTaskScheduler.Default);
\nif (current.Right != null)
\nTask.Factory.StartNew(() => DisplayNode(current.Right),
\nCancellationToken.None,
\nTaskCreationOptions.AttachedToParent,
\nTaskScheduler.Default);
\nConsole.WriteLine(“\u5f53\u524d\u8282\u70b9\u7684\u503c\u4e3a{0};\u5904\u7406\u7684ThreadId={1}”, current.Text, Thread.CurrentThread.ManagedThreadId);
\n}
\n}
\n2.3\u3000\u53d6\u6d88\u4efb\u52a1
\nprivate static int TaskMethod(string name, int seconds, CancellationToken token)
\n{
\nConsole.WriteLine(“Task {0} \u6b63\u5728\u8fd0\u884c,\u5f53\u524d\u7ebf\u7a0bid {1}. Is thread pool thread: {2}”,
\nname, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
\nfor (int i = 0; i < seconds; i++)
\n{
\nThread.Sleep(TimeSpan.FromSeconds(1));
\nif (token.IsCancellationRequested) return -1;
\n}
\nreturn 42 * seconds;
\n}<\/p>\n

private static void Main(string[] args)
\n{
\nvar cts = new CancellationTokenSource();
\nvar longTask = new Task<int>(() => TaskMethod(“Task 1”, 10, cts.Token), cts.Token);
\nConsole.WriteLine(longTask.Status);
\ncts.Cancel();
\nConsole.WriteLine(longTask.Status);
\nConsole.WriteLine(“\u7b2c\u4e00\u4e2a\u4efb\u52a1\u5728\u6267\u884c\u524d\u5df2\u88ab\u53d6\u6d88”);
\ncts = new CancellationTokenSource();
\nlongTask = new Task<int>(() => TaskMethod(“Task 2”, 10, cts.Token), cts.Token);
\nlongTask.Start();
\nfor (int i = 0; i < 5; i++)
\n{
\nThread.Sleep(TimeSpan.FromSeconds(0.5));
\nConsole.WriteLine(longTask.Status);
\n}
\ncts.Cancel();
\nfor (int i = 0; i < 5; i++)
\n{
\nThread.Sleep(TimeSpan.FromSeconds(0.5));
\nConsole.WriteLine(longTask.Status);
\n}<\/p>\n

Console.WriteLine(“\u4efb\u52a1\u5df2\u5b8c\u6210,\u7ed3\u679c\u4e3a {0}.”, longTask.Result);
\n}
\n2.4\u3000\u5904\u7406\u5f02\u5e38
\n2.4.1 \u5355\u4e2a\u4efb\u52a1<\/p>\n

static int TaskMethod(string name, int seconds)
\n{
\nConsole.WriteLine(“Task {0} is running on a thread id {1}. Is thread pool thread: {2}”,
\nname, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
\nThread.Sleep(TimeSpan.FromSeconds(seconds));
\nthrow new Exception(“Boom!”);
\nreturn 42 * seconds;
\n}<\/p>\n

static void Main(string[] args)
\n{
\ntry
\n{
\nTask<int> task = Task.Run(() => TaskMethod(“Task 2”, 2));
\nint result = task.GetAwaiter().GetResult();
\nConsole.WriteLine(“Result: {0}”, result);
\n}
\ncatch (Exception ex)
\n{
\nConsole.WriteLine(“Task 2 Exception caught: {0}”, ex.Message);
\n}
\nConsole.WriteLine(“———————————————-“);
\nConsole.ReadLine();
\n}
\n2.4.2 \u591a\u4e2a\u4efb\u52a1<\/p>\n

static int TaskMethod(string name, int seconds)
\n{
\nConsole.WriteLine(“Task {0} is running on a thread id {1}. Is thread pool thread: {2}”,
\nname, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
\nThread.Sleep(TimeSpan.FromSeconds(seconds));
\nthrow new Exception(string.Format(“Task {0} Boom!”, name));
\nreturn 42 * seconds;
\n}<\/p>\n

public static void Main(string[] args)
\n{
\ntry
\n{
\nvar t1 = new Task<int>(() => TaskMethod(“Task 3”, 3));
\nvar t2 = new Task<int>(() => TaskMethod(“Task 4”, 2));
\nvar complexTask = Task.WhenAll(t1, t2);
\nvar exceptionHandler = complexTask.ContinueWith(t =>
\nConsole.WriteLine(“Result: {0}”, t.Result),
\nTaskContinuationOptions.OnlyOnFaulted
\n);
\nt1.Start();
\nt2.Start();
\nTask.WaitAll(t1, t2);
\n}
\ncatch (AggregateException ex)
\n{
\nex.Handle(exception =>
\n{
\nConsole.WriteLine(exception.Message);
\nreturn true;
\n});
\n}
\n}
\n2.4.3 async\/await\u7684\u65b9\u5f0f<\/p>\n

class Program
\n{
\nstatic async Task ThrowNotImplementedExceptionAsync()
\n{
\nthrow new NotImplementedException();
\n}<\/p>\n

static async Task ThrowInvalidOperationExceptionAsync()
\n{
\nthrow new InvalidOperationException();
\n}<\/p>\n

static async Task Normal()
\n{
\nawait Fun();
\n}<\/p>\n

static Task Fun()
\n{
\nreturn Task.Run(() =>
\n{
\nfor (int i = 1; i <= 10; i++)
\n{
\nConsole.WriteLine(“i={0}”, i);
\nThread.Sleep(200);
\n}
\n});
\n}<\/p>\n

static async Task ObserveOneExceptionAsync()
\n{
\nvar task1 = ThrowNotImplementedExceptionAsync();
\nvar task2 = ThrowInvalidOperationExceptionAsync();
\nvar task3 = Normal();
\ntry
\n{
\nTask allTasks = Task.WhenAll(task1, task2, task3); \/\/\u5f02\u6b65\u7684\u65b9\u5f0f
\nawait allTasks;
\n\/\/Task.WaitAll(task1, task2, task3); \/\/\u540c\u6b65\u7684\u65b9\u5f0f
\n}
\ncatch (NotImplementedException ex)
\n{
\nConsole.WriteLine(“task1 \u4efb\u52a1\u62a5\u9519!”);
\n}
\ncatch (InvalidOperationException ex)
\n{
\nConsole.WriteLine(“task2 \u4efb\u52a1\u62a5\u9519!”);
\n}
\ncatch (Exception ex)
\n{
\nConsole.WriteLine(“\u4efb\u52a1\u62a5\u9519!”);
\n}
\n}<\/p>\n

public static void Main()
\n{
\nTask task = ObserveOneExceptionAsync();
\nConsole.WriteLine(“\u4e3b\u7ebf\u7a0b\u7ee7\u7eed\u8fd0\u884c……..”);
\ntask.Wait();
\n}
\n}
\n2.5\u3000Task.FromResult
\n\u6b64\u65b9\u6cd5\u521b\u5efa\u4e00\u4e2aTask<TResult>\u5bf9\u8c61\uff0c\u8be5\u5bf9\u8c61\u7684Task<TResult>.Result\u5c5e\u6027\u4e3aresult\uff0c\u5176Status\u5c5e\u6027\u4e3aRanToCompletion\u3002 \u5f53\u7acb\u5373\u77e5\u9053\u4efb\u52a1\u7684\u8fd4\u56de\u503c\u800c\u4e0d\u6267\u884c\u66f4\u957f\u7684\u4ee3\u7801\u8def\u5f84\u65f6\uff0c\u901a\u5e38\u4f7f\u7528\u65b9\u6cd5\u3002<\/p>\n

class Program
\n{
\nstatic IDictionary<string, string> cache = new Dictionary<string, string>()
\n{
\n{“0001″,”A”}, {“0002″,”B”}, {“0003″,”C”},
\n{“0004″,”D”}, {“0005″,”E”}, {“0006″,”F”}
\n};<\/p>\n

public static void Main()
\n{
\nTask<string> task = GetValueFromCache(“0006”);
\nConsole.WriteLine(“\u4e3b\u7a0b\u5e8f\u7ee7\u7eed\u6267\u884c\u3002\u3002\u3002\u3002”);
\nstring result = task.Result;
\nConsole.WriteLine(“result={0}”, result);
\n}<\/p>\n

private static Task<string> GetValueFromCache(string key)
\n{
\nConsole.WriteLine(“GetValueFromCache\u5f00\u59cb\u6267\u884c\u3002\u3002\u3002\u3002”);
\nstring result = string.Empty;
\n\/\/Task.Delay(5000);
\nThread.Sleep(5000);
\nConsole.WriteLine(“GetValueFromCache\u7ee7\u7eed\u6267\u884c\u3002\u3002\u3002\u3002”);
\nif (cache.TryGetValue(key, out result))
\n{
\nreturn Task.FromResult(result);
\n}
\nreturn Task.FromResult(“”);
\n}
\n}
\n2.6\u3000Factory.FromAsync
\n\u7b80APM\u6a21\u5f0f\uff08\u59d4\u6258\uff09\u8f6c\u6362\u4e3a\u4efb\u52a1\uff0cBeginXXX\u548cEndXXX<\/p>\n

2.6.1 \u5e26\u56de\u8c03\u65b9\u5f0f\u7684<\/p>\n

class Program
\n{
\nprivate delegate string AsynchronousTask(string threadName);
\nprivate static string Test(string threadName)
\n{
\nConsole.WriteLine(“\u5f00\u59cb…”);
\nConsole.WriteLine(“\u7ebf\u7a0b\u6c60\u662f\u7ebf\u7a0b\u5417: {0}”, Thread.CurrentThread.IsThreadPoolThread);
\nThread.Sleep(TimeSpan.FromSeconds(2));
\nThread.CurrentThread.Name = threadName;
\nreturn string.Format(“\u7ebf\u7a0b\u540d\u79f0: {0}”, Thread.CurrentThread.Name);
\n}<\/p>\n

private static void Callback(IAsyncResult ar)
\n{
\nConsole.WriteLine(“\u5f00\u59cb\u4e00\u4e2a\u56de\u8c03…”);
\nConsole.WriteLine(“\u4f20\u9012\u7ed9callbak\u7684\u72b6\u6001: {0}”, ar.AsyncState);
\nConsole.WriteLine(“\u7ebf\u7a0b\u6c60\u662f\u7ebf\u7a0b\u5417: {0}”, Thread.CurrentThread.IsThreadPoolThread);
\nConsole.WriteLine(“\u7ebf\u7a0b\u6c60\u5de5\u4f5c\u7ebf\u7a0bid: {0}”, Thread.CurrentThread.ManagedThreadId);
\n}<\/p>\n

\/\/\u6267\u884c\u7684\u6d41\u7a0b\u662f:\u5148\u6267\u884cTest—>Callback—>task.ContinueWith
\nstatic void Main(string[] args)
\n{
\nAsynchronousTask d = Test;
\nConsole.WriteLine(“Option 1”);
\nTask<string> task = Task<string>.Factory.FromAsync(
\nd.BeginInvoke(“AsyncTaskThread”, Callback, “\u59d4\u6258\u5f02\u6b65\u8c03\u7528”), d.EndInvoke);
\ntask.ContinueWith(t => Console.WriteLine(“\u5b8c\u6210\u56de\u8c03, \u73b0\u5728\u7ee7\u7eed! Result: {0}”, t.Result));
\nwhile (!task.IsCompleted)
\n{
\nConsole.WriteLine(task.Status);
\nThread.Sleep(TimeSpan.FromSeconds(0.5));
\n}
\nConsole.WriteLine(task.Status);
\n}
\n}
\n2.6.2 \u4e0d\u5e26\u56de\u8c03\u65b9\u5f0f\u7684<\/p>\n

class Program
\n{
\nprivate delegate string AsynchronousTask(string threadName);
\nprivate static string Test(string threadName)
\n{
\nConsole.WriteLine(“\u5f00\u59cb…”);
\nConsole.WriteLine(“\u7ebf\u7a0b\u6c60\u662f\u7ebf\u7a0b\u5417: {0}”, Thread.CurrentThread.IsThreadPoolThread);
\nThread.Sleep(TimeSpan.FromSeconds(2));
\nThread.CurrentThread.Name = threadName;
\nreturn string.Format(“\u7ebf\u7a0b\u540d\u79f0: {0}”, Thread.CurrentThread.Name);
\n}<\/p>\n

\/\/\u6267\u884c\u7684\u6d41\u7a0b\u662f:\u5148\u6267\u884cTest—>task.ContinueWith
\nstatic void Main(string[] args)
\n{
\nAsynchronousTask d = Test;
\nTask<string> task = Task<string>.Factory.FromAsync(
\nd.BeginInvoke, d.EndInvoke, “AsyncTaskThread”, “\u59d4\u6258\u5f02\u6b65\u8c03\u7528”);
\ntask.ContinueWith(t => Console.WriteLine(“\u4efb\u52a1\u5b8c\u6210\uff0c\u73b0\u5728\u8fd0\u884c\u4e00\u4e2a\u5ef6\u7eed! Result: {0}”, t.Result));
\nwhile (!task.IsCompleted)
\n{
\nConsole.WriteLine(task.Status);
\nThread.Sleep(TimeSpan.FromSeconds(0.5));
\n}
\nConsole.WriteLine(task.Status);
\n}
\n}
\n2.6.3 Task\u542f\u52a8\u5e26\u53c2\u6570\u548c\u8fd4\u56de\u503c\u7684\u51fd\u6570\u4efb\u52a1<\/p>\n

\u65b9\u6cd51<\/p>\n

private int MyTest(object i)
\n{
\nthis.Invoke(new Action(() =>
\n{
\npictureBox1.Visible = true;
\n}));
\nSystem.Threading.Thread.Sleep(3000);
\nMessageBox.Show(“hello:” + i);
\nthis.Invoke(new Action(() =>
\n{
\npictureBox1.Visible = false;
\n}));
\nreturn 0;
\n}<\/p>\n

private void Call()
\n{
\n\/\/Func<string, string> funcOne = delegate(string s){ return “fff”; };
\nobject i = 55;
\nvar t = Task<int>.Factory.StartNew(new Func<object, int>(MyTest), i);
\n}
\n\u65b9\u6cd52<\/p>\n

private async Task<int> MyTest(object i)
\n{
\nthis.Invoke(new Action(() =>
\n{
\npictureBox1.Visible = true;
\n}));<\/p>\n

HttpClient client = new HttpClient();
\nvar a = await client.GetAsync(“http:\/\/www.baidu.com”);
\nTask<string> s = a.Content.ReadAsStringAsync();
\nMessageBox.Show (s.Result);
\nthis.Invoke(new Action(() =>
\n{
\npictureBox1.Visible = false;
\n}));
\nreturn 0;
\n}<\/p>\n

async private void Call()
\n{
\nobject i = 55;
\nvar t = Task<Task<int>>.Factory.StartNew(new Func<object, Task<int>>(MyTest), i);
\n}
\n\u65b9\u6cd53<\/p>\n

private async void MyTest()
\n{
\nthis.Invoke(new Action(() =>
\n{
\npictureBox1.Visible = true;
\n}));
\nHttpClient client = new HttpClient();
\nvar a = await client.GetAsync(“http:\/\/www.baidu.com”);
\nTask<string> s = a.Content.ReadAsStringAsync();
\nMessageBox.Show (s.Result);
\nthis.Invoke(new Action(() =>
\n{
\npictureBox1.Visible = false;
\n}));
\n}<\/p>\n

private void Call()
\n{
\nvar t = Task.Run(new Action(MyTest));
\n\/\/\u76f8\u5f53\u4e8e
\n\/\/Thread th= new Thread(new ThreadStart(MyTest));
\n\/\/th.Start();
\n}
\n2.7\u3000\u4f7f\u7528IProgress
\nIProgress<in T>\u53ea\u63d0\u4f9b\u4e86\u4e00\u4e2a\u65b9\u6cd5void Report(T value)\uff0c\u901a\u8fc7Report\u65b9\u6cd5\u628a\u4e00\u4e2aT\u7c7b\u578b\u7684\u503c\u62a5\u544a\u7ed9IProgress\uff0c\u7136\u540eIProgress<in T>\u7684\u5b9e\u73b0\u7c7bProgress<in T>\u7684\u6784\u9020\u51fd\u6570\u63a5\u6536\u7c7b\u578b\u4e3aAction<T>\u7684\u5f62\u53c2\uff0c\u901a\u8fc7\u8fd9\u4e2a\u59d4\u6258\u8ba9\u8fdb\u5ea6\u663e\u793a\u5728UI\u754c\u9762\u4e2d\u3002<\/p>\n

class Program
\n{
\nstatic void DoProcessing(IProgress<int> progress)
\n{
\nfor (int i = 0; i <= 100; ++i)
\n{
\nThread.Sleep(100);
\nif (progress != null)
\n{
\nprogress.Report(i);
\n}
\n}
\n}<\/p>\n

static async Task Display()
\n{
\n\/\/\u5f53\u524d\u7ebf\u7a0b
\nvar progress = new Progress<int>(percent =>
\n{
\nConsole.Clear();
\nConsole.Write(“{0}%”, percent);
\n});
\n\/\/\u7ebf\u7a0b\u6c60\u7ebf\u7a0b
\nawait Task.Run(() => DoProcessing(progress));
\nConsole.WriteLine(“”);
\nConsole.WriteLine(“\u7ed3\u675f”);
\n}<\/p>\n

public static void Main()
\n{
\nTask task = Display();
\ntask.Wait();
\n}
\n}<\/p>\n","protected":false},"excerpt":{"rendered":"

cc from   \u5c0f\u84dd\u6ce2 \u4e8e<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"colormag_page_container_layout":"default_layout","colormag_page_sidebar_layout":"default_layout","footnotes":""},"categories":[24],"tags":[121],"class_list":["post-7089","post","type-post","status-publish","format-standard","hentry","category-value_docs","tag-05-"],"_links":{"self":[{"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/posts\/7089","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/comments?post=7089"}],"version-history":[{"count":0,"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/posts\/7089\/revisions"}],"wp:attachment":[{"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/media?parent=7089"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/categories?post=7089"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/i007.cc\/wordpress\/wp-json\/wp\/v2\/tags?post=7089"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}