《CLR via C#》第二十六,二十七章

今天药忘吃喽~ 2021-06-26 16:06 420阅读 0赞

## 第二十六章《线程基础》 ##

*  windows为什么要支持线程
 *  线程开销
 *  停止疯狂
 *  CPU发展趋势
 *  CLR线程和Windows线程
 *  使用专用线程执行异步的计算限制操作
 *  使用线程的理由
 *  线程调度和优先级
 *  前台线程和后台线程

### 26.1 windows为什么要支持线程 ###

当操作系统没有线程的概念的时候，整个计算机只运行一个**执行线程**（单核CPU），其中包括了操作系统和各种应用代码，一旦一个长时间运行的程序占用了线程，或者应用程序产生Bug开始了无限死循环，那整个机器就会被冻结，这个时候，网管都会过来告诉你，重启一下就好了，这不是没有道理！

这个时候微软想了个办法，那就是决定在一个进程中，执行多个线程，进程就相当于工厂的车间一样，是线程（人）使用资源的集合，既然是车间肯定就需要分配虚拟地址空间。这样就确保了其他的进程无法使用该进程的代码和数据。下面采用图文并茂的方式来描述一下线程和进程的关系:

**1. 计算机的核心是CPU，它承担了所有的计算任务，它就像一座工厂，时刻在运行**

**2. 由于该工厂的电力有限，一次只能给工厂的一个车间供电，一个车间开工的时候，所有车间都要停工，背后的含义就是26.1的第一段话，单核CPU一次只能运行一个任务。**

**3. 进程就好比工厂的车间，它代表CPU所能处理的单个任务。车间的种类分工各有不同，但是如上所说，因为电量不足，所以该效率底下的工厂总是只能运行一个车间**

**4. 一个车间里，可以有很多人，他们同时执行的同一个任务**

**5. 线程就好比车间里的工人，一个车间可以有多个工人，就好像一个进程可以有多个线程一样**

**6. 每一个车间的地方都是共享的，这意味着所有的工人都可以自由的进出，就好像每一个进程的虚拟地址空间是共享的，每个线程都可以使用这些**

**7. 可是，每间房间的大小不同，容纳的人也不同，就好比厕所一样，一旦有人占着茅坑，其他人就得等他拉完屎了，这就好像一个线程占用了某个内存地址，其他线程就乖乖等着吧**

**8. 当然了，有的地方特别的抢手，就好像图7的厕所，计算机有一个防止别人进入的简单方法，就是给工人配一把锁，当多个工人抢厕所的时候，允许一个工人去上厕所，然后把门锁上，防止你上厕所上着上着有人就推门进来了。这就好像计算机中的“互斥锁”，防止多个线程同时读写某一块内存地址**

**9. 操作系统的设计，可以归结为三点：**

1.  以多进程的形式，允许多个任务同时执行（多个工厂）
2.  以多线程的形式，允许单个任务被多个线程运行（一个车间完成的工作量由多个工人共同完成）
3.  提供协调机制，比如“互斥锁”，一方面防止进程之间和线程之间产生冲突，另一方面允许进程和线程共享CPU资源

### 26.2 线程开销 ###

线程比作工人，就需要给工人工作环境和支配工资，所以线程务必会占用进程的虚拟内存地址和执行性能上的开销。

### 26.3 停止疯狂 ###

如果只关心线程，那么机器最优的线程数就是该机器的CPU数，比如四核CPU最优的就是每个进程里面有四个线程，Windows默认给每个线程分配线程栈的内存是`1M`，现在打开任务管理器，你可以看看你的`RAM`是不是早就不够用了

### 26.4 CPU发展趋势 ###

谁都知道，如果一个进程可以有多个线程（每个线程其实都分配了CPU内核，就相当于一个虚拟CPU）来执行，那速度一定很快。就好像一个车间，多加几个工人来完成车间工作，时间一定会更快，所以在更新迭代的计算机领域，都是由：

*  多个CPU  
    给一个计算机安装多个CPU，就是在机箱上多插几个CPU，但是这样主板也要求更大，机箱也会更大，所以其体积和价格都不理想
 *  超线程芯片  
    我的理解是超线程芯片其实是假的双核芯片，在Windows上，看起来就像是安装了两个CPU一样，但芯片每次都只能执行一个线程。并不是两个线程同时并发运行的，Windows先只运行一个线程，然后在忙里偷闲，去运行其他的线程
 *  多核芯片  
    广为使用的八核芯片说的就是这个东西，八核，八个CPU，每个车间的空间更大，一下可以容纳8个工人来共同完成该车间任务

### 26.5 CLR线程和`Windows`线程 ###

略

### 26.6 使用专用线程执行异步操作的计算限制操作 ###

//构造thread对象
    class ThreadTest 
    { 
      static void Main() { 
        Thread t = new Thread (WriteY);
        t.Start();                          // Run WriteY on the new thread
        while (true) Console.Write ("x");   // Write 'x' forever
      }
      
      static void WriteY() { 
        while (true) Console.Write ("y");   // Write 'y' forever
      }
    }

### 26.7 使用线程的理由 ###

*  可响应性（对于图形化应用程序）  
    灵敏的响应用户想要执行的Button操作，是因为使用了独立的线程来完成该操作
 *  性能（对于客户端和服务器应用程序）  
    同时执行多个操作性能能不好么，废话~

### 26.8 线程调度和优先级 ###

略

### 26.9前台线程和后台线程 ###

应用程序：必须运行完所有的前台程序才可以退出，一般都是主线程（尽量避免使用）  
后台程序：不考虑是否已经运行完毕就可以直接退出

public static void myStaticThreadMethod()
    { 
        Thread.Sleep(3000);
    }
    Thread thread = new Thread(myStaticThreadMethod);
    // thread.IsBackground = true;//注释去掉，因为没有前台线程的存在，程序会立即退出！
    thread.Start()

--------------------

## 第二十七章《计算限制的异步操作》 ##

*  CLR线程池基础
 *  执行简单的计算限制操作
 *  执行上下文
 *  协作式取消和超时
 *  任务
 *  `Parallel`的静态`For`，`Foreach`和`INvoke`方法
 *  并行语言集成查询（`PLINQ`）
 *  执行定时的计算限制操作
 *  线程池如何管理线程

### 27.1 线程池基础 ###

CLR初始化的时候，线程池是没有任何线程的，当应用程序执行某一个异步回调函数的时候，会调用某个方法，将一个记录项丢到线程池里面（其实是把该纪录项给线程池的一个线程类似托管），它的优势就在于当线程池的线程完成任务之后，它会返回到线程池中，并等待下一次响应。当然最后这样会囤积一大堆什么也不做的线程，放心，它会自我检查，并自动销毁的

### 27.2 执行简单的计算限制操作 ###

将一个异步的、计算限制的操作放到一个线程池的队列中，通常可以调用`ThreadPool`类定义的以下方法之一：

//将方法排入队列以便执行。此方法在有线程池线程变得可用时执行。
    static Boolean QueueUserWorkItem(WaitCallback callBack);
    //将方法排入队列以便执行，并指定包含该方法所用数据的对象。此方法在有线程池线程变得可用时执行。
    static Boolean QueueUserWorkItem(WaitCallback callBack,Object state);

这些方法向线程池的队列中添加一个"工作项"(`work item`)以及可选的状态数据， 如果此方法成功排队，则为 `true`；如果无法将该工作项排队，则引发 `OutOfMemoryException`。工作项其实就是由`callBack`参数标识的一个方法，该方法将由线程池线程调用。可通过`state`实参(状态数据)向方法传递一个参数。无`state`参数的那个版本的`QueueUserWorkItem`则向回调方法传递`null`。最终，池中的某个线程会处理工作项，造成你指定的方法被调用。你写的回调方法必须匹配`System.Threading.WaitCallBack`委托类型，它的定义如下：

delegate void WaitCallback(Object state);
    class Program
        { 
            static void Main(string[] args)
            { 
                Console.WriteLine("Main thread: queuing an asynchronous operation");
                ThreadPool.QueueUserWorkItem(ComputeBoundOp, 5);
                Console.WriteLine("Main thread: Doing other work here...");
                Thread.Sleep(10000);  // 模拟其它工作 (10 秒钟)
                //Console.ReadLine();
            }
     
            // 这是一个回调方法，必须和WaitCallBack委托签名一致
            private static void ComputeBoundOp(Object state)
            { 
                // 这个方法通过线程池中线程执行
                Console.WriteLine("In ComputeBoundOp: state={0}", state);
                Thread.Sleep(1000);  // 模拟其它工作 (1 秒钟)
     
                // 这个方法返回后，线程回到线程池，等待其他任务
            }
        }

### 27.3 执行上下文 ###

向`CLR`的线程池队列添加一个工作项的时候，如何通过阻止执行上下文的流动来影响线程逻辑调用上下文中的数据：

class Program
        { 
            static void Main(string[] args)
            { 
                // 将一些数据放到Main线程的逻辑调用上下文中
                CallContext.LogicalSetData("Name", "Jeffrey");
     
                // 线程池能访问到逻辑调用上下文数据，加入到程序池队列中
                ThreadPool.QueueUserWorkItem(
                   state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));
     
     
                // 现在阻止Main线程的执行上下文流动
                ExecutionContext.SuppressFlow();
     
                //再次访问逻辑调用上下文的数据
                ThreadPool.QueueUserWorkItem(
                   state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));
     
                //恢复Main线程的执行上下文流动
                ExecutionContext.RestoreFlow();
     
                //再次访问逻辑调用上下文的数据
                ThreadPool.QueueUserWorkItem(
                   state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));
                Console.Read();
            }
        }

得到的结果：

Name=Jeffrey
    Name=   //被组织的线程不在执行上下文
    Name=Jeffrey

### 27.4 协作式取消和超时 ###

### 27.5 任务 ###