Task的使用注意事项
Task是基于线程池的封装。Task进行异步操作就是从线程池中获取线程进行操作。
基本操作
Task结束后状态
RanToCompletion, Canceled, Faulted
判断一个Task是否成功完成
task == TaskStatus.RanToCompletion
任务调度机制TaskScheduler
ThreadPoolTaskScheduler
Task的默认机制，任务在ThreadPool上执行；如果当前Task上的TaskCreationOptions设置为LongRunning的话，这个task就会委托到Thread中去执行。
private static readonly CustomThreadTaskScheduler _customThreadTaskScheduler = new CustomThreadTaskScheduler(20);
/// <summary>
/// 长时间运行的线程
/// </summary>
/// <param name="action">线程动作</param>
/// <param name="cts"></param>
public static void LongThread(Action action, CancellationTokenSource cts)
{
if (cts != null)
{
return Task.Factory.StartNew(action, cts.Token, TaskCreationOptions.LongRunning, _customThreadTaskScheduler);
}
else
{
return Task.Factory.StartNew(action, CancellationToken.None, TaskCreationOptions.LongRunning, _customThreadTaskScheduler);
}
}
public static void LongThread(Action<object> action, CancellationTokenSource cts)
{
Disponse(cts);
cts = new CancellationTokenSource();
Task.Factory.StartNew(action, cts, cts.Token, TaskCreationOptions.LongRunning, _customThreadTaskScheduler).ConfigureAwait(false);
}
private static CancellationTokenSource _cts = new CancellationTokenSource();
WSCommFunc.LongThread(() =>
{
while (true)
{
WSCommFunc.TestMethod();
WSCommFunc.ThreadPoolInfo();
}
}, _cts);
SynchronizationContextTaskScheduler
同步上下文的调度器，原理就是把繁重的耗时工作丢给ThreadPool，然后将更新UI的操作丢给 UI线程的队列中，由UIThread来执行。
自定义调度器
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
/// <summary>
/// 自定义线程调度器
/// </summary>
public sealed class CustomThreadTaskScheduler : TaskScheduler
{
private readonly BlockingCollection<Task> _tasks = new BlockingCollection<Task>();
private readonly Thread[] _threads;
protected override IEnumerable<Task> GetScheduledTasks() => _tasks;
protected override void QueueTask(Task task) => _tasks.Add(task);
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
public CustomThreadTaskScheduler(int threadCount)
{
_threads = new Thread[threadCount];
for (int index = 0; index < threadCount; index++)
{
_threads[index] = new Thread(_ =>
{
while (true)
{
TryExecuteTask(_tasks.Take());
}
});
}
Array.ForEach(_threads, it => it.Start());
}
}
ContinueWith
一个任务完成后发起一个新任务。
有时候使用 Task 的 Delay 之后，如果想要返回主线程，则有
Task.Delay(TimeSpan.FromSeconds(5)).ContinueWith
(
_ => Foo()
// 如果 Foo 不需要操作UIThread，可以注释下面一段代码提高效率
, TaskScheduler.FromCurrentSynchronizationContext()
);
线程池
线程池的默认最小线程数、最大线程数 与硬件配置有关，最小线程数和逻辑处理器一致（一个处理器保留一个空闲线程）。
不要随意更改线程池的工作线程最小数目，线程上下文切换可能更耗时。
int maxWorkerThreads = 0, maxCompletionPortThreads = 0;
ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxCompletionPortThreads);
Console.WriteLine($"线程池中工作线程的最大数目: {maxWorkerThreads}, 线程池中I/O线程的最大数目: {maxCompletionPortThreads}");
int minWorkerThreads = 0, minCompletionPortThreads = 0;
ThreadPool.GetMinThreads(out minWorkerThreads, out minCompletionPortThreads);
Console.WriteLine($"线程池的空闲工作线程的最小数目: {minWorkerThreads}, 线程池的空闲I/O线程的最小数目: {minCompletionPortThreads}");
Console.WriteLine($"此计算机处理器数量: {Environment.ProcessorCount}");
int count = 200;
Console.WriteLine(Environment.NewLine + "设置最小线程数：" + count);
if (!ThreadPool.SetMinThreads(count, minCompletionPortThreads))
{
Console.WriteLine("Failed!!!!");
}
ThreadPool.GetMinThreads(out minWorkerThreads, out minCompletionPortThreads);
Console.WriteLine($"线程池的空闲工作线程的最小数目: {minWorkerThreads}, 线程池的空闲I/O线程的最小数目: {minCompletionPortThreads}");
等待所有任务完成
多任务长时间操作，等待结果
使用 WaitAll 或 Parallel，一般多用于相对独立的任务列表。
若想操作（统计、计算等）任务的结果，可以加锁，防止并发冲突。
WaitAll
// 多任务长时间操作，等待结果
var tasks = new List<Task>();
for (int i = 0; i < 15; i++)
{
int indx = i;
tasks.Add(Task.Run(()=> TaskLongMethod(indx)));
}
Task.WaitAll(tasks.ToArray());
Console.WriteLine("All Task Completed!!");
foreach (var t in tasks)
{
//Console.WriteLine(t.Result);
}
// 长时间操作
private static int TaskLongMethod(int index)
{
Console.WriteLine($"Task({index,2}): starting.......{DateTime.Now} ");
Stopwatch timer = new Stopwatch();
timer.Start();
Thread.Sleep(_rand.Next(1, 10) * 500);
timer.Stop();
Console.WriteLine($"Task({index,2}): end............{DateTime.Now} 耗时：{timer.ElapsedMilliseconds} ms");\
return 0;
}
Parallel
List<int> list = new List<int>(count);
for (int i = 0; i < 15; i++)
{
list.Add(i);
}
Parallel.ForEach(list, itm =>
{
TaskLongMethod(itm);
});
看着Parallel的效果更好，这只是理论效果，实际应用应根据具体业务具体分析，采用不同的方式。
异步长时间操作，等待结果按顺序输出
LongMethodAsync().GetAwaiter().GetResult();
Console.WriteLine("All Task Completed!!");
static async Task LongMethodAsync()
{
var tasks = new List<Task<Demo>>();
for (int i = 0; i < 15; i++)
{
int indx = i;
tasks.Add(MethodAsync(indx));
}
foreach (var item in tasks.IncompletionOrder())
{
var rslt = await item;
Console.WriteLine($"Task({rslt.Number, 2}): {rslt.Text} ms");
}
}
private static async Task<Demo> MethodAsync(int index)
{
Console.WriteLine($"Task({index, 2}): starting.......{DateTime.Now} ");
Stopwatch timer = new Stopwatch();
timer.Start();
Random rand = new Random();
await Task.Delay(rand.Next(1, 20) * 500);
timer.Stop();
Console.WriteLine($"Task({index, 2}): end............{DateTime.Now} 耗时：{timer.ElapsedMilliseconds} ms");
return new Demo { Number = index, Text = timer.ElapsedMilliseconds.ToString() };
}
其中IncompletionOrder方法，可以参考多线程编程-按完成顺序返回结果
有异常即返回
static async Task LongMethodAsync()
{
var arr = new List<int>();
for (int i = 0; i < 15; i++)
{
arr.Add(i);
}
var listTasks = arr.Select(x => MethodAsync(x));
var reslt = await WhenAllOrFirstException(listTasks);
for (int i = 0; i < reslt.Length; i++)
{
PrintThreadId(reslt[i].ToString());
}
}
using System.Collections.Concurrent;
/// <summary>
/// 异常发生时停止等待，返回现有结果
/// </summary>
/// <typeparam name="T">结果类型</typeparam>
/// <param name="tasks">任务集合</param>
/// <returns></returns>
static Task<T[]> WhenAllOrFirstException<T>(IEnumerable<Task<T>> tasks)
{
var inputs = tasks.ToList();
var ce = new CountdownEvent(inputs.Count);
var tcs = new TaskCompletionSource<T[]>();
Action<Task> onCompleted = (Task t) =>
{
if (t.IsFaulted)
{
tcs.TrySetException(t.Exception.InnerExceptions);
}
if (ce.Signal() && !tcs.Task.IsCompleted)
{
tcs.TrySetResult(inputs.Select(s => s.Result).ToArray());
}
};
foreach (var item in inputs)
{
item.ContinueWith(onCompleted);
}
return tcs.Task;
}
交错完成 Interleaving
谁先完成，先处理谁
static async Task LongMethodAsync()
{
var arr = new List<int>();
for (int i = 0; i < 15; i++)
{
arr.Add(i);
}
var listTasks = arr.Select(x => MethodAsync(x)).ToList();
while (listTasks.Count > 0)
{
try
{
var task = await Task.WhenAny(listTasks);
listTasks.Remove(task);
var result = await task;
// TODO
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
WhenAny适合处理少量任务。当处理大量任务集时，每次WhenAny都会向每个任务注册延续O(\(N^{2}\))，造成性能问题。此时可以使用Interleaved。
static async Task LongMethodAsync()
{
var arr = new List<int>();
for (int i = 0; i < 15; i++)
{
arr.Add(i);
}
var listTasks = arr.Select(x => MethodAsync(x)).ToList();
foreach (var item in Interleaved(listTasks))
{
var result = await item;
// TODO
PrintThreadId(result.ToString());
}
}
/// <summary>
/// 交错操作
/// </summary>
/// <typeparam name="T">结果类型</typeparam>
/// <param name="tasks">任务集合</param>
/// <remarks>实时返回处理结果</remarks>
/// <returns></returns>
static IEnumerable<Task<T>> Interleaved<T>(List<Task<T>> tasks)
{
var source = tasks.Select(s => new TaskCompletionSource<T>()).ToList();
int nextIndex = -1;
foreach (var item in tasks)
{
item.ContinueWith(t =>
{
var tcs = source[Interlocked.Increment(ref nextIndex)];
PrintThreadId(t.Status.ToString());
if (t.IsFaulted)
{
tcs.TrySetException(t.Exception.InnerExceptions);
}
else if (t.IsCanceled)
{
tcs.TrySetCanceled();
}
else
{
tcs.TrySetResult(t.Result);
}
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}
return source.Select(s => s.Task);
}
遏制/节流 Throttling
限制并发数量。
static async Task LongMethodAsync()
{
const int CONCURRENCY_LEVEL = 10;
int index = 0;
var arr = new List<int>();
for (int i = 0; i < 15; i++)
{
arr.Add(i);
}
var tasks = new List<Task<Demo>>();
while (index < CONCURRENCY_LEVEL && index < arr.Count)
{
tasks.Add(MethodAsync(index));
index++;
}
while (tasks.Count > 0)
{
try
{
var task = await Task.WhenAny(tasks);
tasks.Remove(task);
var result = await task;
// TODO
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
if (index < arr.Count)
{
tasks.Add(MethodAsync(index));
index++;
}
}
}
超时
与 CancellationTokenSource或Task.Delay 结合使用。
LongMethodAsync().ConfigureAwait(false);
Thread.Sleep(1000); // 1
//Thread.Sleep(10000); // 2
_cts?.Cancel();
当是EAP类方法，无法传递CancellationToken，可以如下操作。
static async Task LongMethodAsync()
{
_cts = new CancellationTokenSource();
var task = MethodAsync(100);
await UnitilCompletionOrCancellation(task, _cts.Token);
if (task.IsCompleted)
{
var result = await task;
Console.WriteLine("Task Completed! " + result);
}
else
{
task.ContinueWith(t =>
{
Console.WriteLine(t.Status);
});
}
}
private static async Task UnitilCompletionOrCancellation(Task asyncOp, CancellationToken token)
{
var tcs = new TaskCompletionSource<bool>();
using (token.Register(() => tcs.TrySetResult(true)))
{
await Task.WhenAny(asyncOp, tcs.Task);
}
}
LongMethodAsync().ConfigureAwait(false);
static async Task LongMethodAsync()
{
var task = MethodAsync(100);
if (task == await Task.WhenAny(task, Task.Delay(5000)))
{
var result = await task;
Console.WriteLine("Task Completed! " + result);
}
else
{
task.ContinueWith(t =>
{
Console.WriteLine("Timeout!" + t.Status);
});
}
}
重试 RetryOnFault
耗时超过5s时，方法抛出异常，继续重试，最后重试n次或者返回正确结果
static async Task LongMethodAsync()
{
var result = await RetryOnFault(() => MethodAsync(10), 3);
Console.WriteLine(result);
}
/// <summary>
/// 失败时重试
/// </summary>
/// <typeparam name="T">返回数据类型</typeparam>
/// <param name="func">异步方法</param>
/// <param name="count">重试次数</param>
/// <param name="retryWhen">何时重试</param>
/// <returns></returns>
static async Task<T> RetryOnFault<T>(Func<Task<T>> func, int count, Func<Task> retryWhen = null)
{
for (int i = 0; i < count; i++)
{
try
{
return await func().ConfigureAwait(false);
}
catch (Exception ex)
{
if ( i == count - 1)
{
Console.WriteLine("重试失败！");
}
else
{
Console.WriteLine(ex.Message);
}
}
// null时直接重试
if (retryWhen != null)
{
await retryWhen().ConfigureAwait(false);
}
}
return default(T);
}
在重试前，等待片刻
var result = await RetryOnFault(() => MethodAsync(10), 3, ()=> Task.Delay(1000));
只需要一个 NeedOnlyOne
利用冗余改进操作延迟，提高成功的可能性。
static async Task LongMethodAsync()
{
var result = await NeedOnlyOne(
token => MethodAsync(1, token),
token => MethodAsync(2, token),
token => MethodAsync(3, token)
);
if (result == null)
{
PrintThreadId("NULL!!");
}
else
{
PrintThreadId(result.ToString());
}
}
/// <summary>
/// 只要从其中一个获得响应，立刻取消剩余的请求
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="funcs">委托</param>
/// <returns></returns>
static async Task<T> NeedOnlyOne<T>(params Func<CancellationToken, Task<T>>[] funcs)
{
var length = funcs.Length;
if (length == 0)
{
return default(T);
}
var arr = new CancellationToken[length];
for (int i = 0; i < length; i++)
{
var function = funcs[i];
Expression<Func<CancellationToken, Task<T>>> exp = ct => function(ct);
CancellationToken token = CancellationToken.None;
var variableParameter = Expression.Variable(typeof(CancellationToken), nameof(token));
var inputParameter = exp.Parameters[0];
Expression.Assign(variableParameter, inputParameter);
arr[i] = token;
}
var cts = CancellationTokenSource.CreateLinkedTokenSource(arr);
var tasks = funcs.Select(s => s(cts.Token)).ToArray();
var completed = await Task.WhenAny(tasks).ConfigureAwait(false);
cts.Cancel();
foreach (var task in tasks)
{
var ignored = task.ContinueWith(t =>
{
Console.WriteLine(t.Status);
}, TaskContinuationOptions.OnlyOnFaulted);
}
if (completed.IsFaulted)
{
return default(T);
}
return await completed;
}
static Random _rand = new Random();
private static async Task<Demo> MethodAsync(int index, CancellationToken token)
{
var cost = _rand.Next(1, 20) * 500;
Console.WriteLine($"Task({index,2}): starting.......{DateTime.Now} (Predicate: {cost} ms)");
Stopwatch timer = new Stopwatch();
timer.Start();
try
{
await Task.Delay(cost, token);
Console.WriteLine($"Task({index,2}): end............{DateTime.Now} 耗时：{timer.ElapsedMilliseconds} ms");
}
catch (TaskCanceledException ex)
{
Console.WriteLine($"Task({index,2}): end............{DateTime.Now} 耗时：{timer.ElapsedMilliseconds} ms {ex.Message}");
}
timer.Stop();
if (timer.ElapsedMilliseconds > 3000)
{
throw new Exception("Timeout!!");
}
return new Demo { Number = index, Text = timer.ElapsedMilliseconds.ToString() };
}
任务的异步缓存
AsyncCache<int, Demo> _cache = new AsyncCache<int, Demo>(MethodAsync);
Random random = new Random();
for (int i = 0; i < 15; i++)
{
int index = random.Next(0, 5);
var result = await _cache[index];
PrintThreadId(i + result.ToString());
}
/// <summary>
/// 小型异步缓存
/// </summary>
/// <typeparam name="TKey">任务对应的密钥</typeparam>
/// <typeparam name="TValue">任务结果类型</typeparam>
public class AsyncCache<TKey, TValue>
{
private readonly Func<TKey, Task<TValue>> _factory;
private readonly ConcurrentDictionary<TKey, Lazy<Task<TValue>>> _map;
public AsyncCache(Func<TKey, Task<TValue>> func)
{
if (func == null)
{
throw new ArgumentNullException("func");
}
_factory = func;
_map = new ConcurrentDictionary<TKey, Lazy<Task<TValue>>>();
}
public Task<TValue> this[TKey key]
{
get
{
if (key == null)
{
throw new ArgumentNullException("key");
}
return _map.GetOrAdd(key, value => new Lazy<Task<TValue>>(() => _factory(value))).Value;
}
}
}
浙公网安备 33010602011771号