《Linux C/C++服务器开发实践》之第3章 多线程基本编程
《Linux C/C++服务器开发实践》之第3章 多线程基本编程
-
- 3.1 使用多线程的好处
- 3.2 多线程编程的基本概念
-
- 3.2.1 操作系统和多线程
- 3.2.2 线程的基本概念
- 3.2.3 线程的状态
- 3.2.4 线程函数
- 3.2.5 线程标识
- 3.2.6 C++多线程开发的两种方式
- 3.3 POSIX多线程开发
-
- 3.3.1 线程的创建
-
- 3.1.c
- 3.2.c
- 3.3.c
- 3.4.c
- 3.5.c
- 3.3.2 线程的属性
-
- 3.6.cpp
- 3.7.cpp
- 3.8.c
- 3.9.c
- 3.10.c
- 3.11.c
- 3.3.3 线程的结束
-
- 3.12.c
- 3.13.cpp
- 3.14.cpp
- 3.15.c
- 3.16.c
- 3.3.4 线程退出时的清理机会
-
- 3.17.c
- 3.18.c
- 3.19.c
- 3.4 C++11中的线程类
-
- 3.4.1 线程创建
-
- 3.20.cpp
- 3.21.cpp
- 3.22.cpp
- 3.23.cpp
- 3.24.cpp
- 3.25.cpp
- 3.26.cpp
- 3.27.cpp
- 3.4.2 线程标识符
-
- 3.28.cpp
- 3.4.3 当前线程
-
- 3.29.cpp
- 3.30.cpp
- 3.31.cpp
- 3.5 线程同步
-
- 3.5.1 同步的基本概念
-
- 3.32.cpp
- 3.33.cpp
- 3.5.2 临界资源和临界区
- 3.6 POSIX线程同步
-
- 3.6.1 互斥锁
-
- 3.34.cpp
- 3.35.cpp
- 3.6.2 读写锁
-
- 3.36.cpp
- 3.6.3 条件变量
-
- 3.37.c
- 3.7 C++11/14线程同步
-
- 3.7.1 基本互斥锁std::mutex
-
- 3.38.cpp
- 3.7.2 定时互斥锁std::timed_mutex
-
- 3.39.cpp
- 3.8 线程池
-
- 3.8.1 线程池的定义
- 3.8.2 使用线程池的原因
- 3.8.3 POSIX线程池
-
- 3.40_0.c
- 3.40.cpp
- 3.8.4 C++11线程池
-
- 3.41.cpp
- 3.41_0.cpp
3.1 使用多线程的好处
（1）响应速度更灵敏
多个任务不同线程执行，各自占用一段CPU时机，看起来任务同时进行，界面及时更新。
（2）运行效率更高
充分发挥cpu内核性能，增加运行效率。
（3）通信更高效
线程共享进程地址空间，比进程通信更高效和方便。
（4）开销更小
线程创建、切换等系统开销比进程更小。
3.2 多线程编程的基本概念
3.2.1 操作系统和多线程
操作系统分类：
（1）单进程、单线程，MS-DOS。
（2）多进程、单线程，多数UNIX（及类UNIX的Linux）。
（3）多进程、多线程，Win32（Windows NT/2000/XP/7/8/10等）、Solaris 2.x、OS/2。
（4）单进程、多线程，VxWorks。
3.2.2 线程的基本概念
CPU执行的是线程，线程是程序的最小执行单位，是操作系统分配CPU时间的最小实体。
线程共享进程的公共资源，如虚拟地址空间、全局变量等，线程可有自己私有资源，如堆栈、堆栈中定义的静态变量和动态变量、CPU寄存器的状态等（程序计数器、一组寄存器和线程栈，线程栈用于维护线程在执行代码时所需要的所有函数参数和局部变量）。
线程好处：
（1）线程创建、终止比进程更快；
（2）线程（尤其用户级）比进程切换更快；
（3）线程可以解决父子进程模型中子进程必须复制父进程地址空间的问题；
（4）线程对解决客户/服务器模型非常有效。
使用多线程情况：
（1）各任务相对独立；
（2）某些任务耗时较多；
（3）各任务有不同优先级；
（4）一些实时系统应用。
3.2.3 线程的状态
(1)就绪态
运行条件满足，等待处理器调度（调度策略）。等待原因：线程刚创建（刚创建线程不一定马上运行，一般先就绪）、刚重阻塞态恢复、其它线程抢占。
(2)运行态
占用着处理器运行。
(3)阻塞态
等待处理器之外的其它条件（I/O操作、互斥锁释放、条件变量的改变等）而无法运行的状态。
(4)终止态
线程函数运行结束或被其它线程取消。此时线程结束，但占用资源还未被回收，可以被重新复活。
3.2.4 线程函数
线程创建后进入运行态要执行的函数。
全局函数或类的静态函数。
void *ThreadProc(void *arg);
3.2.5 线程标识
句柄标识线程对象，ID标识线程本身。
3.2.6 C++多线程开发的两种方式
POSIX多线程API函数，传统；
C++自带线程类，新。
3.3 POSIX多线程开发
| API函数 | 含义 |
|---|---|
| pthread_create | 创建线程 |
| pthread_exit | 终止自身线程 |
| pthread_join | 等待线程结束 |
| pthread_self | 线程ID |
| pthread_cancel | 取消其它线程 |
| pthread_kill | 线程发送信号 |
3.3.1 线程的创建
int pthread_create(pthread_t *pid, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
pid指向线程ID，pthread_t是unsigned long int；
pthread_attr_t，线程属性结构，NULL使用默认属性；
start_routine指向线程函数地址；
arg指向传给线程函数的参数；
成功返回0。
int pthread_join(pthread_t pid, void **value_ptr);
pid，线程ID；
value_ptr，获取线程退出值，可为NULL；
成功返回0。
pthread_join阻塞函数，让主线程挂起（即休眠，让出CPU），直到子线程退出，同时释放子线程所占资源。子线程退出后，主线程会收到系统信号，从休眠中恢复。
gcc -o test test.cpp -lpthread
3.1.c
#include 3.2.c
#include 3.3.c
#include 3.4.c
#include 3.5.c
#include 3.3.2 线程的属性
分离状态（Detached State）、调度策略和参数（Scheduling Policy and Parameters）、作用域（Scope）、栈尺寸（Stack Size）、栈地址（Stack Address）、优先级（Priority）等。
union pthread_attr_t {
char __size[__SIZEOF_PTHREAD_ATTR_T];
long int __align;
};
#define _GNU_SOURCE
#include 默认线程属性，非分离、堆栈大小1MB，与父进程同样优先级。
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
- 分离状态
线程终止方式，默认可连接。
非分离状态（可连接，joinable， PTHREAD_CREATE_JOINABLE），可以被其它线程收回资源和取消，不会主动释放资源（比如栈空间，僵尸线程），必须等待其它线程回收资源（pthread_join）。线程函数结束（return或pthread_exit）时，都不会释放线程占用的堆栈和线程描述符（8KB多）。父进程先于子线程退出，不会泄漏资源，会被init进程收养。线程不能被多个线程等待，第一个收到信号的线程成功返回，其余调用pthread_join的线程得到错误代码ESRCH。
可分离线程能独立（分离）出去，运行结束时，其资源立刻被系统回收。两种方式设置，pthread_detach和pthread_attr_setdetachstate(pthread_attr_t *attr, PTHREAD_CREATE_DETACHED)。
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
//PTHREAD_CREATE_DETACHED或PTHREAD_CREATE_JOINABLE
//设置线程分离状态属性。
3.6.cpp
#include 3.7.cpp
#include int pthread_detach(pthread_t thread);
//可连接线程转变为可分离线程（退出或pthread_exit后系统回收资源）
//EINVAL，非可连接线程
//ESRCH，线程未找到
//pthread_join后pthread_detach线程无作用
//pthread_detach后pthread_join出错
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
//获取分离状态
3.8.c
#ifndef _GNU_SOURCE
#define _GNU_SOURCE //pthread_getattr_np
#endif
#include 3.9.c
#ifndef _GNU_SOURCE
#define _GNU_SOURCE //pthread_getattr_np
#endif
#include - 栈尺寸
栈上的内存空间，如局部变量（尤其数组）、函数参数、返回地址等，动态分配内存（malloc）或全局变量等属于堆空间。
int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);
//获取栈尺寸（字节）
3.10.c
#ifndef _GNU_SOURCE
#define _GNU_SOURCE // pthread_getattr_np()
#endif
#include - 调度策略
操作系统管理线程如何占用CPU，就是线程调度。
实时是操作系统对一些中断等的响应时效性非常高，非实时相反。VxWorks实时操作系统（Real-time Operating System，TSOS），Windows和Linux非实时操作系统（分时操作系统，Time-sharing Operating System，TSOS）。优先级控制CPU抢占，响应实时。
线程分实时和分时。线程调度策略：
（1）SCHED_OTHER
分时调度策略（轮转策略），默认，非实时。线程分配时间片，无优先级，按序运行。
（2）SCHED_FIFO
先来先服务调度策略，实时，支持优先级抢占。按序运行，直到更高优先级任务抢占。优先级范围1~99。
（3）SCHED_RR
时间片轮转（轮询）调度策略，实时，支持优先级抢占。线程分配特定时间片，用完后重新分配，保证相同优先级线程能够公平地调度。优先级范围1~99。
int sched_get_priority_min(int policty);
int sched_get_priority_max(int policty);
//SCHED_FIFO、SCHED_RR、SCHED_OTHER
3.11.c
#include 3.3.3 线程的结束
线程结束方法：
（1）线程函数中调用pthread_exit；
不会导致C++对象被析构，可放心使用。
（2）线程所属进程结束，比如进程调用exit;
最好不用，线程函数中C++对象不会被销毁。
（3）线程函数执行结束，return；
最安全方式。
（4）线程被其它线程通知结束或取消。
中途停止线程，发送取消信号。
- 线程主动结束
return或pthread_exit
主线程中调用pthread_exit(NULL);将结束主线程，但进程不会立即退出。
3.12.c
#include - 线程被动结束
pthread_kill或pthread_cancel。
int pthread_kill(pthread_t threadId, int signal);
//signal等于0用于探测线程是否存在
//ESRCH，线程不存在
//EINVAL，信号不合法
sigaction注册信号处理函数，默认会退出进程。
3.13.cpp
#include 3.14.cpp
#include pthread_cancel发送终止线程运行的请求，不一定成功。
发送终止线程运行的请求成功，系统并不会马上关闭被取消的线程，只有被取消的线程下次调用一些系统函数或C库函数（比如printf）或pthread_testcancel(死循环中，让内核有机会去检测是否需要取消当前线程)时，才会真正结束线程。被取消线程成功停止运行时，会返回常数PTHREAD_CANCELED(-1)。线程执行过程中，检测是否有未响应取消信号的地方，叫取消点，位于printf、pthread_testcancel、read/write、sleep等函数调用的地方。
3.15.c
#include 3.16.c
#include 3.3.4 线程退出时的清理机会
需要线程退出时执行清理的机会，保证顺利地释放掉占用的资源，尤其是锁。
void pthread_cleanup_push(void (*routine)(void *), void *arg);
//压入清理函数routine。
/*
清理函数routine执行情况：
（1）线程主动结束，return或ptherad_exit
（2）pthread_cleanup_pop(1)
（3）其它线程函数调用pthread_cancel
*/
void pthread_cleanup_pop(int execute);
//弹出栈顶清理函数的同时，是否执行清理函数。
//0不执行，非0执行。
pthread_cleanup_push和pthread_cleanup_pop必须成对出现，否则语法错误。
void *thread1(void *arg){
pthread_cleanup_push(clean_funnc, ...);
pthread_mutex_lock(&mutex);
sock = accept(...);
pthread_mutex_unlock(&mutex);
pthread_cleanup_pop(0);
return NULL;
}
3.17.c
#include 3.18.c
#include 3.19.c
#include 3.4 C++11中的线程类
-
atomic
std::atomic和std::atomic_flag -
thread
std::thread和std::this_thread -
mutex
std::mutex、std::lock_guard、std::unique_lock -
condition_variable
std::condition_variable和std::condition_variable_any -
future
std::promise、std::package_task、std::future、std::shared_future、std::async
| std::thread成员函数 | 说明（public访问方式） |
|---|---|
| thread | 4种构造函数 |
| get_id | 线程id |
| joinable | 是否可连接 |
| join | 连接，阻塞函数 |
| native_handle | 操作系统相关的原生线程句柄（需要本地库支持） |
| swap | 线程交换 |
| detach | 分离线程 |
g++ -o test test.cpp -lpthread -sd=c++11
3.4.1 线程创建
- 默认构造函数
thread();
//线程不会马上运行
3.20.cpp
#include - 初始化构造函数
将线程函数指针和参数（若存在）线程类的构造函数中，线程会立即开始执行。
templace <class Fn, class... Args>
explicit thread(Fn&& fn, Args&&... args);
void join();
3.21.cpp
#include 3.22.cpp
#include 3.23.cpp
#include 3.24.cpp
#include 3.25.cpp
#include void detach();
3.26.cpp
#include - 移动构造函数
thread(thread&& x);
3.27.cpp
#include 3.4.2 线程标识符
thread::id get_id()
3.28.cpp
#include 3.4.3 当前线程
this_thread引用当前线程。
- 让出CPU时间
//线程放弃执行，回到就绪态
void yield();//让出线程CPU时间片，让其它线程有机会执行。
3.29.cpp
#include - 线程暂停一段时间
template <class Clock, class Duration>
void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
template <class Rep, class Period>
void sleep_for(const chrono::duration<Rep, Period>& rel_time);
3.30.cpp
#include 3.31.cpp
#include 3.5 线程同步
保证共享资源的稳定性，使用线程同步机制调整多个线程的执行顺序。只有拥有锁的线程才能操作共享资源，其它线程等待。
异步是当调用或请求发送给被调用者时，调用者不用等待结果返回而继续当前处理。实现异步机制的方式有多线程、中断和消息等。
3.5.1 同步的基本概念
同步机制消除并发和异步机制带来的线程资源竞争无序性的复杂度，实现线程间有序正确地共享数据，以一致的顺序执行一组操作。
3.32.cpp
#include 3.33.cpp
#include 3.5.2 临界资源和临界区
临界资源，指一次仅允许一个线程使用的共享资源，各线程应该互斥对其访问。每个线程中访问临界资源的那段代码称为临界(区|段)(Critical Section)。
3.6 POSIX线程同步
3.6.1 互斥锁
- 互斥锁的概念
线程同步的一种机制，用来保护多线程的共享资源。初始化一个互斥锁，进入临界区之前把互斥锁加锁（防止其它线程进入临界区），退出临界区的时候把互斥锁解锁（其它线程有机会进入临界区），最后不用互斥锁的时候销毁它。
#include - 互斥锁的初始化
//函数初始化，动态方式，需要销毁
//restrict，只用于限定指针，告知编译器，只能通过该指针修改期指向内容。
//帮助编译器进行代码优化，生成更有效率的汇编代码。
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
//宏PTHREAD_MUTEX_INITIALIZER静态初始化，常量初始化，不需要销毁
#define PTHREAD_MUTEX_INITIALIZER \
{{0,0,0,0,0,{0}}}
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
//或者
pthread_mutex_t pmutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(pmutex , NULL);
- 互斥锁的上锁和解锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
- 互斥锁的销毁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
3.34.cpp
#include 3.35.cpp
#include 3.6.2 读写锁
- 读写锁的概念
不修改临界资源的情况下，可以多个线程同时读取共享变量的值。
资源的独占式访问，称为写操作；资源的共享式访问，称为读操作。
读锁锁定临界区时，其它线程可用读锁进入临界区，并行读取共享资源，此时写锁线程会阻塞；
写锁锁定临界区时，其它线程无论读锁还是写锁都会阻塞。
#include - 读写锁的初始化
//宏PTHREAD_RWLOCK_INITIALIZER静态初始化，常量初始化，不需要销毁
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
//函数初始化，动态方式，需要销毁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);
//或者
pthread_rwlock_t *prwlock = (pthread_rwlock_t *)malloc(sizeof(pthread_rwlock_t ));
pthread_rwlock_init(prwlock , NULL);
- 读写锁的上锁和解锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
//若上锁，不阻塞，立即返回EBUSY
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
//若上锁，不阻塞，立即返回EBUSY
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
//规定时间等待读写锁，等不到返回ETIMEDOUT
int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *restrict abs_timeout);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *restrict abs_timeout);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
- 读写锁的销毁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
3.36.cpp
#include 3.6.3 条件变量
- 条件变量的概念
条件变量（Condition Variable），让线程因等待“条件变量的条件而挂起”，其它线程在条件成立后向挂起的线程发送条件成立的信号。
条件变量联合互斥锁使用，用于防止线程间竞争。条件变量常用于多线程间共享数据状态变化的通信中，当一个线程的行为依赖于另外一个线程对共享数据状态的改变时，就可以使用条件变量来同步它们。
经典的生产者消费者（Producer-Consumer）问题，即有界缓冲区（Bounded Buffer）问题。线程共享公共的固定的缓冲区，生产者线程向缓冲区写入数据，消费者线程从缓冲区读取数据。缓冲区满时，生产者休眠，等待消费者从缓冲区取走数据后再去唤醒它；缓冲区空时，消费者休眠，等待生产者向缓冲区写入数据后再去唤醒它。
pthread_mutex_t mutex;
#define N 100
int count = 0;
//生产者线程
void procedure() {
int item;
while(1) {
item = produce_item(); //生成数据项
if(count == N) //缓冲区满了
sleep();
pthread_mutex_lock(&mutex);
insert_item(item); //数据项放入缓冲区
count = count + 1;
pthread_mutex_unlock(&mutex);
if(count == 1) //消费者等待
wakeup(consumer); //唤醒消费者
}
}
//消费者线程
void consumer() {
int item;
while(1) {
if(count == 0) //缓冲区空了
sleep();
pthread_mutex_lock(&mutex);
item = remove_item(); //取走数据项
count = count - 1;
pthread_mutex_unlock(&mutex);
if(count == N - 1) //缓冲区有空槽
wakeup(procedure); //唤醒生成者
}
}
消费者从解锁到休眠这段代码有可能被打断，而条件变量将互斥锁释放到休眠当作原子操作，不容打断。
- 条件变量的初始化
常量（静态）初始化，不需要销毁
pthread_cont_t cond = PTHREAD_COND_INITIALLER;
动态初始化，需要销毁
pthread_cont_t cond;
pthread_cond_init(&cond, NULL);
//和
pthread_cont_t *pcond = (pthread_cont_t *)malloc(sizeof(pthread_cont_t));
pthread_cond_init(pcond, NULL);
#include - 等待条件变量
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
typedef struc timespec {
time_t tv_sec; //秒
long tv_nsex; //纳秒
} timespec_t ;
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
lock(mutex)
while(condition is false)
cond_wait(cond, mutex, timeout)
dosomething()
unlock(mutex)
条件变量必须和互斥锁联合使用。能够保证互斥锁解锁到线程被条件变量阻塞，互斥锁上锁到线程被唤醒都是原子操作。
while循环用于判断是否虚假唤醒（Spurious Wakeups），条件不一定满足。
- 唤醒等待条件变量的线程
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
- 条件变量的销毁
int pthread_cond_destroy(pthread_cond_t *cond);
3.37.c
#include 3.7 C++11/14线程同步
mutex(基本互斥锁)、recursive_mutex(递归互斥锁)、timed_mutex(定时互斥锁)、recursive_timed_mutex(定时递归互斥锁)
lock、try_lock、unlock
3.7.1 基本互斥锁std::mutex
| std::mutex成员函数 | 说明 |
|---|---|
| mutex | 构造函数 |
| lock | 上锁 |
| try_lock | 尝试上锁 |
| native_handle | 本地互斥锁句柄 |
void lock();
void unlock();
3.38.cpp
#include 3.7.2 定时互斥锁std::timed_mutex
增加定时功能
| std::timed_mutex成员函数 | 说明 |
|---|---|
| timed_mutex | 构造函数 |
| lock | 上锁 |
| try_lock | 尝试上锁 |
| try_lock_for | 一段时间尝试上锁 |
| try_lock_until | 时间点前尝试上锁 |
| native_handle | 本地互斥锁句柄 |
3.39.cpp
#include 3.8 线程池
3.8.1 线程池的定义
一堆已经创建好了的线程，初始时处于空闲等待状态，当需要处理新任务时，线程池中取出一个空闲等待的线程来处理该任务，任务处理完毕后该线程放回池中（线程状态设置为空闲）。
3.8.2 使用线程池的原因
与进程比较，线程的创建和销毁是轻量级的（开销较小），但大量创建和销毁线程时，开销合在一起就比较大。线程池可以线程复用，避免无谓的开销。
3.8.3 POSIX线程池
c 线程池
3.40_0.c
#include C++线程池
3.40.cpp
#include 3.8.4 C++11线程池
3.41.cpp
#include
#include 3.41_0.cpp
#include
#include