BSP Day54

今天开始呢，就开始学习线程了。接下来就分享下今天的收获：

线程的起源

线程”一词于 1967 年左右被首次提出，是计算机硬件和软件发展过程中诞生的产物。

一台计算机所能利用的资源总是有限的，比如 CPU 在 1 秒钟之内最多执行 1 亿条指令，计算机一共有 1GB 的内存空间等等。因此，“如何提高计算机资源的利用率”是人们一直思考的问题，这个问题也一直带动着计算机硬件和软件的发展。

计算机诞生初期，任何安装任何操作系统和软件，只能运行机器指令，完成一些简单的数学运算。受到当时价格因素的制约，计算机并不普及，拥有者主要是政府、大型机构和公司，一台计算机往往由多个用户共同使用。计算机由专人负责操控，如果有用户想让计算机运行一段指令，必须先将指令输入到打孔卡（一种存储设备）中，然后交给计算机管理员，由计算机管理员负责将指令输入到计算机中执行。

随着对计算机资源利用率的要求不断提升，人们逐渐发现，计算机资源的利用率受管理员的影响非常大。例如，计算机每执行完一个任务，都要等待管理员输入下一个任务，期间很多硬件资源（比如 CPU、某些输入输出设备）都处于空闲状态。

为此，人们设计出了批处理操作系统，由它代替计算机管理员完成任务的切换工作。当计算机执行完某一任务时，批处理系统会自动将下一个要执行的任务输入到计算机中，缩减了任务切换所花费的时间，提高了计算机资源的利用率。

渐渐地人们又发现，批处理系统操控计算机执行的过程中，计算机的 CPU 资源仍经常处于空闲状态。举个例子，当执行中的程序进行 I/O 操作时，CPU 只能等待其 I/O 操作完成后继续工作，这段时间内 CPU 就处于空闲状态。

在批处理系统（又称单道批处理操作系统）的基础上，人们又设计出了功能更强大的多道批处理操作系统。和先前的系统相比，多道批处理系统主要有以下两点优势：

它将计算机的内存分成很多区域，每个区域都可以存储一个程序；

当执行的程序执行 I/O 操作时，操作系统会将 CPU 资源分配给其它等待执行的程序。

也就是说，多道批处理操作系统可以“同时”执行多个程序，这样的操作系统又称多任务操作系统。为了使多任务系统更高效地完成计算机资源的分配和回收，便于管理各个程序的执行过程，人们提出了“进程”的概念。

所谓进程，指的就是正在执行的应用程序。多任务操作系统可以控制各个进程的执行状态，例如终止某个正在执行的进程，启动某个暂停执行的进程等。操作系统负责为每个进程分配独立的内存空间和其它所需资源（例如 I/O 设备、文件等），进程执行完毕后，操作系统会将进程占用的资源全部回收。

早期的多任务操作系统，以进程为单位管理各个程序的运行以及计算机资源的分配和回收，进一步提高了计算机资源的利用率。但随着计算机硬、软件的发展，人们发现还可以做进一步优化，例如：

操作系统将 CPU 资源从一个进程分配给另一个进程时，开销较大；

各个进程占用的内存空间是相互独立的，大大增加了进程间通信的实现难度；

一个进程可能会执行多个任务，当某个任务因 I/O 操作暂停执行时，其他任务将无法执行。

在计算机软、硬件快速发展，人们计算机运行效率的要求越来越高的大背景下，“线程”应运而生。

什么是线程？

我们知道，一个进程指的是一个正在执行的应用程序。线程对应的英文名称为“thread”，它的功能是执行应用程序中的某个具体任务，比如一段程序、一个函数等。

线程和进程之间的关系，类似于工厂和工人之间的关系，进程好比是工厂，线程就如同工厂中的工人。一个工厂可以容纳多个工人，工厂负责为所有工人提供必要的资源（电力、产品原料、食堂、厕所等），所有工人共享这些资源，每个工人负责完成一项具体的任务，他们相互配合，共同保证整个工厂的平稳运行。

每个进程执行前，操作系统都会为其分配所需的资源，包括要执行的程序代码、数据、内存空间、文件资源等。一个进程至少包含 1 个线程，可以包含多个线程，所有线程共享进程的资源，各个线程也可以拥有属于自己的私有资源。

进程仅负责为各个线程提供所需的资源，真正执行任务的是线程，而不是进程。

下图描述了进程和线程之间的关系：

如图所示，所有线程共享的进程资源有：

• 代码：即应用程序的代码；
• 数据：包括全局变量、函数内的静态变量、堆空间的数据等；
• 进程空间：操作系统分配给进程的内存空间；
• 打开的文件：各个线程打开的文件资源，也可以为所有线程所共享，例如线程 A 打开的文件允许线程 B 进行读写操作。

各个线程也可以拥有自己的私有资源，包括寄存器中存储的数据、线程执行所需的局部变量（函数参数）等。

为什么要引入线程？ 

 早期的操作系统都是以进程作为独立运行的基本单位的，直到后期计算机科学家们又提出了更小的能独立运行的基本单位，也就是线程。这就好比物理学家研究物质组成一样：先发现了分子，然后继续细分发现原子，再后来是原子核和电子、夸克等等。

那么，为什么要引入线程呢？我们只需要记住这句话：线程又称为迷你进程，但是它比进程更容易创建，也更容易撤销。

从上文我们知道，进程是拥有资源的基本单位，而且还能够进行独立调度，这就犹如一个随时背着粮草的士兵，这必然会造成士兵的执行命令（战斗）的速度。所以，一个简单想法就是：分配两个士兵执行同一个命令：一个负责携带所需粮草随时供给，另一个士兵负责执行命令（战斗）。这就是线程的思想，轻装上阵的士兵就是线程。

用严谨的语言描述来说就是：由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，需要较大的时空开销，限制了并发程度的进一步提高。为减少进程切换的开销，把进程作为资源分配单位和调度单位这两个属性分开处理，即进程还是作为资源分配的基本单位，但是不作为调度的基本单位（很少调度或切换），把调度执行与切换的责任交给线程，即线程成为独立调度的基本单位，它比进程更容易（更快）创建，也更容易撤销。

记住这句话！引入线程前，进程是资源分配和独立调度的基本单位。引入线程后，进程是资源分配的基本单位，线程是独立调度的基本单位。

线程的优缺点：

线程的特征和进程差不多，进程有的他基本都有，比如：

• 线程具有就绪、阻塞、运行三种基本状态，同样具有状态之间的转换关系；
• 线程间可以并发执行
• 在多 CPU 环境下，各个线程也可以分派到不同的 CPU 上并行执行

线程的优点：

• 一个进程中可以同时存在多个线程，这些线程共享该进程的资源。进程间的通信必须请求操作系统服务（因为 CPU 要切换到内核态），开销很大。而同进程下的线程间通信，无需操作系统干预，开销更小。
  不过，需要注意的是：从属于不同进程的线程间通信，也必须请求操作系统服务。
• 线程间的并发比进程的开销更小，系统并发性提升。
  同样，需要注意的是：从属于不同进程的线程间切换，它是会导致进程切换的，所以开销也大。

线程的缺点：

• 当进程中的一个线程奔溃时，会导致其所属进程的所有线程奔溃。

举个例子，对于游戏的用户设计，就不应该使用多线程的方式，否则一个用户挂了，会影响其他同个进程的线程。

进程（process）和线程（thread）是操作系统的基本概念，但是它们比较抽象，不容易掌握。

我读到一篇材料，发现有一个很好的类比，可以把它们解释地清晰易懂。

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

假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。

进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

一个车间里，可以有很多工人。他们协同完成一个任务。

线程就好比车间里的工人。一个进程可以包括多个线程。 

车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。

可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。

一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫"互斥锁"（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。 

还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。 

这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做"信号量"（Semaphore），用来保证多个线程不会互相冲突。

不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。

操作系统的设计，因此可以归结为三点：

（1）以多进程形式，允许多个任务同时运行；

（2）以多线程形式，允许单个任务分成不同的部分运行；

（3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

线程控制函数

　1.pthread_self()函数

　获取线程ID。其作用对应进程中 getpid() 函数。

　　函数原型：pthread_t pthread_self(void);          返回值：成功：0；       失败：无

　　线程ID：pthread_t类型，本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现

       线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同)

       注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。

　　在主控线程中可以使用tid获得线程ID。

 2.pthread_create()函数　

创建一个新线程。其作用，对应进程中fork() 函数。

　　函数原型：int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

　　返回值：成功：0；失败：错误号 -----Linux环境下，所有线程特点，失败均直接返回错误号，但不设置errno，所以无法使用perror

       函数打印错误信息，需要使用strerror函数将返回的错误号转换成错误信息后再打印。

　　参数：

　　　　1. thread：传出参数，保存系统为我们分配好的线程ID

        　  2. attr：通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数，后面线程属性会详细讲解。

         　 3. start_routine：函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。

      　　 4. arg：传递给线程主函数执行期间所使用的参数，回调函数。

例程：循环创建N个子线程，每个线程打印自己是第几个被创建的线程。(类似于进程循环创建子进程)  　

#include 
#include 
#include 
#include 
 
void *tfn(void *arg)
{
    int i;
 
    i = (int)arg;
    sleep(i);     //通过i来区别每个线程
    printf("I'm %dth thread, Thread_ID = %lu\n", i+1, pthread_self());
 
    return NULL;
}
 
int main(int argc, char *argv[])
{
    int n = 5, i;
    pthread_t tid;
 
    if (argc == 2)
        n = atoi(argv[1]);
 
    for (i = 0; i < n; i++) {
        pthread_create(&tid, NULL, tfn, (void *)i);
        //将i转换为指针，在tfn中再强转回整形。
    }
    sleep(n);
    printf("I am main, and I am not a process, I'm a thread!\n" 
            "main_thread_ID = %lu\n", pthread_self());
 
    pthread_exit(NULL);
}

好的，今天就到这里，明天继续线程！