簡介：
Task 對象是一種的中心思想基於任務的異步模式首次引入.NET Framework 4 中。 因為由執行工作Task對象通常以異步方式執行線程池線程上而不是以同步方式在主應用程序線程中，可以使用Status屬性，並將IsCanceled， IsCompleted，和IsFaulted屬性，以確定任務的狀態。
一.Task的創建
1.創建Task類
（1）
Task task = new Task(() =>
{
Console.WriteLine("hello world!");
});
task.Start();
（2）
new Task(() =>
{
Console.WriteLine("hello world!");
}).Start();
(3)帶參數
new Task(x =>
{
Console.WriteLine(x.ToString());
}, "hello world!").Start();
（4）帶返回值
Task<string> t = new Task<string>(x =>
{
return x.ToString();
}, "hello world!");
t.Start();
Console.WriteLine(t.Result);
2.Task.Factory.StartNew
（1）
Task.Factory.StartNew(() =>
{
Console.WriteLine("hello world!");
});
（2）帶參數
Task.Factory.StartNew(x =>
{
Console.WriteLine(x.ToString());
}, "hello world!");
（3）帶返回值
Task<string> t = Task.Factory.StartNew<string>(() =>
{
return "hello world!";
});
Console.WriteLine(t.Result);
3.Task.Run
Task.Run(() =>
{
Console.WriteLine("hello world!");
});
4.TaskStatus
Created = 0, //該任務已初始化，但尚未被計划。
WaitingForActivation = 1, //該任務正在等待 .NET Framework 基礎結構在內部將其激活並進行計划。
WaitingToRun = 2,//該任務已被計划執行，但尚未開始執行。
Running = 3, //該任務正在運行，但尚未完成。
WaitingForChildrenToComplete = 4,//該任務已完成執行，正在隱式等待附加的子任務完成。
RanToCompletion = 5,//已成功完成執行的任務。
Canceled = 6, //該任務已通過對其自身的 CancellationToken 引發 OperationCanceledException 對取消進行了確認，此時該標記處於已發送信號狀態；或者在該任務開始執行之前，已向該任務的CancellationToken 發出了信號。 有關詳細信息，請參閱任務取消。
Faulted = 7 //由於未處理異常的原因而完成的任務。
二. TaskCreationOptions
Task.Factory.StartNew和創建Task類可以帶TaskCreationOptions參數而Task.Run不可以帶
//
// 摘要:
// 指定應使用默認行為。
None = 0,
//
// 摘要:
// 提示 System.Threading.Tasks.TaskScheduler 以一種盡可能公平的方式安排任務，這意味着較早安排的任務將更可能較早運行，而較晚安排運行的任務將更可能較晚運行。
PreferFairness = 1,
//
// 摘要:
// 指定任務將是長時間運行的、粗粒度的操作，涉及比細化的系統更少、更大的組件。 它會向 System.Threading.Tasks.TaskScheduler
// 提示，過度訂閱可能是合理的。 可以通過過度訂閱創建比可用硬件線程數更多的線程。 它還將提示任務計划程序：該任務需要附加線程，以使任務不阻塞本地線程池隊列中其他線程或工作項的向前推動。
LongRunning = 2,
//
// 摘要:
// 指定將任務附加到任務層次結構中的某個父級。 默認情況下，子任務（即由外部任務創建的內部任務）將獨立於其父任務執行。 可以使用 System.Threading.Tasks.TaskContinuationOptions.AttachedToParent
// 選項以便將父任務和子任務同步。 請注意，如果使用 System.Threading.Tasks.TaskCreationOptions.DenyChildAttach
// 選項配置父任務，則子任務中的 System.Threading.Tasks.TaskCreationOptions.AttachedToParent 選項不起作用，並且子任務將作為分離的子任務執行。
// 有關詳細信息，請參閱附加和分離的子任務。
AttachedToParent = 4,
//
// 摘要:
// 指定任何嘗試作為附加的子任務執行（即，使用 System.Threading.Tasks.TaskCreationOptions.AttachedToParent
// 選項創建）的子任務都無法附加到父任務，會改成作為分離的子任務執行。 有關詳細信息，請參閱附加和分離的子任務。
DenyChildAttach = 8,
//
// 摘要:
// 防止環境計划程序被視為已創建任務的當前計划程序。 這意味着像 StartNew 或 ContinueWith 創建任務的執行操作將被視為 System.Threading.Tasks.TaskScheduler.Default
// 當前計划程序。
HideScheduler = 16
1. LongRunning
任務是長時間任務，就需要用LongRunning，可能會創建一個非線程池線程來執行該任務，防止阻塞線程池隊列中的其他線程
private static void fun8()
{
Task.Factory.StartNew(() =>
{
Console.WriteLine($"task1.線程 id {Thread.CurrentThread.ManagedThreadId}. 是否為線程池線程: {Thread.CurrentThread.IsThreadPoolThread}");
});
Task.Factory.StartNew(() =>
{
Console.WriteLine($"task2.線程 id {Thread.CurrentThread.ManagedThreadId}. 是否為線程池線程: {Thread.CurrentThread.IsThreadPoolThread}");
}, TaskCreationOptions.LongRunning);
}
運行結果：
2. 父子任務（AttachedToParent，DenyChildAttach）
AttachedToParent：將子任務附加到父任務上，表現為：附加到父任務上的所有子任務都結束，父任務才結束
DenyChildAttach：不允許子任務附加到父任務上
（1）子任務不附加到父任務
private static void fun5()
{
Task t = Task.Factory.StartNew(() =>
{
Console.WriteLine("parent");
Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
Console.WriteLine("child");
});
});
t.ContinueWith(x =>
{
Console.WriteLine("parent over");
});
}
運行結果：
（2）子任務附加到父任務上，使用AttachedToParent
private static void fun6()
{
Task t = Task.Factory.StartNew(() =>
{
Console.WriteLine("parent");
Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
Console.WriteLine("child");
},TaskCreationOptions.AttachedToParent);
});
t.ContinueWith(x =>
{
Console.WriteLine("parent over");
});
}
運行結果：
（3）拒絕子任務附加到父任務上，使用DenyChildAttach
private static void fun7()
{
Task t = Task.Factory.StartNew(() =>
{
Console.WriteLine("parent");
Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
Console.WriteLine("child");
}, TaskCreationOptions.AttachedToParent);
}, TaskCreationOptions.DenyChildAttach);
t.ContinueWith(x =>
{
Console.WriteLine("parent over");
});
}
運行結果：
三.CancellationToken 取消任務
private static void fun4()
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken Token = cancellationTokenSource.Token;
//結束任務回調
Token.Register(() =>
{
Console.WriteLine("canceled");
});
Task.Factory.StartNew(() =>
{
try
{
while (true)
{
Console.WriteLine("hello world!");
Thread.Sleep(100);
Token.ThrowIfCancellationRequested();
}
}
catch (OperationCanceledException ocex)
{
}
catch (ObjectDisposedException odex)
{
}
catch (Exception ex)
{
}
}, Token);
Thread.Sleep(1000);
cancellationTokenSource.Cancel();
}
執行結果：
當執行cancellationTokenSource.Cancel()后，任務進行到Token.ThrowIfCancellationRequested()代碼后，throw出OperationCanceledException異常，才結束任務並執行cancel回調
四.方法
| Wait | 等待 System.Threading.Tasks.Task 完成執行過程 |
| WaitAll | 等待提供的所有 System.Threading.Tasks.Task 對象完成執行過程 |
| WaitAny | 等待提供的任一 System.Threading.Tasks.Task 對象完成執行過程 |
| WhenAll | 創建一個任務，該任務將在所有 System.Threading.Tasks.Task 對象都完成時完成 |
| WhenAny | 任何提供的任務已完成時，創建將完成的任務 |
| ContinueWith | 創建一個在目標 System.Threading.Tasks.Task 完成時異步執行的延續任務 |
1 Wait
阻塞當前線程，等待任務執行完成
//等待 System.Threading.Tasks.Task 在指定的毫秒數內完成執行。
public bool Wait(int millisecondsTimeout);
//等待 System.Threading.Tasks.Task 完成執行過程。 如果在任務完成之前取消標記已取消，等待將終止。
public void Wait(CancellationToken cancellationToken);
//等待 System.Threading.Tasks.Task 完成執行過程。 如果在任務完成之前超時間隔結束或取消標記已取消，等待將終止。
public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
//等待 System.Threading.Tasks.Task 完成執行過程。
public void Wait();
//等待 System.Threading.Tasks.Task 在指定的時間間隔內完成執行。
public bool Wait(TimeSpan timeout);
使用方式：
t.Wait();//無限等待
t.Wait(100);//等待100ms
t.Wait(TimeSpan.FromMilliseconds(1500));//等待1500ms
例：
private static void fun9()
{
Task t = Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
Console.WriteLine("task");
});
t.Wait();
Console.WriteLine("main");
}
運行結果：
2.WaitAll
阻塞當前線程，等待所有任務執行完成
//等待提供的所有 System.Threading.Tasks.Task 對象完成執行過程。
public static void WaitAll(params Task[] tasks);
//等待所有提供的可取消 System.Threading.Tasks.Task 對象在指定的時間間隔內完成執行。
public static bool WaitAll(Task[] tasks, TimeSpan timeout);
//等待所有提供的 System.Threading.Tasks.Task 在指定的毫秒數內完成執行。
public static bool WaitAll(Task[] tasks, int millisecondsTimeout);
//等待提供的所有 System.Threading.Tasks.Task 對象完成執行過程（除非取消等待）。
public static void WaitAll(Task[] tasks, CancellationToken cancellationToken);
//等待提供的所有 System.Threading.Tasks.Task 對象在指定的毫秒數內完成執行，或等到取消等待。
public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);
使用：
private static void fun10()
{
Task t1 = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Console.WriteLine("task1");
});
Task t2 = Task.Factory.StartNew(() =>
{
Thread.Sleep(150);
Console.WriteLine("task2");
});
//Task.WaitAll(t1, t2);
//Task.WaitAll(new Task[] { t1, t2 }, 200);
Task.WaitAll(new Task[] { t1, t2 }, TimeSpan.FromMilliseconds(200));
Console.WriteLine("main");
}
運行結果：
3.WaitAny
阻塞當前線程，等待任一任務執行完成
//等待提供的任一 System.Threading.Tasks.Task 對象完成執行過程。
public static int WaitAny(params Task[] tasks);
//等待任何提供的 System.Threading.Tasks.Task 對象在指定的時間間隔內完成執行。
public static int WaitAny(Task[] tasks, TimeSpan timeout);
//等待任何提供的 System.Threading.Tasks.Task 對象在指定的毫秒數內完成執行。
public static int WaitAny(Task[] tasks, int millisecondsTimeout);
//等待提供的任何 System.Threading.Tasks.Task 對象完成執行過程（除非取消等待）。
public static int WaitAny(Task[] tasks, CancellationToken cancellationToken);
//等待提供的任何 System.Threading.Tasks.Task 對象在指定的毫秒數內完成執行，或等到取消標記取消。
public static int WaitAny(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);
使用：
private static void fun11()
{
Task t1 = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Console.WriteLine("task1");
});
Task t2 = Task.Factory.StartNew(() =>
{
Thread.Sleep(150);
Console.WriteLine("task2");
});
//Task.WaitAny(t1, t2);
//Task.WaitAny(new Task[] { t1, t2 }, 200);
Task.WaitAny(new Task[] { t1, t2 }, TimeSpan.FromMilliseconds(200));
Console.WriteLine("main");
}
結果：
4.WhenAll
不阻塞當前線程，等待所有任務執行完成后，可以進行ContinueWith
//創建一個任務，該任務將在可枚舉集合中的所有 System.Threading.Tasks.Task 對象都完成時完成。
public static Task WhenAll(IEnumerable<Task> tasks);
//創建一個任務，該任務將在數組中的所有 System.Threading.Tasks.Task 對象都完成時完成。
public static Task WhenAll(params Task[] tasks);
//創建一個任務，該任務將在可枚舉集合中的所有 System.Threading.Tasks.Task`1 對象都完成時完成。
public static Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>> tasks);
//創建一個任務，該任務將在數組中的所有 System.Threading.Tasks.Task`1 對象都完成時完成。
public static Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks);
使用：
（1）不帶返回值
public static Task WhenAll(params Task[] tasks);
private static void fun12()
{
Task t1 = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Console.WriteLine("task1");
});
Task t2 = Task.Factory.StartNew(() =>
{
Thread.Sleep(150);
Console.WriteLine("task2");
});
Task.WhenAll(t1, t2).ContinueWith(t =>
{
Console.WriteLine("WhenAll");
});
Console.WriteLine("main");
}
執行結果：
（2）帶返回值
public static Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks);
private static void fun13()
{
Task<string> t1 = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Console.WriteLine("task1");
return "task1";
});
Task<string> t2 = Task.Factory.StartNew<string>(() =>
{
Thread.Sleep(150);
Console.WriteLine("task2");
return "task2";
});
Task.WhenAll(new Task<string>[] { t1, t2 }).ContinueWith(t =>
{
string s = "WhenAll:";
foreach (string item in t.Result)
{
s += item;
}
Console.WriteLine(s);
});
Console.WriteLine("main");
}
執行結果：
5.WhenAny
//任何提供的任務已完成時，創建將完成的任務。
public static Task<Task> WhenAny(params Task[] tasks);
//任何提供的任務已完成時，創建將完成的任務。
public static Task<Task> WhenAny(IEnumerable<Task> tasks);
//任何提供的任務已完成時，創建將完成的任務。
public static Task<Task<TResult>> WhenAny<TResult>(params Task<TResult>[] tasks);
//任何提供的任務已完成時，創建將完成的任務。
public static Task<Task<TResult>> WhenAny<TResult>(IEnumerable<Task<TResult>> tasks);
使用：
（1）不帶參數
public static Task<Task> WhenAny(params Task[] tasks);
private static void fun14()
{
Task t1 = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Console.WriteLine("task1");
});
Task t2 = Task.Factory.StartNew(() =>
{
Thread.Sleep(150);
Console.WriteLine("task2");
});
Task.WhenAny(t1, t2).ContinueWith(t =>
{
Console.WriteLine("WhenAny1");
});
Console.WriteLine("main");
}
運行結果：
（2）帶參數：
public static Task<Task<TResult>> WhenAny<TResult>(params Task<TResult>[] tasks);
private static void fun15()
{
Task<string> t1 = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Console.WriteLine("task1");
return "response task1";
});
Task<string> t2 = Task.Factory.StartNew<string>(() =>
{
Thread.Sleep(150);
Console.WriteLine("task2");
return "response task2";
});
Task.WhenAny(new Task<string>[] { t1, t2 }).ContinueWith(t =>
{
t.Result.ContinueWith(tt =>
{
Console.WriteLine(tt.Result);
});
});
Console.WriteLine("main");
}
運行結果：
6.ContinueWith
相當於回調
6.1使用
（1）使用lambda表達式方式
private static void fun1()
{
Console.WriteLine("start");
Task<string> task1 = new Task<string>(() =>
{
Console.WriteLine("task0");
return "task1";
});
Task<string> task2 = task1.ContinueWith(t =>
{
Console.WriteLine(t.Result);
return "task2";
});
task1.Start();
Console.WriteLine("end");
Console.ReadKey();
}
2.使用函數
private static void fun2()
{
Console.WriteLine("start");
Task<string> task1 = new Task<string>(doTask1);
Task<string> task2 = task1.ContinueWith(doTask2);
task1.Start();
Console.WriteLine("end");
Console.ReadKey();
}
private static string doTask1()
{
Console.WriteLine("task0");
return "task1";
}
private static string doTask2(Task<string> t)
{
Console.WriteLine(t.Result);
return "task2";
}
運行結果：
6.2 ContineWith和task可能不在同一線程上
例：
private static void fun16()
{
Task.Factory.StartNew(() =>
{
Console.WriteLine($"task {Thread.CurrentThread.ManagedThreadId}");
}).ContinueWith(t =>
{
Console.WriteLine($"ContinueWith {Thread.CurrentThread.ManagedThreadId}");
});
}
運行結果：
七.TaskFactory類
方法：
| StartNew | 創建並啟動任務 |
| ContinueWhenAll | 創建一個延續任務，該任務在一組指定的任務完成后開始 |
| ContinueWhenAny | 創建一個延續 System.Threading.Tasks.Task，它將在提供的組中的任何任務完成后馬上開始 |
| FromAsync | 創建一個 System.Threading.Tasks.Task`1，表示符合異步編程模型模式的成對的開始和結束方法 |
1.ContinueWhenAll
相當於回調
效果其實和WhenAll差不多，只不過ContineWhenAll采用了回調的方式
使用：帶返回值
private static void fun17()
{
Task<string> t1 = Task.Factory.StartNew<string>(() =>
{
Console.WriteLine("task1");
return "task1";
});
Task<string> t2 = Task.Factory.StartNew<string>(() =>
{
Console.WriteLine("task2");
return "task2";
});
Task.Factory.ContinueWhenAll(new Task[] { t1, t2 }, t =>
{
string s = "ContinueWhenAll:";
foreach (Task<string> item in t)
{
s += item.Result;
}
Console.WriteLine(s);
});
}
運行結果：
2.ContinueWhenAny
相當於回調
效果其實和WhenAny差不多，只不過ContineWhenAny采用了回調的方式
使用：
private static void fun18()
{
Task<string> t1 = Task.Factory.StartNew<string>(() =>
{
Thread.Sleep(10);
Console.WriteLine("task1");
return "task1";
});
Task<string> t2 = Task.Factory.StartNew<string>(() =>
{
Console.WriteLine("task2");
return "task2";
});
Task.Factory.ContinueWhenAny(new Task[] { t1, t2 }, t =>
{
Console.WriteLine($"{(t as Task<string>).Result} 先執行完");
});
}
執行結果：
3.FromAsync
相當於異步委托的精簡寫法，其中ContinueWith相當於異步委托中的callback
使用：
public Task<TResult> FromAsync<TArg1, TResult>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object state);
static void Main(string[] args)
{
fun20();
Console.WriteLine("Main");
Console.ReadKey();
}
private static void fun20()
{
var func = new Func<string, string>(x =>
{
Thread.Sleep(1000);
Console.WriteLine(x);
return "callback";
});
Task.Factory.FromAsync(func.BeginInvoke, func.EndInvoke, "func", null).ContinueWith(t =>
{
Console.WriteLine(t.Result);
});
}
運行結果：
參考：
https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task?view=netframework-4.7.2
https://docs.microsoft.com/zh-cn/dotnet/standard/asynchronous-programming-patterns/task-based-asynchronous-pattern-tap?view=netframework-4.7.2
https://www.cnblogs.com/leo_wl/archive/2012/03/03/2378695.html#_label2