从 0 开始学习 Linux 系列之「25.Posix 线程」

多线程

版权声明：本文为 cdeveloper 原创文章，可以随意转载，但必须在明确位置注明出处！

多线程概念

多线程技术是应用开发中非常重要的技术之一，几乎大型的应用软件都使用这个技术，这次一起来学习下 Linux 中的多线程开发基础（其他的系统中概念也是类似的）。

在 Linux 中，一个简单的进程可以看成只有一个单线程（主线程），因为只有一个线程，所以进程在某一个时刻只能做一件事。为了能够使得进程可以在同一时刻做多件事情，可以让这个进程内部产生多个线程来分工同时完成。

例如典型的字处理程序，有一个线程在前台与用户进行图形界面的交互，有一个线程在进行语法和拼写检查，还有一个线程在周期性的保存文档，这 3 个线程共同完成了文档的编写和保存功能。想想假如只有一个主线程，那么你先键入文档，然后进行语法和拼写检查，最后才保存文档，这 3 个步骤是串行执行的，而使用多线程时这 3 个任务是并行执行的，效率提高了很多，也更加安全了，如下图：

单线程和多线程的区别

使用多线程技术有下面几个优点：

• 简化任务的代码：在单独的线程中执行一个任务可以使用简单的同步编程模式
• 共享进程资源：多个线程可以访问相同的进程地址空间
• 提高进程的吞吐量：使用多线程可以并行运行多个任务
• 优化程序体验：可以使用多线程分开处理程序的输入输出

总体来说使用多线程技术可以优化程序，提升用户的体验。了解了基本概念后，接下来看看操作系统实现线程的模型。

多线程模型

现在的操作系统有 2 种不同的方法来提供线程支持：

1. 用户线程：受内核支持，无须内核管理
2. 内核线程：由内核直接支持和管理

这两种方法之间有一定的联系，毕竟用户线程要受内核的支持，有 3 种常见的建立两者关系的模型：

1. 多对一模型：多个用户线程映射到一个内核线程，多个线程不能并行执行
2. 一对一模型：一个用户线程映射到一个内核线程，创建线程的开销较大
3. 多对多模型：多个用户线程可以复用同样数量或更小数量的内核线程，没有前面 2 者的缺点

3 种模型图如下：

3 种模型图

实现的模型在不同的操作系统上都差不多，但是不同操作系统上的线程库的实现却是不大相同的。

线程库

操作系统为我们提供创建和管理线程的 API，线程操作也有 2 种实现方法：

1. 内核支持的用户线程库：此库的代码和数据都存在用户空间中，API 不会进行系统调用
2. 原始的内核级别的库：此库的代码和数据都存在内核空间，API 会进行系统调用

有 3 种主要的线程库：

1. Posix Pthread：POSIX 标准的拓展，可以提供用户级和内核级的库，但仅仅是线程行为规范，而不是实现，Linux，Solaris 等 OS 都实现了这个规范
2. Win 32：适用于 Windows OS 的内核级线程库
3. Java 线程：由于 JVM 运行在宿主 OS 上，所以 Java 线程 API 通常采用宿主 OS 上的线程库的实现

因为本次介绍的是 Linux 下的多线程技术，所以这里学习的就是 Posix Pthread 的规范定义的 API 了，下面来看看都有哪些常用的函数。

比较，获取线程 ID

就像每个进程有一个进程 ID 一样，每个线程也有一个线程 ID，线程 ID 只有在它所属的进程上下文中才有意义。在 Posix Pthread 中用 pthread_t 类型来表示一个线程 ID，该类型在 Linux 下是一个无符号长整型，并提供了 2 个相关的操作：

#include <pthread.h>

// 比较 2 个线程 ID
int pthread_equal(pthread_t t1, pthread_t t2);

// 获取自身线程 ID
pthread_t pthread_self(void);

这两个函数比较简单，就不介绍例子了，返回值等信息可以参考 man pthread_equal 和 man pthread_self 手册。

创建线程

Posix 线程定义下面的函数来创建新的线程：

#include <pthread.h>

/*
 * thread: 指向线程 ID
 * attr: 定制线程属性，传递 NULL 设置默认属性
 * start_routine: 要运行的线程函数
 * arg: 要传递的函数参数
 * return: 成功返回 0，失败返回错误码，但不会设置 erron
 */
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);

来看一个简单的创建线程的例子，这个例子创建一个子线程并打印子线程的进程 ID 和线程 ID：

// thread_create.c

#include <stdio.h>
#include <pthread.h>
#include <sys/types.h>
#include <unistd.h>

/* print pid and tid. */
void print_id(const char *s) {
    printf("%s pid %lu, tid 0x%lx\n", s, 
            (unsigned long)getpid(), 
            (unsigned long)pthread_self());
}

/* thread fun */
void *thread_fun(void *arg) {
    print_id("new  thread: ");
    return NULL;
}

int main(void) {
    pthread_t tid;
    
    // create pthread
    if (pthread_create(&tid, NULL, thread_fun, NULL) != 0) {
        printf("thread create failed.\n");
        return -1;
    }
    
    print_id("main thread: ");
    // 等待子线程执行完，后面会用 pthread_join 代替
    sleep(1);
    return 0;
}

编译需要链接 -lpthread 线程库，运行结果如下：

orange@ubuntu:~/$ gcc -Wall thread_create.c -lpthread -o thread_create
orange@ubuntu:~/$ ./thread_create
new  thread:  pid 21301, tid 0x7f05c2ee3700
main thread:  pid 21301, tid 0x7f05c36bf700

从结果可看出两个线程的进程 pid 是相同的，因为 2 者都所属同一个进程，但是线程 tid 就不同了。另外，大家以后在用 gcc 编译的时候尽量都加上 -Wall 来开启所有的警告，可以帮助我们编写更加严谨的代码。

线程终止，等待

单个线程可以通过 3 种方式退出，并且不会终止整个进程：

1. 线程直接返回
2. 线程被其他线程取消
3. 线程调用 pthread_exit

这里主要介绍第 3 种方法，先来看看这个函数的定义：

#include <pthread.h>

void pthread_exit(void *retval);

其中 retval 返回的值可以通过调用 pthread_join 函数访问：

#include <pthread.h>

/*
 * thread: 要等待的线程 ID
 * retval: 线程的退出状态
 * return: 成功返回 0，失败返回错误编号
 */
int pthread_join(pthread_t thread, void **retval);

调用线程将一直阻塞，直到线程 ID 为 thread 的线程调用 pthread_exit，被取消或从启动例程中返回。并且，进程中的其他线程可以通过调用 pthread_join 函数获得该线程的退出状态。其中 retval 有 2 种情况：

1. 如果不为 NULL，则拷贝线程的退出状态码到 retval
2. 如果目标线程被取消，PTHREAD_CANCELED 被放到 retval 中

下面结合上面这两个函数来看一个例子：主线程开启 2 个子线程，然后分别使用 return 返回和 pthread_exit 退出，最后在主线程中获取线程的返回码。

#include <stdio.h>
#include <pthread.h>

void *thread_fun1(void *arg) {
    printf("thread 1 return.\n");
    return ((void *)1);
}

void *thread_fun2(void *arg) {
    printf("thread 2 exit.\n");
    pthread_exit((void *)2);
}

int main(void) {
    pthread_t tid1, tid2;
    void *ret_val = NULL;
    // create thread 1 and 2
    pthread_create(&tid1, NULL, thread_fun1, NULL);
    pthread_create(&tid2, NULL, thread_fun2, NULL);
    // wait thread 1
    pthread_join(tid1, &ret_val);
    printf("thread 1 exit code %ld\n", (long)ret_val);
    // wait thread 2
    pthread_join(tid2, &ret_val);
    printf("thread 2 exit code %ld\n", (long)ret_val);

    return 0;
}

编译，运行可以看到成功获得了 2 个线程的退出码：

gcc -Wall thread_join.c -o thread_join -lpthread

./thread_join
thread 1 return.
thread 1 exit code 1
thread 2 exit.
thread 2 exit code 2

线程分离

Posix 也给我们提供了分离线程的函数，当分离一个线程后，该线程在终止时，线程资源由系统自动释放，不需要其他线程再次 join 等待它。：

#include <pthread.h>

// thread: 要分离的线程 ID，成功返回 0，失败返回错误码
int pthread_detach(pthread_t thread);

注意，如果尝试分离一个已经分离的线程会产生未定义的行为。该函数的使用方法很简单，只需要一行代码：

#include <pthread.h>

// 在主线程创建 tid 线程
pthread_create(&tid, NULL, thread_fun, NULL);
// 从主线程分离 tid 线程
pthread_detach(tid);

线程同步

当多个线程同时访问共享资源时会产生线程安全的问题，我们需要使用一些技术来使得这些线程同步访问共享资源（一个一个访问，不同时访问），并且使它们访问变量的存储内存时不会访问到无效的值。

线程同步的方法主要有互斥锁，信号量等，前面在介绍 IPC 的时候使用信号量进行了进程间的通信，其中的信号量操作也是适用与线程的，所以这次主要介绍的同步方法是：互斥锁 Mutex。

使用互斥锁进行线程同步的基本思想是：线程在获取共享资源的访问前首先需要获得锁，没有获取则阻塞或返回，访问结束后必须释放锁，伪代码如下：

mutex_lock();
operate share resource
mutex_unlock();

Posix 线程给我们提供下面这些函数来操作互斥锁。

初始化和销毁 Mutex

#include <pthread.h>

// 动态初始化
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);

// 静态初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 销毁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

静态初始化比较简单，动态初始化需要和销毁 Mutex 的函数成对使用。

加锁，解锁 Mutex

#include <pthread.h>

// 加锁，如果不能获取锁会阻塞调用进程
int pthread_mutex_lock(pthread_mutex_t *mutex);

// 尝试加锁，不能获取锁就返回，不会阻塞
int pthread_mutex_trylock(pthread_mutex_t *mutex);

// 解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

例子：使用 Mutex 来保护共享资源

虽然 Mutex 的函数比较多，但是使用起来是很简单的，只需要 4 步：初始化，加锁，解锁，销毁（静态初始化不需要），来看一个简单的程序：

#include <stdio.h>
#include <pthread.h>

// 静态初始化不需要 main 中的 1，2 两步
//pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t mymutex;

void* thread_fun(void* arg) {
    // lock
    pthread_mutex_lock(&mymutex);
    for(int i = 0; i < 5; i++)  
        printf("thread num = %d\n", (int)arg);
    // unlock
    pthread_mutex_unlock(&mymutex);
    return NULL;
}

int main() {
    // 1. 动态初始化
    pthread_mutex_init(&mymutex, NULL);
    pthread_t mythread[3];
    void* retval = NULL;
    for (int i = 0; i < 3; i++) {
        pthread_create(&mythread[i], NULL, thread_fun, (void *)i);
        pthread_join(mythread[i], &retval);
    }
    // 2. 销毁，与动态初始化成对使用
    pthread_mutex_destroy(&mymutex);
    return 0;
}

编译，运行：

gcc -Wall lock_thread.c -o lock_thread -lpthread

./lock_thread
thread num = 0
thread num = 0
thread num = 0
thread num = 0
thread num = 0
thread num = 1
thread num = 1
thread num = 1
thread num = 1
thread num = 1
thread num = 2
thread num = 2
thread num = 2
thread num = 2
thread num = 2

这是我的机器的运行结果，可以将 pthread_mutex_lock 和 pthread_mutex_unlock 注释掉，即不加锁查看最后的结果会不会乱序。

线程池

线程池概念也是经常遇到，这里来了解一下它的基本原理，这里没有给出实现，有兴趣可以 Google 相关的线程池技术。来看一个 Web 服务的例子，以来了解为何使用线程池会有优势。

假设现在有一个多线程的 Web 服务器，没有使用线程池前，每接受一个客户端的连接请求就创建一个独立线程来处理，但是如果请求较多就会严重影响系统性能，主要有 2 个原因：

1. 创建很多线程需要耗费资源
2. 一个线程做完任务后就被销毁，不能重复利用

基于这两个缺点，提出了线程池的概念：它的主要思想是在进程开始的时候就创建一定数量的线程，放到一起（称为池）等待分配工作：

• 当服务器收到请求即唤醒一个线程处理任务，在一个线程处理完后会重新回到池中等待下一次的任务，使得线程可以重复使用
• 如果池中没有可用线程，则服务器会等待直到有可用线程，使得系统不会再创建新的线程

线程池中的线程数量可以手动规定，也可以在系统运行时根据当前负荷动态调整，具有动态调整功能的线程池比较高级。

结语

多线程技术的应用非常广泛，这篇文章主要介绍了在 Linux 下的 Posix 的标准的线程库的使用方法，相关 API 的使用其实不难，关键是要理解多线程的概念及为和要使用它。另外多线程中比较重要的是如何处理线程安全（同步）的问题，常见的处理方法有互斥锁，信号量等，同步的话题比较复杂有兴趣可以深入学习。

最后，感谢你的阅读，我们下次再见 :)