多线程操作

class Program
{
static List<int> list = new List<int>();
static int size;
static object _lock = new object();
static int exeCount = 0;
static void Main(string[] args)
{
TestThread();
Console.WriteLine("done");
Console.ReadKey();
}
static void TestThread()
{
for (int i = 0; i < 500; i++)
{
list.Add(i);
}
int threadCount = 5;
size = list.Count / threadCount+1;
List<Thread> tlist = new List<Thread>();
for (int i = 0; i < threadCount; i++)
{
RunIt(i);
}
Console.WriteLine("线程数：" + tasks.Count);
Console.WriteLine("每组个数：" + size);
foreach (var t in tasks)
{
t.Wait();
}
Console.WriteLine("总执行次数：" + exeCount);
}
static List<Task> tasks = new List<Task>();
static void RunIt(int i)
{
var task= Task.Run(() =>
{
var listSub = list.Skip(i * size).Take(size);
foreach (var a in listSub)
{
Console.Write(a.ToString()+"\t");
lock(_lock)
{
exeCount++;
}
}
});
tasks.Add(task);
}

}

/// <summary>
/// 多线程任务
/// </summary>
/// <typeparam name="T">类型</typeparam>
public class TaskHelper<T>
{
/// <summary>
///
/// </summary>
/// <param name="threadCount">线程数量</param>
/// <param name="list">待处理列表</param>
/// <param name="handle">调用方法</param>
public TaskHelper(int threadCount, IEnumerable<T> list, Handle<T> handle)
{
this.threadCount = threadCount;
this.listT = list;
this.handle = handle;
}
private List<Task> tasks = new List<Task>();
private int threadCount;
private int size;
private IEnumerable<T> listT;
private Handle<T> handle;
/// <summary>
/// 启动
/// </summary>
public void Start()
{
size = listT.Count() / threadCount + 1;
for (int i = 0; i < threadCount; i++)
{
Run(i);
}
foreach (var t in tasks)
{
t.Wait();
}
}

private void Run(int i)
{
var task = Task.Run(() =>
{
var listSub = listT.Skip(i * size).Take(size);
foreach (T a in listSub)
{
handle(a);
}
});
tasks.Add(task);
}
}
/// <summary>
/// 委托方法
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="t">参数</param>
public delegate void Handle<T>(T t);

List<int> list = new List<int>();
for (int i = 0; i < 100; i++)
{
list.Add(i);
}
int threadCount = 5;
TaskHelper<int> task = new TaskHelper<int>(threadCount,list,RunConsole);
task.Start();

public static async Task Gooo()
{
var cts = new CancellationTokenSource(5000);
var ct = cts.Token;
try
{
await Task.Delay(10000).WithCancellation(ct);
Console.WriteLine("Task completed");
}
catch (Exception)
{
Console.WriteLine("Task cancelled");
}
}

public static class TaskUnity
{
private struct Void { }
public static async Task WithCancellation(this Task task, CancellationToken ct)
{
var tcs = new TaskCompletionSource<Void>();
using (ct.Register(t => ((TaskCompletionSource<Void>)t).TrySetResult(default(Void)), tcs))
{
if (await Task.WhenAny(task, tcs.Task) == tcs.Task) ct.ThrowIfCancellationRequested();
}
await task;
}
private static async Task<TResult> WithCancellation<TResult>(this Task<TResult> originalTask, CancellationToken ct)
{
var cancelTask = new TaskCompletionSource<Void>();
using (ct.Register(
t => ((TaskCompletionSource<Void>)t).TrySetResult(new Void()), cancelTask))
{
Task any = await Task.WhenAny(originalTask, cancelTask.Task);
if (any == cancelTask.Task) ct.ThrowIfCancellationRequested();
}
return await originalTask;
}

}