并发编程/线程同步/线程同步深入/线程池/异步编程/Tas任务

一：并发编程：

《1》：进程
通俗的讲，一个exe运行一次就会产生一个进程，一个exe的多个进程之间数据互相隔离。
1.一个进程里至少有一个线程：主线程。我们平时写的控制台程序默认就是单线程的，代码从上往下执行，一行执行完了再执行下一行；
2.什么是多线程：一个人一边烧水一边洗衣服比“先烧水再洗衣服”效率高。同一时刻一个人做多件件事情，只是在“快速频繁切换”，如果处理不当可能比不用多线程效率还低。讨论多线程先只考虑“单核cpu”。
3.普通的代码是从上向下执行的，但是多线程的代码可以“并行”执行，我们可以把“线程”理解成独立的执行单元，线程中的代码可以“并行执行”。线程根据情况被分配给一定的“时间片”来运行，可能一个线程还没执行完，就又要把时间片交给别的线程执行。把要在单独的线程放到一个方法中，然后创建 Thread 对象，运行它，这个 Thread 中的代码就会在单独的线程中执行。
4. 多线程的好处：有很大可能增加系统的运行效率；开发winform程序，避免界面卡；注册后向用户发送欢迎邮件，如果发送邮件很慢的话，避免注册过程很慢。
5. 线程默认是“非后台线程”，一个程序必须所有“非后台线程”执行结束后程序才会退出， 否则看起来好像是主线程退出了，其实进程还没有结束（搞一个winform 程序演示）把线程设置为“后台线程”后，所有“非后台线程”执行结束后程序就会退出，不会等“后台线程”执行结束：
thread.IsBackground = true;
简单的验证：控制台程序，如果不加 t1.IsBackground = true; 是线程执行结束才退出。加上的话就是“闪退”。

二：线程同步

《1》：定义：
线程同步问题就是解决多个线程同时操作一个资源的问题，多个线程对于资源的使用，必须等所有的线程使用完成之后再进行处理
while(th1.IsAlive);操作会大量消耗cpu空转，可以改成th1.Join()就是让当前线程等待th1线程的结束。

    class Program
    {
       static int count = 0;   //定义一个变量
        static void Main(string[] args)
        {
            //实例化一个线程对象用th1表示
            Thread th1 = new Thread(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    count++;
                    Console.WriteLine("th1:" + count);
                    Thread.Sleep(100);   //将当前线程挂起100ms
                }
            });
            th1.Start();   //线程的调用

            Thread th2 = new Thread(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    count++;
                    Console.WriteLine("th2:" + count);
                    Thread.Sleep(100);
                }
            });
            th2.Start();
            while (th1.IsAlive)    //获取当前线程执行状态的值并处于死循环
            {

            }
            while (th2.IsAlive)
            {

            }
            Console.WriteLine(count);     //最终输出结果count
            Console.ReadLine();
        }
    }

《2》：实现：
（1）：Join
原理，等待耗时最长的线程执行完成之后在处理公共资源，给耗时最长的线程调用Join方法
（2）：lock
改用lock解决多个线程同时操作一个资源。lock是C#中的关键字，他要锁定一个资源
lock的特点是：同时只能有一个线程进入lock的对象的范围，其他lock的线程就要等。

class Program
    {
        static int count = 0;    //定义一个静态的变量
        static Object o = new Object();    //新实例化一个静态的object对象
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToLongTimeString());
            //实例化一个线程对象用th1表示
            Thread th1 = new Thread(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    lock (o)    //同时只能有一个线程进入lock的对象的范围，其他lock的线程就要等。
                    {
                        count++;
                    }
                    Console.WriteLine("th1:" + count);
                    Thread.Sleep(100);   //线程休眠时间100ms
                }
            });

            th1.Start();   //启动线程

            Thread th2 = new Thread(() => //Lambda表达式传值   实际上是构建了一个匿名函数 通过函数闭包来传值

            {
                for (int i = 0; i < 10; i++)
                {
                    lock (o)
                    {
                        count++;
                    }
                    Console.WriteLine("th2:" +