C#线程、任务和同步

一、进程和线程的区别

       一个进程可以有多个线程；操作系统的设计可以归结为三点:(1)以多进程形式，允许多个任务同时运行;(2)以线程形式，允许单个任务分成不同的部分运行。(3)提供协调机制，一方面防止进程之间产生冲突，另一方面允许进程之间共享资源。

二、通过委托方式创建线程

       这当中包括3种方式判断线程结束，代码如下：
       Program.cs

class Program
        {
            //一般为比较耗时的操作 开启单独的线程去执行，比如下载操作
            static int Test(int i,string str)
            {
                Console.WriteLine("test" + i + str);
                Thread.Sleep(100);//让当前线程休眠（暂停线程的执行）
                return 100;
            }

            static void Main(string[] args) //在main线程中执行一个线程里面语句执行 是从上到下的
            {
                //1.通过委托 开启一个线程
                //Func<int, string, int> a = Test;
                //IAsyncResult asyncResult = a.BeginInvoke(100, "lYl", null, null); //开启一个新的线程去执行a所引用的方法
                //可以认为线程是同时执行（异步执行）
                //Console.WriteLine("main");
                //检测线程结束，方式一（通过死循环）
                //while (asyncResult.IsCompleted == false) //如果当前线程没有执行完毕
                //{
                //    Console.Write(".");
                //    Thread.Sleep(10);//控制子线程的检测频率
                //}
                //int res = a.EndInvoke(asyncResult); //获取耗时方法的返回值
                //Console.WriteLine(res);

                //检测线程结束，方式二(等待句柄方式)
                //如果1000ms表示超时事件，如果等待了1000毫秒线程还没遇结束，则返回false；如果1000ms内线程结束了，则返回true;
                //bool isEnd = asyncResult.AsyncWaitHandle.WaitOne(1000);//此处等待时间不超过1000ms
                //if (isEnd)
                //{
                //    int res = a.EndInvoke(asyncResult);
                //    Console.WriteLine(res);
                //}

                //检测线程结束，方式3（通过回调 检测线程结束）(最常用的方法)
                Func<int, string, int> a = Test;
                //倒数第二个委托参数表示回调函数，当线程结束的时候会调用这个委托指向的方法
                //倒数第一个参数用来给回调函数传递参数
                //开启一个新的线程去执行 a所引用的方法
                //IAsyncResult asyncResult = a.BeginInvoke(100, "lYl", OnCallBack, a); 
                a.BeginInvoke(100, "lYl", ar =>
                {
                    int res = a.EndInvoke(ar);
                    Console.WriteLine(res);//在Lambda表达式中取得
                },null);
                Console.ReadKey();
            }

            //在回调函数中取得结果
            static void OnCallBack(IAsyncResult ar)
            {
                Func<int,string,int> a = ar.AsyncState as Func<int,string,int>;

                int res = a.EndInvoke(ar);
                Console.WriteLine(res);
            }
        }

三、通过Thread类创建线程

       以下代码包括线程是如何传递参数的两种方式，代码如下：
       MyThread.cs

class MyThread
    {
        private string filename;
        private string filepath;

        public MyThread(string name, string path)
        {
            this.filename = name;
            this.filepath = path;
        }

        public void DownFile()
        {
            Console.WriteLine("开始下载" + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);//休眠
            Console.WriteLine("下载完成" + filename);
        }
    }

       Program.cs

class Program
    {
        //要在线程当中传递参数，参数类型必须为Object类型，而不能是int/string/double等类型
        static void DownloadFile(object filename)
        {
            Console.WriteLine("开始下载" + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            Console.WriteLine("下载完成" + filename);
        }

        static void Main(string args)
        {
            //Thread类的两种创建方式
            //Thread t = new Thread(DownloadFile); //创建出来Thread对象，这个线程并没有启动
            //Thread t = new Thread(
            //{
            //    Console.WriteLine("开始下载" + Thread.CurrentThread.ManagedThreadId);
            //    Thread.Sleep(2000);
            //    Console.WriteLine("下载完成");
            //});
            //t.Start();
            //第一种传递参数方式 1.在函数中的参数，定义为object类；2.然后在Start()方法中传递参数
            //Thread t = new Thread(DownloadFile); //创建线程
            //t.Start("564"); //开启线程
            //第二种传递参数方式 1.定义一个线程类MyThread对象，需要传递的参数放入该对象中，通过定义字段来实现；
            //2.通过定义该类的构造方法来给上述定义字段赋值，从而达到传递参数的目的 3.然后创建普通方法
            MyThread my = new MyThread("122","www.baidu.com");
            //我们构造一个thread对象的时候，既可以传递一个静态方法，也可以传递一个普通方式
            Thread t = new Thread(my.DownFile);
            t.Start();
            Console.WriteLine("Main");
            Console.ReadKey();
        }
    }

四、后台线程和前台线程

       在默认情况下，用Thread类创建的线程是前台线程。线程池中的线程总是后台线程。只有一个前台线程在运行，应用程序的进程就在运行；如果多个前台线程在运行，但是Main()方法结束了，应用程序的进程仍然是运行的，直到所有的前台线程完成其任务为止。在用Thread类创建线程的时候，可以设置IsBackground属性，表示它是一个前台线程还是一个后台线程。
       后台线程用的地方：如果关闭word应用程序，拼写检查器继续运行就没有意义了，在关闭应用程序的时候，拼写检查线程就可以关闭。当所有的前台线程运行完毕，如果还有后台线程运行运行的话，所有的后台线程就会被终止掉。示例如下：

            Thread t = new Thread(DownloadFile);//默认创建的是前台线程
            t.IsBackground = true; //设置为后台线程
            t.Start("123");

五、线程的优先级

       线程有操作系统调度，一个CUP同一时间只能做一件事情（运行一个线程中的计算任务），当有很多线程需要CPU去执行的时候，线程调度器会根据线程的优先级去判断执行哪一个线程，如果优先级相同的话，就使用一个循环调度规则，逐个执行每个线程。在Thread类中，可以设置Priority属性，以影响线程的基本优先级，Priority属性是一个ThreadPriority枚举定义的一个值。定义的级别有Highest、AboveNormal、BelowNomal和Lowest.

六、控制线程

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

七、通过线程池创建线程

       创建线程需要时间。如果有不同的小任务要完成,就可以事先创建许多线程,在应完成这些任务时发出请求。这个线程数最好在需要更多的线程时增加,在需要释放资源时减少。
       不需要自己创建线程池，系统已经有一个ThreadPool类管理线程。这个类会在需要时增减池中线程的线程数,直到达到最大的线程数。池中的最大线程数是可配置的。在双核 CPU中 ,默认设置为1023个工作线程和 1000个 I/O线程。也可以指定在创建线程池时应立即启动的最小线程数,以及线程池中可用的最大线程数。 如果有更多的作业要处理,线程池中线程的个数也到了极限,最新的作业就要排队,且必须等待线程完成其任务
       注意：线程池中的所有线程都是后台线程。如果进程的所有前台线程都结束了,所有的后台线程就会停止。不能把入池的线程改为前台线程。不能给入池的线程设置优先级或名称。入池的线程只能用于时间较短的任务。如果线程要一直运行(如 Word的拼写检查器线程),就应使用Thread类创建一个线程。
       代码示例如下：
       Program.cs:

class Program
    {
        //此处一定要加上一个object类型的参数，用于判断线程的可用状态
        static void ThreadMethod(object state)
        {
            Console.WriteLine("线程开始" + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            Console.WriteLine("线程结束");
        }

        static void Main(string[] args)
        {
            //线程池都是后台线程
            ThreadPool.QueueUserWorkItem(ThreadMethod); //使用QueueUserWorkItem，添加到工作队列中
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            ThreadPool.QueueUserWorkItem(ThreadMethod);
            Console.ReadKey();
        }
    }

八、通过任务开启线程

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

class Program
    {
        //任务相当于对线程进行了封装
        static void ThreadMethod()
        {
            Console.WriteLine("任务开始" + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            Console.WriteLine("任务结束");
        }

        static void Main(string[] args)
        {
            //任务方式一创建线程
            //Task t = new Task(ThreadMethod);//传递一个需要线程去执行的方法
            //t.Start();

            //任务方式二创建线程
            TaskFactory tf = new TaskFactory();
            Task t = tf.StartNew(ThreadMethod);

            Console.WriteLine("Main");
            Console.ReadKey();
        }
    }

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

    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);
    }
    Task t1 = new Task(DoFirst);
    Task t2 = t1.ContinueWith(DoSecond);
    Task t3 = t1.ContinueWith(DoSecond);
    Task t4 = t2.ContinueWith(DoSecond);

       (2)任务层次结构
       我们在一个任务中启动一个新的任务，相当于新的任务是当前任务的子任务，两个任务异步执行，如果父任务执行完了但是子任务没有执行完，它的状态会设置为WaitingForChildrenToComplete，只有子任务也执行完了，父任务的状态就变成RunToCompletion。示例代码如下：

    static void Main(){
        var parent = new Task(ParentTask);
        parent.Start();
        Thread.Sleep(2000);
        Console.WriteLine(parent.Status);
        Thread.Sleep(4000);
        Console.WriteLine(parent.Status);
        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 ");
    }

九、线程争用条件和死锁

       （1）线程争用条件
       MyThreadObject.cs:

    class MyThreadObject
    {
        private int state = 5;

        public void ChangeState()
        {
            state++;
            if (state == 5)
            {
                Console.WriteLine("state = 5");
            }
            state = 5;
        }
    }

       Program.cs

    class Program
    {
        static void ChangeState(object o)
        {
            MyThreadObject m = o as MyThreadObject;
            while (true)
            {
                //向系统申请可不可以锁定m对象 如果m对象没有被锁定，那么可以；
                //如果m对象被锁定，则会暂停，直到申请到m对象
                lock (m) //只能锁定引用类型，不能锁定值类型
                {
                    m.ChangeState();
                }
            }
        }
        static void Main(string[] args)
        {
            MyThreadObject m = new MyThreadObject();
            Thread t = new Thread(ChangeState);
            t.Start(m);
            new Thread(ChangeState).Start(); 
        }
    }

       (2)死锁
       解决方法：在编程的开始设计阶段，就设计锁定顺序
       代码示例：

public class SampleThread
 {
    //由于s1,s2在不同的方法，锁定的顺序不一样，就可能会导致死锁
    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){ //此处可能会导致死锁
                lock(s2){
                    s1.ChangeState(i);
                    s2.ChangeState(i);
                    i++;
                    Console.WriteLine("Running i : "+i);
                }
            }
        }
    }
    public void Deadlock2(){
        int i =0;
        while(true){
            lock(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();