线程基础

1. Windows为什么要支持线程

　　线程(thread)职责是对CPU进行虚拟化.

　　Windows为每个进程提供了该进程专用的线程(功能相当于一个CPU, 可将线程理解为一个逻辑CPU).

　　如果应用程序进入无限循环，与代码相关的进程会被“冻结”，但其他进程可以继续执行.

 

2.专用线程执行异步计算限制操作

　　创建一个线程, 并让其执行一次异步计算限制(asunchronous compute-bound)操作

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("MainThread: start a dedicated thread " + "to do an asynchronous operation");
            Thread dedicatedThread = new Thread(ComputerBoundOp);  //生成专用线程
            dedicatedThread.Start(555);  //Thread的Start方法开始执行回调函数, 异步调用一个方法

            Console.WriteLine("MainThread: Doing Other Work here...");
            Thread.Sleep(10000);
            dedicatedThread.Join();  //代表dedicatedThread线程结束后才能继续执行下面代码
            Console.WriteLine("The End");
        }

        private static void ComputerBoundOp(Object state){
            Console.WriteLine("ComputerBoundOp: state={0}",state);
            Thread.Sleep(1000); //这个方法返回后，专用线程将结束
        }
    }
}

　　

　　有可能后两句话的打印顺序相反, 因为无法控制Windows对两个线程进行调度的方式.

　　但是试了几次都是这样的结果( 妈蛋！)

　　dedicatedThread.join(); 直到dedicatedThread线程销毁或终止, 才会解除阻塞.

 

3. 前台线程和后台线程

　　每个线程要么是前台线程, 要么是后台线程.

　　一个进程中所有前台线程结束运行时, 任何后台线程将强制终止, 不会抛出异常

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t = new Thread(Worker);//默认为前台线程
            t.IsBackground = true; //使线程成为后台线程
            t.Start();
　　　　　　  //如果t是一个前台线程，则应用程序大约10秒后才终止 
　　　　　　　　  //如果t是一个后台线程，则应用程序立即终止
            Console.WriteLine("Returning from Main");
        }

        private static void Worker()
        {
            Thread.Sleep(10000); //模拟做10秒钟工作
            Console.WriteLine("Returning from Worker");
        }
    }
}

　　结果就是程序立即终止了

 

4. 线程池

　　创建和销毁线程都是一个昂贵的操作, 需要耗费大量时间, 太多的线程会浪费内存资源.

　　利用线程池可以对线程进行有效的控制，使得线程能够更好的协作。

　　线程池将自己的线程划分为 Worker线程 和 I/O线程

　　4.1 线程池简单的计算限制操作

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
             Console.WriteLine("MainThread: queuing an asynchronous operation");
             ThreadPool.QueueUserWorkItem(ComputerBoundOp,555);  
             Console.WriteLine("MainThread: Doing Other Work here...");
             Thread.Sleep(10000);
             Console.WriteLine("The End");
         }
 
         private static void ComputerBoundOp(Object state){
             Console.WriteLine("ComputerBoundOp: state={0}",state);
             Thread.Sleep(1000); 
         }
    }
}

　　ThreadPool类可将异步的, 计算限制的操作放到线程池队列中　

public static bool QueueUserWorkItem(WaitCallback callBack);
public static bool QueueUserWorkItem(WaitCallback callBack, object state);

　　那么, 线程池是如何有效的控制系统资源的消耗的呢？

　　它的原理非常简单：

• 线程池中维护一个请求队列，当应用程序有异步的请求时，将此请求(比如请求A)发送到线程池。
• 线程池将请求A放入请求队列中，然后新建一个线程(比如线程A)来处理请求A。
• 请求A处理完成后，线程池不会销毁线程A，而是使用线程A来处理请求队列中的下一个请求(比如请求B) (销毁线程会耗费资源)。
• 当请求过多时，线程池才会再新建一些线程来加快处理请求队列中的请求。（注1）
• 当请求队列为空时，线程池会销毁一些空闲时间比较长的线程。（注2）

　　注1：保证所有的请求由少量线程处理，减少系统资源的消耗，同时减少了线程新建，销毁的次数。

　　注2：空闲时间多长才销毁线程是由CLR决定的，不同版本的CLR这个时间可能不同。

 

5. Task

　　参考博客 http://www.cnblogs.com/wang_yb/archive/2011/11/10/2244745.html

　　利用ThreadPool的QueueUserWorkItem方法建立的异步操作存在一些限制：

　　1. 异步操作没有返回值

　　2. 没有内建的机制通知异步操作什么时候完成

　　通过任务的状态（TaskStatus），可以了解任务(Task)的生命周期。　　

public enum TaskStatus
{   
    // 运行前状态
    Created = 0,                      // 任务被显式创建,通过Start()开始这个任务
    WaitingForActivation = 1,         // 任务被隐式创建,会自动开始
    WaitingToRun = 2,                 // 任务已经被调度,但是还没有运行
 
    // 运行中状态
    Running = 3,                      // 任务正在运行
    WaitingForChildrenToComplete = 4, // 等待子任务完成
 
    // 运行完成后状态
    RanToCompletion = 5,              // 任务正常完成
    Canceled = 6,                     // 任务被取消
    Faulted = 7,                      // 任务出错
}

　　构造一个Task后，它的状态为Create。

　　启动后，状态变为WaitingToRun。

　　实际在一个线程上运行时，状态变为Running。

　　运行完成后，根据实际情况，状态变为RanToCompletiion，Canceled，Faulted三种中的一种。

　　如果Task不是通过new来创建的，而是通过以下某个函数创建的，那么它的状态就是WaitingForActivation：

　　ContinueWith，ContinueWhenAll，ContinueWhenAny，FromAsync。

　　如果Task是通过构造一个TaskCompletionSource<TResult>对象来创建的，该Task在创建时也是处于WaitingForActivation状态。

　　5.1 创建并启动一个Task

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
             Console.WriteLine("MainThread Start");

             Task t = new Task(() =>
             {
                 Console.WriteLine("Task Start");
                 Thread.Sleep(1000);
                 Console.WriteLine("Task End");
             });

             t.Start();

            //主线程没有等待Task, 在Task完成之前就已经完成了 
            Console.WriteLine("Main Thread end!");
             Console.ReadKey(true);
         }
    }
}

　　

　　5.2 主线程等待子线程完成

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
             Console.WriteLine("MainThread Start");

             Task t1 = new Task(() =>
             {
                 Console.WriteLine("Task1 Start");
                 Thread.Sleep(1000);
                 Console.WriteLine("Task1 End");
             });
             Task t2 = new Task(() =>
             {
                 Console.WriteLine("Task2 Start");
                 Thread.Sleep(2000);
                 Console.WriteLine("Task2 End");
             });
             t1.Start();
             t2.Start();

             // 当t1和t2中任何一个完成后，主线程继续后面的操作
             // Task.WaitAny(new Task[] { t1, t2 });

             //当t1和t2中全部完成后，主线程继续后面的操作
             Task.WaitAll(new Task[] { t1, t2 });

            //主线程没有等待Task, 在Task完成之前就已经完成了 
            Console.WriteLine("Main Thread end!");
             Console.ReadKey(true);
         }
    }
}

　　

 　　5.3取消Task

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main Thread start!");
            CancellationTokenSource cts = new CancellationTokenSource();

            // 创建2个Task
            Task t1 = new Task(() =>
            {
                Console.WriteLine("Task1 start");
                for (int i = 0; i < 100; i++)
                {
                    if (!cts.Token.IsCancellationRequested)
                    {
                        Console.WriteLine("Count : " + i.ToString());
                        Thread.Sleep(1000);
                    }
                    else
                    {
                        Console.WriteLine("Task1 is Cancelled!");
                        break;
                    }
                }
                Console.WriteLine("Task1 end");
            }, cts.Token);

            // 启动Task
            t1.Start();
            Thread.Sleep(3000);
            // 运行3秒后取消Task
            cts.Cancel();

            // 为了测试取消操作，主线程等待Task完成
            Task.WaitAny(new Task[] { t1 });
            Console.WriteLine("Main Thread end!");
            Console.ReadKey(true);  //等待按键结束
        }
    }
}

　　

 

6. 子任务和任务工厂

　　6.1延续任务

　　为了保证程序的伸缩性, 应该尽量避免线程阻塞, 这就意味着我们在等待一个任务完成时, 最好不要用Wait, 而是让一个任务结束后自动启动它的下一个任务.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
           Console.WriteLine("Main Thread start!");
 
            // 第一个Task
            Task<int> t1 = new Task<int>(() =>
            {
                Console.WriteLine("Task 1 start!");
                Thread.Sleep(2000);
                Console.WriteLine("Task 1 end!");
                return 1;
             });
 
            // 启动第一个Task
            t1.Start();
            
            // 因为TaskContinuationOptions.OnlyOnRanToCompletion，
            // 所以第一个Task正常结束时,启动第二个Task。
            // TaskContinuationOptions.OnlyOnFaulted，则第一个Task出现异常时,启动第二个Task
            // 其他可详细参考TaskContinuationOptions定义的各个标志
            
            t1.ContinueWith(AnotherTask, TaskContinuationOptions.OnlyOnRanToCompletion);//OnlyOnRanToComplete可以更改为其他参数,如OnlyOnCanceled
 
            Console.WriteLine("Main Thread end!");
            Console.ReadKey(true);
         }
 
        // 第二个Task的处理都在AnotherTask函数中，
        // 第二个Task的引用其实就是上面ContinueWith函数的返回值。
        // 这里没有保存第二个Task的引用
        private static void AnotherTask(Task<int> task)
        {
            Console.WriteLine("Task 2 start!");
            Thread.Sleep(1000);
            Console.WriteLine("Task 1's return Value is : " + task.Result);  //Task参数传递
            Console.WriteLine("Task 2 end!");
        }
    }
}

　　

 

　　6.2 子任务

　　定义子任务时，注意一定要加上TaskCreationOptions.AttachedToParent，这样父任务会等待子任务执行完后才结束

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main Thread start!");

            Task<int[]> parentTask = new Task<int[]>(() =>
            {
                var result = new int[3];

                // 子任务1
                new Task(() =>
                {
                    Console.WriteLine("sub task 1 start!");
                    Thread.Sleep(1000);
                    Console.WriteLine("sub task 1 end!");
                    result[0] = 1;
                }, TaskCreationOptions.AttachedToParent).Start();

                // 子任务2
                new Task(() =>
                {
                    Console.WriteLine("sub task 2 start!");
                    Thread.Sleep(1000);
                    Console.WriteLine("sub task 2 end!");
                    result[1] = 2;
                }, TaskCreationOptions.AttachedToParent).Start();

                // 子任务3
                new Task(() =>
                {
                    Console.WriteLine("sub task 3 start!");
                    Thread.Sleep(1000);
                    Console.WriteLine("sub task 3 end!");
                    result[2] = 3;
                }, TaskCreationOptions.AttachedToParent).Start();

                return result;
            });

            parentTask.Start();

            Console.WriteLine("Parent Task's Result is :");
            foreach (int result in parentTask.Result)
                Console.Write("{0}\t", result);

            Console.WriteLine();
            Console.WriteLine("Main Thread end!");
            Console.ReadKey(true);
        }
    }
}

　　

　　<1>3个子任务的执行顺序也和定义的顺序无关，比如任务3可能最先执行（与CPU的调度有关）。

　　<2>Result打印出来是1 2 3 ,把   ，TaskCreationOptions.AttachedToParent  删掉试试，打印出来的Result应该是3个0，而不是1  2   3。

　　

　　

　　6.3 任务工厂

　　可以使用任务工厂来批量创建任务

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace thread1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main Thread start!");

            Task<int[]> parentTask = new Task<int[]>(() =>
            {
                var result = new int[3];
                TaskFactory tf = new TaskFactory(TaskCreationOptions.AttachedToParent, TaskContinuationOptions.None);

                // 子任务1
                tf.StartNew(() =>
                {
                    Console.WriteLine("sub task 1 start!");
                    Thread.Sleep(1000);
                    Console.WriteLine("sub task 1 end!");
                    result[0] = 1;
                });

                // 子任务2
                tf.StartNew(() =>
                {
                    Console.WriteLine("sub task 2 start!");
                    Thread.Sleep(1000);
                    Console.WriteLine("sub task 2 end!");
                    result[1] = 2;
                });

                // 子任务3
                tf.StartNew(() =>
                {
                    Console.WriteLine("sub task 3 start!");
                    Thread.Sleep(1000);
                    Console.WriteLine("sub task 3 end!");
                    result[2] = 3;
                });

                return result;
            });

            parentTask.Start();

            Console.WriteLine("Parent Task's Result is :");
            foreach (int result in parentTask.Result)
                Console.Write("{0}\t", result);

            Console.WriteLine();
            Console.WriteLine("Main Thread end!");
            Console.ReadKey(true);
        }
    }
}

　　使用任务工厂与上面3.2中直接定义子任务相比，优势主要在于可以共享子任务的设置，比如在TaskFactory中设置TaskCreationOptions.AttachedToParent，　　那么它启动的子任务都具有这个属性了。

　　当然，任务工厂(TaskFactory)还提供了很多控制子任务的函数，用的时候可以看看它的类定义。

 

7. Parallel并行执行任务

Console.WriteLine("Main Thread start!");
        int max = 10;
         
        // 普通循环
        long start = Stopwatch.GetTimestamp();
        for (int i = 0; i < max; i++)
        {
            Thread.Sleep(1000);
        }
        Console.WriteLine("{0:N0}", Stopwatch.GetTimestamp() - start);
 
        // 并行的循环
        start = Stopwatch.GetTimestamp();
        Parallel.For(0, max, i => { Thread.Sleep(1000); });
        Console.WriteLine("{0:N0}", Stopwatch.GetTimestamp() - start);
 
        Console.WriteLine("Main Thread end!");
        Console.ReadKey(true);

　　

　　Parallel是为了简化任务编程而新增的静态类，利用Parallel可以将平时的循环操作都并行起来

　　在上面的例子中，采用并行循环消耗的时间不到原先的一半。

　　但是，采用并行循环需要满足一个条件，就是for循环中的内容能够并行才行。

　　比如for循环中是个对 循环变量i 进行的累加操作(例如sum += i;)，那就不能使用并行循环。

 

　　还有一点需要注意，Parallel的方法本身有开销。

　　所以如果for循环内的处理比较简单的话，那么直接用for循环可能更快一些。

　　比如将上例中的Thread.Sleep(1000);删掉，再运行程序发现，直接for循环要快很多。