C#学习笔记【十二】—— 线程、任务和同步

线程：
对于所有需要等待的操作，例如移动文件，数据库和网络访问都需要一定的时间，此时就可以启动一个新的线程，同时完成其他任务。一个进程的多个线程可以同时运行在不同的CPU上或多核CPU的不同内核上。

线程是程序中独立的指令流。在VS编辑器中输入代码的时候，系统会分析代码，用下划线标注遗漏的分号和其他语法错误，这就是用一个后台线程完成。Word文档需要一个线程等待用户输入，另一个线程进行后台搜索，第三个线程将写入的数据存储在临时文件中。运行在服务器上的应用程序中等待客户请求的线程成为侦听器线程。

进程包含资源，如Window句柄，文件系统句柄或其他内核对象。每个进程都分配的虚拟内存。一个进程至少包含一个线程。

一个应用程序启动，一般会启动一个进程，然后进程启动多个线程。
进程与线程：

1. 计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。
2. 如果工厂的电力有限一次只能供给一个车间使用。也就是说一个车间开工的时候，其他车间就必须停工。背后的含义就是。单个CPU一次只能运行一个任务。（多核CPU可以运行多个任务）
3. 进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。
4. 一个车间里，可以有很多工人，他们协同完成一个任务。
5. 线程就好比车间里的工人。一个进程可以包括多个线程。
6. 车间的控件是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享空间。
7. 进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。
8. 一个防止他人进入的简单方法，就是门口加一把锁（厕所）。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫"互斥锁"（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。
9. 还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。
10. 这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做"信号量"（Semaphore），用来保证多个线程不会互相冲突。
    不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。
11. 操作系统的设计，因此可以归结为三点：
    （1）以多进程形式，允许多个任务同时运行；
    （2）以多线程形式，允许单个任务分成不同的部分运行；
    （3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间

12.1线程的开启方式

12.1.1异步委托

创建线程的一种简单方式是定义一个委托,并异步调用它。 委托是方法的类型安全的引用。Delegate类还支持异步地调用方法。在后台,Delegate类会创建一个执行任务的线程。

namespace c_sharp_practice08
{
    class Program
    {
        //一般我们会为比较耗时的操作开启单独的线程，比如下载操作
        static void Test1(int i,string str)
        {
            Console.WriteLine("test1"+i+str);
        }
        static int Test2(int i, string str)
        {
            Console.WriteLine("test2" + i + str);
            Thread.Sleep(100);
            return 100;
        }
        static void Main(string[] args)//在main线程中执行
        {
            //一个线程中语句的执行是从上到下的

            // 1.通过委托开启一个线程
            //Action<int,string> a = Test1;
            //a.BeginInvoke(999,"Lemon",null,null);//开启一个新线程区执行a引用的方法
            //可以认为线程是同时执行的（异步执行）
            Func<int, string, int> a = Test2;
            IAsyncResult ar=a.BeginInvoke(999, "Lemon", null, null);//IAsyncResult可以取得当前线程的状态
            Console.WriteLine("main");
            while (ar.IsCompleted == false)//如果当前线程没有执行完毕
            {
                Console.Write(".");
                Thread.Sleep(10);//控制线程的检测频率
            }
            int res = a.EndInvoke(ar);//取得异步线程的返回值
            Console.WriteLine(res);
            Console.ReadKey();
        }
    }
}

检测线程结束的方式：

当我们通过BeginInvoke开启一个异步委托的时候，返回的结果是IAsyncResult，我们可以通过它的AsyncWaitHandle属性访问等待句柄。这个属性返回一个WaitHandler类型的对象，它中的WaitOne（）方法可以等待委托线程完成其任务，WaitOne方法可以设置一个超时时间作为参数（要等待的最长时间），如果发生超时就返回false。

namespace c_sharp_practice08
{
    class Program
    {
        //一般我们会为比较耗时的操作开启单独的线程，比如下载操作
        static int Test2(int i, string str)
        {
            Console.WriteLine("test2" + i + str);
            Thread.Sleep(100);
            return 100;
        }
        static void Main(string[] args)//在main线程中执行
        {
            //一个线程中语句的执行是从上到下的

            // 1.通过委托开启一个线程
            //可以认为线程是同时执行的（异步执行）
            Func<int, string, int> a = Test2;
            IAsyncResult ar=a.BeginInvoke(999, "Lemon", null, null);//IAsyncResult可以取得当前线程的状态
            Console.WriteLine("main");

            //检测线程结束
            bool isEnd = ar.AsyncWaitHandle.WaitOne(1000);//等待线程结束，设置超时间1000ms
            if (isEnd)
            {
                int res = a.EndInvoke(ar);
                Console.WriteLine(res);
            }
            Console.ReadKey();
        }
    }
}

等待委托的结果的第3种方式是使用异步回调。在BeginInvoke的第三个参数中，可以传递一个满足AsyncCallback委托的方法，AsyncCallback委托定义了一个IAsyncResult类型的参数其返回类型是void。对于最后一个参数，可以传递任意对象，以便从回调方法中访问它。（我们可以设置为委托实例，这样就可以在回调方法中获取委托方法的结果）

namespace c_sharp_practice08
{
    class Program
    {
        //一般我们会为比较耗时的操作开启单独的线程，比如下载操作
        static int Test2(int i, string str)
        {
            Console.WriteLine("test2" + i + str);
            Thread.Sleep(100);
            return 100;
        }
        static void Main(string[] args)//在main线程中执行
        {
            //通过回调检测线程结束
            Func<int, string, int> a = Test2;
            IAsyncResult ar=a.BeginInvoke(999, "Lemon", OnCallBack, a);//倒数第二个参数是一个委托类型的参																		数，表示回调函数
                                                                       //（当线程结束的时候会调用这个委托指																	向的方法）
                                                                       //倒数第一个参数用来给回调函数传递数																	据
            Console.ReadKey();
        }
        static void OnCallBack(IAsyncResult ar)
        {
            //Console.WriteLine("子线程结束");
            Func<int, string, int> a = ar.AsyncState as Func<int, string, int>;
            int res = a.EndInvoke(ar);
            Console.WriteLine(res+"在回调函数中取得结果");
        }
    }
}

            a.BeginInvoke(999, "Lemon",ar=> {
                int res = a.EndInvoke(ar);
                Console.WriteLine(res + "在Lambda表达式中取得结果");
            },null);

12.1.2 Thread类

使用Thread类可以创建和控制线程。Thread构造函数的参数是一个无参无返回值的委托类型。

static void Main(){
		var t1 = new Thread(ThreadMain);
		t1.Start();
		Console.WriteLine("This is the main thread.");
	}
	static void ThreadMain(){
		Console.WriteLine("Running in a thread.");
	}

在这里哪个先输出是无法保证了线程的执行有操作系统决定，只能知道Main线程和分支线程是同步执行的。在这里给Thread传递一个方法，调用Thread的Start方法，就会开启一个线程去执行，传递的方法。

上面直接给Thread传递了一个方法，其实也可以传递一个Lambda表达式。(委托参数的地方都可以使用Lambda表达式)

static void Main(){
		var t1 = new Thread( ()=>Console.WriteLine("Running in a thread, id : 	"+Thread.CurrentThread.ManagedThreadId) );
		t1.Start();
		Console.WriteLine("This is the main Thread . ID : 	"+Thread.CurrentThread.ManagedThreadId)
	}

给线程传递一些数据可以采用两种方式，一种方式是使用带ParameterizedThreadStart委托参数的Thread构造函数，一种方式是创建一个自定义的类，把线程的方法定义为实例方法，这样就可以初始化实例的数据，之后启动线程。

namespace c_sharp_practice09_通过Thread发起线程
{
    class MyThread
    {
        private string fileName;
        private string filePath;

        public MyThread(string fileName,string filePath)
        {
            this.fileName = fileName;
            this.filePath = filePath;
        }

        public void DownloladFile()
        {
            Console.WriteLine("开始下载"+filePath+fileName);
            Thread.Sleep(2000);
            Console.WriteLine("下载结束");
        }
    }
}
namespace c_sharp_practice09_通过Thread发起线程
{
    class Program
    {
        static void DownloadFile(object fileName)
        {
            Console.WriteLine("开始下载"+Thread.CurrentThread.ManagedThreadId+fileName);//可以获取当前线程的ID
            Thread.Sleep(2000);
            Console.WriteLine("下载结束");
        }
        static void Main(string[] args)
        {
            用Lambda表达式的方式
            //Thread t = new Thread(() =>
            //{
            //    Console.WriteLine("开始下载" + Thread.CurrentThread.ManagedThreadId);//可以获取当前线程的ID
            //    Thread.Sleep(2000);
            //    Console.WriteLine("下载结束");
            //});
            //t.Start();

            Thread t = new Thread(DownloadFile);//创建Thread对象，这个线程并没有启动
            t.Start("xxx.种子");//开始执行线程,可以给线程传递参数
            Console.WriteLine("main");

            //传递数据的另一种方式-创建一个对象
            MyThread my = new MyThread("xxx.bt", "http://www.xxx.bbs");
            Thread tt = new Thread(my.DownloladFile);//构造Thread对象时，可以传递一个静态方法，也可以传递一个普通方法
            tt.Start();
            Console.ReadKey();
        }
    }
}

前台线程和后台线程：

只要有一个前台线程在运行，应用程序的进程就在运行，如果多个前台线程在运行，但是Main方法结束了，应用程序的进程仍然是运行的，直到所有的前台线程完成其任务为止。当所有的前台线程运行完毕，如果还有后台线程运行的话，所有的后台线程会被终止掉。

在默认情况下，用Thread类创建的线程是前台线程。线程池中的线程总是后台线程。

在用Thread类创建线程的时候，可以设置IsBackground属性，表示它是一个前台线程还是一个后台线程。

namespace c_sharp_practice09_通过Thread发起线程
{
    class Program
    {
        static void DownloadFile(object fileName)
        {
            Console.WriteLine("开始下载"+Thread.CurrentThread.ManagedThreadId+fileName);//可以获取当前线程的ID
            Thread.Sleep(2000);
            Console.WriteLine("下载结束");
        }
        static void Main(string[] args)
        {
            Thread t = new Thread(DownloadFile);//默认创建一个前台线程
            t.IsBackground = true;//设置为后台线程
            t.Start("xxx.种子");//开始执行线程,可以给线程传递参数
        }
    }
}

线程的优先级：

线程由操作系统调度，一个CPU同一时间只能做一件事情（运行一个线程中的计算任务），当有很多线程需要CPU去执行的时候，线程调度器会根据线程的优先级去判断先去执行哪一个线程，如果优先级相同的话，就使用一个循环调度规则，逐个执行每个线程。

在Thead类中，可以设置Priority属性，以影响线程的基本优先级 ,Priority属性是一个ThreadPriority枚举定义的一个值。定义的级别有Highest ,AboveNormal,BelowNormal 和 Lowest。

控制线程：

1. 获取线程的状态（Running还是Unstarted），当我们通过调用Thread对象的Start方法，可以创建线程，但是调用了Start方法之后，新线程不是马上进入Running状态，而是出于Unstarted状态，只有当操作系统的线程调度器选择了要运行的线程，这个线程的状态才会修改为Running状态。我们使用Thread.Sleep()方法可以让当前线程休眠进入WaitSleepJoin状态。
2. 使用Thread对象的Abort()方法可以停止线程。调用这个方法，会在终止要终止的线程中抛出一个ThreadAbortException类型的异常，我们可以try catch这个异常，然后在线程结束前做一些清理的工作。
3. 如果需要等待线程的结束，可以调用Thread对象的Join方法，表示把Thread加入进来，停止当前线程，并把它设置为WaitSleepJoin状态，直到加入的线程完成为止。

12.1.3线程池

创建线程需要时间。 如果有不同的小任务要完成,就可以事先创建许多线程 , 在应完成这些任务时发出请求。 这个线程数最好在需要更多的线程时增加,在需要释放资源时减少。

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

namespace c_sharp_practice09_线程池
{
    class Program
    {
        static void ThreadMethod(object state)
        {
            Console.WriteLine("线程开始"+Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            Console.WriteLine("线程结束");        }
        static void Main(string[] args)
        {
            ThreadPool.QueueUserWorkItem(ThreadMethod);//开启一个工作线程（必须要有参数）
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            Console.ReadKey();
        }
    }
}

示例应用程序首先要读取工作线程和I/o线程的最大线程数,把这些信息写入控制台中。接着在 for循环中,调用ThreadPool.QueueUserWorkItem方法,传递一个WaitCallBack类型的委托 ,把 JobForAThread方法赋予线程池中的线程。 线程池收到这个请求后,就会从池中选择一个线程 来调用该方法。如果线程池还没有运行,就会创建一个线程池,并启动第一个线程。 如果线程池己经在运行,且有一个空闲线程来完成该任务,就把该作业传递给这个线程。

使用线程池需要注意的事项：

1. 程池中的所有线程都是后台线程。如果进程的所有前台线程都结束了,所有的后台线程就会停止。不能把入池的线程改为前台线程。
2. 不能给入池的线程设置优先级或名称。
3. 入池的线程只能用于时间较短的任务。如果线程要一直运行(如 Word的拼写检查器线程),就应使用Thread类创建一个线程。

12.1.4任务

在.NET4 新的命名空间System.Threading.Tasks包含了类抽象出了线程功能，在后台使用的ThreadPool进行管理的。任务表示应完成某个单元的工作。这个工作可以在单独的线程中运行，也可以以同步方式启动一个任务。任务也是异步编程中的一种实现方式。

namespace c_sharp_practice09_任务
{
    class Program
    {
        static void ThreadMethod()
        {
            Console.WriteLine("任务开始" );
            Thread.Sleep(2000);
            Console.WriteLine("任务结束");
        }
        static void Main(string[] args)
        {
            //开启任务的方式1
            Task t1 = new Task(ThreadMethod);
            t1.Start();

            //开启任务的方式2
            TaskFactory tf = new TaskFactory();
            Task t2 = tf.StartNew(ThreadMethod);
            Console.ReadKey();
        }
    }
}

连续任务：

如果一个任务t1的执行是依赖于另一个任务t2的，那么就需要在这个任务t2执行完毕后才开始执行t1。这个时候我们可以使用连续任务。

namespace c_sharp_practice09_任务
{
    class Program
    {
        static void DoFirst()
        {
            Console.WriteLine("do  in task : " + Task.CurrentId);
            Thread.Sleep(3000);
        }
        static void DoSecond(Task t)
        {
            Console.WriteLine("task " + t.Id + " finished.");
            Console.WriteLine("this task id is " + Task.CurrentId);
            Thread.Sleep(3000);
        }

        static void Main(string[] args)
        {
            Task t1 = new Task(DoFirst);
            Task t2 = t1.ContinueWith(DoSecond);
            Task t3 = t1.ContinueWith(DoSecond);
            Task t4 = t2.ContinueWith(DoSecond);
            t1.Start();

            //Task t5 = t1.ContinueWith(DoError, TaskContinuationOptions.OnlyOnFaulted);

            Console.ReadKey();
        }
    }
}

任务层次结构：

我们在一个任务中启动一个新的任务，相当于新的任务是当前任务的子任务（线程没有父子关系），两个任务异步执行，如果父任务执行完了但是子任务没有执行完，它的状态会设置为WaitingForChildrenToComplete，只有子任务也执行完了，父任务的状态就变成RunToCompletion

namespace c_sharp_practice09_任务
{
    class Program
    {

        static void Main(string[] args)
        {
            var parent = new Task(ParentTask);
            parent.Start();
            Thread.Sleep(2000);
            Console.WriteLine(parent.Status);
            Thread.Sleep(4000);
            Console.WriteLine(parent.Status);
            Console.ReadKey();

            Console.ReadKey();
        }
        static void ParentTask()
        {
            Console.WriteLine("task id " + Task.CurrentId);
            var child = new Task(ChildTask);
            child.Start();
            Thread.Sleep(1000);
            Console.WriteLine("parent started child , parent end");
        }
        static void ChildTask()
        {
            Console.WriteLine("child");
            Thread.Sleep(5000);
            Console.WriteLine("child finished ");
        }
    }
}

12.2线程问题

12.2.1争用条件

namespace c_sharp_practice09_线程问题
{
    class MyThreadObject
    {
        private int state = 5;

        public void ChangeState()
        {
            state++;
            if (state == 5)
            {
                Console.WriteLine("state=5");
                state = 5;
            }
        }
    }
}
namespace c_sharp_practice09_线程问题
{
    class Program
    {
        static void ChangeState(object o)
        {
            MyThreadObject m = o as MyThreadObject;
            while (true)
            {
                m.ChangeState();
            }
        }
        static void Main(string[] args)
        {
            MyThreadObject m = new MyThreadObject();
            Thread t = new Thread(ChangeState);
            t.Start(m);
            new Thread(ChangeState).Start(m);//两个线程同时访问修改一个内存区域，可能使结果出错（输出了stste=5）
            Console.ReadKey();
        }
    }
}
使用lock锁解决争用条件的问题
namespace c_sharp_practice09_线程问题
{
    class Program
    {
        static void ChangeState(object o)
        {
            MyThreadObject m = o as MyThreadObject;
            lock (m)//向系统申请可不可以锁定m对象
                    //如果m对象没有被锁定，那么可以
                    //如果m对象已被锁定，那么这个语句会暂停，直到申请到m对象
            {
                m.ChangeState();//在同一时刻只有一个线程在访问该方法
            }//释放对m的锁定
        }
        static void Main(string[] args)
        {
            MyThreadObject m = new MyThreadObject();
            Thread t = new Thread(ChangeState);
            t.Start(m);
            new Thread(ChangeState).Start(m);//两个线程同时访问修改一个内存区域，可能使结果出错（输出了stste=5）
            Console.ReadKey();
        }
    }
}

12.2.2死锁

死锁是由于在使用lock锁时，不同任务中锁定对象的顺序不同，可能使多个对象同时锁定，使程序一直处于等待状态。

解决死锁的方法是，在编程的开始设计阶段，设计锁定顺序。

public class SampleThread
{
    private StateObject s1;
    private StateObject s2;
    public SampleThread(StateObject s1, StateObject s2)
    {
        this.s1 = s1;
        this.s2 = s2;
    }
    public void Deadlock1()
    {
        int i = 0;
        while (true)
        {
            lock (s1)//锁s1，如果此时Deadlock2中锁定了s2，那么程序就会一直处于等待状态
            {
                lock (s2)
                {
                    s1.ChangeState(i);
                    s2.ChangeState(i);
                    i++;
                    Console.WriteLine("Running i : " + i);
                }
            }
        }
    }
    public void Deadlock2()
    {
        int i = 0;
        while (true)
        {
            lock (s2)//锁定s2
            {
                lock (s1)
                {
                    s1.ChangeState(i);
                    s2.ChangeState(i);
                    i++; Console.WriteLine("Running i : " + i);
                }
            }
        }
    }
}
var state1 = new StateObject();
var state2 = new StateObject();
new Task(new SampleTask(s1, s2).DeadLock1).Start();
new Task(new SampleTask(s1, s2).DeadLock2).Start();