C# 多线程、异步线程、线程池相关知识

/*
线程池ThreadPool类会在需要时增减池中线程的线程数，直到最大的线程数。池中的最大线程数是可配置的。
在双核CPU中，默认设置为1023个工作线程和1000个I/O线程。也可以指定在创建线程池时应立即启动的最小线程数，
以及线程池，中可用的最大线程数。如果有更多的作业要处理，线程池中线程的个数也到了极限，
最新的作业就要排队，且必须等待线程完成其任务。
*/

//下面这个方法是一个符合WaitCallBack委托的方法：
static void WaitCallBackMethod(object param)
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine(String.Format("Thread {0} is running", param));
Thread.Sleep(1000);
}
}
//然后在主线程里给线程池添加方法,QueueUserWorkItem()方法的第二个参数是个object类型的参数，可传入一个数据到线程中

static void Main(string[] args)
{
for (int i = 1; i <= 3; i++)
{
ThreadPool.QueueUserWorkItem(WaitCallBackMethod, i);
}
Console.Read();
}

/////////////////////////////////////////////////////////////////
//Task任务
1、Task类构造函数

使用Task类的构造函数。实例化Task对象时，任务不会立即运行，而是指定Created状态。
接着调用Task类的Start()方法来启动任务。
使用Task类时，除了调用Start()方法,还可以调用RunSynchronously()方法。
这样，任务也会启动，但是同时调用。默认情况下,任务是异步运行的。
Task类的构造函数接收一个无参无返回值的委托：

Task task = new Task(TaskMethod);
task.Start();

下面是TaskMethod方法：
static void TaskMethod()
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine(String.Format("Running in a task. Task ID: {0}", Task.CurrentId));
Thread.Sleep(500);
}
}

方法里用Task.CurrentId属性取得当前任务ID。下面是主线程：
static void Main(string[] args)
{
Task task = new Task(TaskMethod);
task.Start();

for (int i = 0; i < 10; i++)
{
Console.WriteLine("Running in main thread.");
Thread.Sleep(500);
}

Console.Read();
}

如果要往线程里传递参数，Task构造函数提供的重载，可以传入一个object类型的参数：
Task task = new Task(TaskMethodWithParameter, "Hello world");
task.Start();

下面是带参的线程方法：
static void TaskMethodWithParameter(object param)
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine(String.Format("Running in a task. Parameter: {0}", param));
Thread.Sleep(500);
}
}

2、TaskFactory类
使用实例化的TaskFactory类，在其中把TaskMethod方法传递给StartNew()方法，就会立即启动任务。
TaskFactory tf = new TaskFactory();
tf.StartNew(TaskMethod);

3、Task.Factory属性
Task类提供了一个Factory静态属性，这个属性返回一个TaskFactory对象。
Task task = Task.Factory.StartNew(TaskMethod);

///////////////////////////////////////////////////////////////////////////////////
C#异步编程的实现方式——连续任务

通过任务,可以指定在任务完成后，应开始运行另一个特定任务。任务处理程序或者不带参数或者带一个对象参数，而连续处理程序有一个Task类型的参数。下面先定义两个任务：

static void FirstTaskMethod()
{
Console.WriteLine(String.Format("Task {0} is doing something", Task.CurrentId));
Thread.Sleep(200);
}

static void SecondTaskMethod(Task task)
{
Console.WriteLine("Last task is finished");
Console.WriteLine(String.Format("Task {0} is doing something", Task.CurrentId));
Thread.Sleep(200);
}

连续任务通过在任务上调用ContinueWith()方法来现实：
static void Main(string[] args)
{
Task task1 = new Task(FirstTaskMethod);
Task task2 = task1.ContinueWith(SecondTaskMethod);
task1.Start();

for (int i = 0; i < 20; i++)
{
Console.WriteLine("Main thread is running");
Thread.Sleep(200);
}

Console.Read();
}
主线程循环输出字符串到控制台，Task1任务在另外一个线程里运行，FirstTaskMethod执行完继续SecondTaskMethod
值得注意的是，在一个任务结束时，可以启动多个任务，也就是说，任务的连接可以像一个树结构那样，如下代码：

Task task1 = new Task(FirstTaskMethod);
Task task2 = task1.ContinueWith(SecondTaskMethod);
Task task3 = task1.ContinueWith(SecondTaskMethod);
Task task4 = task2.ContinueWith(SecondTaskMethod);
Task task5 = task2.ContinueWith(SecondTaskMethod);
无论前一个任务是如何结束的，后面的连续任务总是在前一个任务结束时启动。
TaskContinuationOptions枚举提供了OnlyOnFaulted，NotOnFaulted，OnlyOnCanceled，
NotOnCanceled，OnlyOnRunToCompletion几个选项。我们可以指定只有当前一个任务成功结束时才启动：

Task task5 = task2.ContinueWith(SecondTaskMethod, TaskContinuationOptions.OnlyOnRanToCompletion);

///////////////////////////////////////////////////////////////////////////////////
C#异步编程的实现方式——层次任务

任务也可以构成一个层次结构。一个任务启动一个新任务时，就启动了一个层次结构。
下面的代码段在父任务内部新建一个任务。创建子任务的代码与创建父任务的代码相同，
唯一的区别是这个任务从另一个任务内部创建：

static void Main(string[] args)
{
Task parentTask = new Task(ParentTask);
parentTask.Start();

Console.Read();
}

static void ParentTask()
{
Console.WriteLine("Parent task is starting");
Task childTask= new Task(ChildTask,TaskCreationOptions.AttachedToParent);
childTask.Start();
Thread.Sleep(2000);
Console.WriteLine("Parent task is finished");
}

static void ChildTask()
{
Console.WriteLine("Child task started");
Thread.Sleep(4000);
Console.WriteLine("Child task is finished");
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Ex.RulesTester.Threads
{
/// <summary>
/// Task异步等待所有线程结束通知测试
/// </summary>
[TestClass]
public class TaskAllCompleteTester
{
[TestMethod]
public void TestTaskPoolStatus()
{
//运行异步多任务
TaskTest.RunTask();
var list = TaskTest.SuccessList;
bool isAllComplete = false;
//等待异步通知
while (!isAllComplete)
{
isAllComplete = TaskTest.IsAllComplete;
list = TaskTest.SuccessList;
}

Assert.IsTrue(true);
}
/// <summary>
/// 对于 task 多任务执行的封装
/// </summary>
private class TaskTest
{
private static object m_lock = new object();
public static List<string> SuccessList = new List<string>();
private static string msg = "";
public static bool IsFinish = false;
public static List<Task> TaskList = new List<Task>();
static bool isAllComplete = false;
/// <summary>
/// 标记所有任务是否全部执行完毕
/// </summary>
public static bool IsAllComplete
{
get { return isAllComplete; }
}

private TaskTest()
{

}

public static void RunTask()
{
//运行5个任务
for (int i = 1; i <= 5; i++)
{
var task = Task.Factory.StartNew(DoTask, i);
TaskList.Add(task);
}
//异步等待所有任务执行完毕
Task.Factory.StartNew(x =>
{
Task.WaitAll(TaskList.ToArray());
//标记所有任务运行完成
isAllComplete = true;
}, null);
}
private static void DoTask(object par)
{
Thread.Sleep(int.Parse(par.ToString()) * 1000);
lock (m_lock)
{
SuccessList.Add("Has Completed T" + par.ToString());
}
}

}
}
}