Home

cdeveloper

读书,写作

Linux 高级编程 - Posix 线程


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

多线程概念

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

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

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

thread

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

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

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

多线程模型

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

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

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

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

3 种模型图如下: thread2

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

线程库

操作系统为我们提供创建和管理线程的 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_equalman 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_lockpthread_mutex_unlock 注释掉,即不加锁查看最后的结果会不会乱序。

线程池

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

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

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

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

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

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

结语

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

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

欢迎关注我的公众号:「cdeveloper」

cdeveloper at 09/04/17