线程编程（thread programming）介绍

ゝ一纸荒年。 2022-05-20 07:00 226阅读 0赞

本文主要介绍线程编程（thread programming）的相关知识。

# 1 概述 #

## 1.1 线程 ##

线程（thread）是进程中的一个实体，是被系统独立调度**基本单位**。

一个进程可以有多个线程，一个线程必须有一个父进程，线程自己不拥有系统资源，**只有运行必须的一些数据结构**，但它可以与同属一个进程的其他线程**共享进程所拥有的全部资源**。

一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

## 1.2 多线程 ##

一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程（来提高程序的执行效率）。

多线程（multithreading），是指从软件或者硬件上实现的多个线程并发执行的技术。

具有多线程能力的计算机因有相关的硬件支持而能够在同一时间同时执行多个线程，进而**提升计算机的整体处理性能**。具有这种能力的计算机包括：对称多处理器、多核心处理器以及芯片级多线程处理器（Chip-level multithreading）和同时多线程（Simultaneous multithreading）处理器。

在多线程的场景下，由于线程之间相互制约，导致线程在运行中呈现出间断性，所以就有了线程的“就绪、阻塞、和运行”三种基本状态。

多个线程同时运行、调用线程函数对同一段内存地址进行写入时，由于 CPU 时间调度上的问题（不确定性，交叉调度），某一线程写入的数据就可能会被其他线程覆盖，出现线程不安全的问题，所以需要让“线程同步”。

## 1.3 线程同步 ##

线程同步是指：当有一个线程在对内存进行操作时，其他线程都不可以对这段内存地址进行操作，直至该线程完成操作。

目前实现线程同步的方法有很多，例如：临界区（critical section）、事件（event）、信号量（semaphore）、互斥量（mutex）。

# 2 Linux多线程 #

Linux 操作系统下使用 C/C++ 编程语言开发多线程程序，需遵循 POSIX 线程接口，称为 pthread。

## 2.1 pthread\_create ##

pthread\_create 是类 Unix 操作系统（Unix、Linux、Mac OS X 等）中创建线程的函数，它的功能是创建线程（实际上就是确定调用该线程函数的入口点）。

**在线程创建以后，就开始运行相关的线程函数。**（虽然描述如此，但线程函数仍然有可能未运行到，下文会有相关介绍）

### 2.1.1 函数简介 ###

**头文件：**

#include <pthread.h>

**函数声明：**

int pthread_create(pthread_t *restrict tidp,
                                  const pthread_attr_t *restrict attr,
                                  void *(*start_rtn)(void *),
                                  void *restrict arg);

**参数说明：**

*  tidp：新创建的线程 ID 会被设置为 tidp 指向的内存单元；
 *  attr：用于定制各种不同的线程属性，默认为 NULL；
 *  start\_rtn：新创建的线程从 start\_rtn 函数的地址开始运行，该函数只有一个 void 类型的指针参数，即 arg；
 *  arg：start\_rtn 函数的参数。如果 start\_rtn 需要多个参数，则可以将参数放入一个结构中，然后将结构的地址作为 arg 传给 start\_rtn。

**返回值：**

pthread\_create 的返回值：创建线程成功，返回 0；若线程创建失败，通常会返回错误码（但不会设置 errno）。

**编译连接参数：**

-lpthread

说明：因为 pthread 并非 Linux 操作系统的默认库，而是 POSIX 线程库，在 Linux 中是将其作为一个库来使用的，因此加上“-lpthread（或-pthread）”以显式连接该库。故 pthread\_create 函数在执行出错时，将错误信息作为返回值返回，并不修改系统全局变量 errno，当然也无法使用 perror() 打印错误信息。

### 2.1.2 示例程序 ###

这里提供一个示例程序，该程序创建了一个线程，并打印“主线程ID和其所属的进程ID”以及“新创建的线程 ID 和其所属的进程 ID”。

所有线程都有一个线程号，即 Thread ID，其类型为 pthread\_t。通过调用 pthread\_self() 函数可以获取自身的线程号。

示例程序（pthread\_create\_test1.cpp）的代码如下：

#include <iostream>
    #include <pthread.h>
    #include <unistd.h>
    
    using namespace std;
    
    void printids(const char *s)
    {
        // 进程ID
        pid_t   pid;
        // 线程ID
        pthread_t   tid;
    
        // 获取进程ID
        pid = getpid();
        // 获取线程ID
        tid = pthread_self();
    
        cout << s << " pid(" << pid << ")";
        cout << " tid(" << tid << ")";
        cout << endl;;
    }
    
    void* thr_fn(void * arg)
    {
        printids("new thread: ");
    }
    
    int main()
    {
        int nRet;
        pthread_t ntid;
    
        // 创建子线程
        nRet = pthread_create(&ntid, NULL, thr_fn, NULL);
        if (0 != nRet)
        {
            cout << "create thread failed" << endl;
            return -1;
        }
    
        // 打印主线程信息
        printids("main thread: ");
    
        // 挂起2秒
        sleep(2);
        
        return 0;
    }

编译并执行上述代码，结果如下：

![70][]

通过上述结果能够看到：主线程与新创建的线程的线程 ID 不同，但两者所属进程的进程 ID 相同。此结果符合我们的预期。

**说明：**在程序中存在一个挂起操作“sleep(2)”，如果将这行代码注释掉，代码的（多次）执行结果如下：

![70 1][]

通过上述运行结果能够看到：**新创建的线程没有执行到！**这是因为去掉了挂起操作，导致在新线程执行之前，主线程就已经退出了，导致新创建的线程没来得及执行。

那么该如何解决上述问题呢？总不能在这种场景下都使用挂起操作吧？

事实上，通过使用 pthread 提供了一个名为 pthread\_join 的函数，就可以解决此问题。

## 2.2 pthread\_join ##

函数 pthread\_join 用来（使一个线程）等待（另）一个线程的结束。当 pthread\_join 返回时，被等待的线程的资源被收回；如果被等待的线程已经结束，那么此函数会立即返回。被等待的线程必须是 joinable 的。

### 2.2.1 函数简介 ###

**头文件：**

#include <pthread.h>

**函数声明：**

int pthread_join(pthread_t thread, void **retval);

**参数说明：**

*  thread：被等待线程的线程标识符，即线程 ID，标识唯一线程；
 *  retval：用户定义的指针，用来存储被等待线程的返回值。

**返回值：**

pthread\_join 的返回值：成功返回 0；失败返回相应的错误号。

### 2.2.2 函数应用场景 ###

在 Linux 操作系统中，默认情况下，一个线程被创建后，必须使用 pthread\_join 函数对创建的线程进行资源回收。或者可以通过 Threads attributes 设置当一个线程结束时，直接回收此线程所占用的系统资源，详细资料参考 Threads attributes。

实际上，在 Linux 操作系统中，新建的线程并不是在原先的进程中执行的，而是通过一个系统调用 clone()，copy 了一个和原进程完全一样的进程，并在这个 copy 出来的进程中执行线程函数。不过这个 copy 过程和 fork 不一样，copy 后的进程和原先的进程共享了所有的变量、运行环境。因此，原先进程中的变量的变动就可以在 copy 后的进程中体现出来了。

根据 2.1 节的描述，代码中如果没有挂起操作或 pthread\_join，那么主线程会很快执行结束，从而使整个进程结束，这就导致了新创建的线程没有机会执行就结束了。在代码中加入 pthread\_join 后，主线程会等待指定的线程（即我们新创建的线程）结束后，自己才结束，这样就使新创建的线程有机会执行了。

### 2.2.3 示例程序 ###

这里使用 2.1.2 节中的示例代码，将代码中的挂起操作替换为 pthread\_join 操作，修改后部分代码内容如下：

// 打印主线程信息
        printids("main thread: ");
    
        // 等待新创建的进程结束
        pthread_join(ntid, NULL);
        
        return 0;

编译并执行上述代码，运行结果如下：

![70 2][]

通过上述运行结果能够看到：通过调用 pthread\_join 函数，保证了新创建的线程能够被执行到（以及实现该线程执行完成后的资源回收操作）。

[70]: /images/20220520/e825da3f1ae045fabd3060d53c7b730d.png
[70 1]: /images/20220520/f886aaf987044299994b0b4790f4c496.png
[70 2]: /images/20220520/d54f01d2a38245dda4da81367b9706aa.png