线程安全
多线程程序共享虚拟地址空间,使得多个线程可以操作同一变量,但这也可能带来意料之外的问题,比如下面的代码:
#include <bits/stdc++.h>
#include <pthread.h>
#include <errno.h>
int num = 0;
void* add(void *){
++num;
return nullptr;
}
int main(){
pthread_t tid[10];
for(int i=0;i<10;++i){
if(pthread_create(&tid[i],nullptr,add,nullptr)<0){
std::cout << "第个" << i << "线程创建失败:" << errno << std::endl;
}
}
for(int i=0;i<10;++i){
pthread_detach(tid[i]);
}
std::cout << num << std::endl;
}
按照我们之前的考虑,有10个线程将num加1,最终结果应该是10,我们多次运行上面的程序,结果如下:
有一次的运行结果为8,并且是在没有发生线程创建失败的情况下!这就是我们要说的线程安全的问题。
add函数中虽然操作只有++num一行代码,但在寄存器层面却是三个操作:
1.将原本的num值存入寄存器;
2.寄存器值+1;
3.寄存器值存入num。
从之前的文章我们知道,线程运行时,可能因为时间片用完而让出cpu,此时cpu将被另一个线程占据,于是可能发生下面的情况:
这时两个线程同时++num,结果只加了一次!诸如此类的问题通常称为线程安全问题,其根本原因是线程的操作不是原子的,此时多个线程对同一内存竞争导致了内存安全的问题,用于解决线程安全的方法通常称为线程同步。
互斥锁
互斥锁是线程同步最常用的方法之一,互斥锁是NPTL线程库提供的锁,当一个线程上锁时,其他线程就无法拿到这把锁,此时无法拿到锁的线程将阻塞,等待拥有锁的线程释放互斥锁。这样可以保证每次只有一个线程拥有锁,避免多线程的竞态。
互斥锁的系统调用如下:
//创建和销毁锁
pthread_mutex_init(pthread_mutex_t* mutex);
pthread_mutex_destroy(pthread_mutex_t* mutex);
//上锁和解锁
pthread_mutex_lock(pthread_mutex_t* mutex);
pthread_mutex_unlock(pthread_mutex_t* mutex);
//非阻塞式上锁
pthread_mutex_trylock(pthread_mutex_t* mutex);
我们上面的示例代码中,使用互斥锁来保证线程安全:
#include <bits/stdc++.h>
#include <pthread.h>
#include <errno.h>
int num = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* add(void *){
pthread_mutex_lock(&mutex);
++num;
pthread_mutex_unlock(&mutex);
return nullptr;
}
int main(){
pthread_t tid[10];
for(int i=0;i<10;++i){
if(pthread_create(&tid[i],nullptr,add,nullptr)<0){
std::cout << "第个" << i << "线程创建失败:" << errno << std::endl;
}
}
for(int i=0;i<10;++i){
pthread_detach(tid[i]);
}
std::cout << num << std::endl;
}
读写锁和自旋锁
除互斥锁外,线程库还提供了读写锁和自旋锁。
读写锁
读写锁加锁分为读锁和写锁,加读锁时,不阻塞其他线程读,之阻塞其他线程写,加写锁时,阻塞其他线程读和写。读写锁存在是由于多线程读时并不存在竞态,没有必要加锁。读写锁的系统调用如下:
//创建和销毁锁
pthread_rwlock_init(pthread_rwlock_t* rwlock, const pthread_rwlockattr_t* attr);
pthread_rwlock_destroy(pthread_rwlock_t* rwlock);
//上锁和解锁
pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
pthread_rwlock_unlock(pthread_rwlock_t* rwlock);
//非阻塞式上锁
pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);
pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);
自旋锁
不管是读写锁还是互斥锁,上锁之后线程都会进入阻塞态,状态之间的切换会导致线程上下文的切换,还需要等待cpu的再次调度,如果锁马上就可以获得,这些时间消耗都是不必要的,因此NPTL库又引入了自旋锁。自旋锁在获取锁之前处于忙等待状态,不会使进程阻塞。
自旋锁的系统调用如下:
//创建和销毁锁
pthread_spin_init(pthread_spinlock_t* lock, int pshared);
pthread_spin_destroy(pthread_spinlock_t* lock);
//上锁和解锁
pthread_spin_lock(pthread_spinlock_t* lock);
pthread_spin_unlock(pthread_spinlock_t* lock);
//非阻塞式上锁
pthread_spin_trylock(pthread_spinlock_t* lock);
特殊的是自选锁的初始化参数pshared,当设置为宏PTHREAD_PROCESS_SHARED时,不同进程中的线程也可以获取这把锁。
条件变量
条件变量与互斥锁配合,可以更精细地控制线程同步。条件变量在使用时需要传入一把互斥锁,在等待条件变量时,将这把互斥锁上锁,条件变量满足时,释放互斥锁,解除线程的阻塞。从本质上来说,条件变量也是由互斥锁控制的,但提供了一种控制互斥锁的方法。条件变量相关的系统调用如下:
//创建和销毁条件变量
pthread_cond_init(pthread_cond_t* cond, const pthread_condattr* attr);
pthread_cond_destroy(pthread_cond_t* cond);
//唤醒单个线程
pthread_cond_signal(pthread_cond_t* cond);
//唤醒所有线程
pthread_cond_broadcast(pthread_cond_t* cond);
//等待条件变量
pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex
const struct timespec *restrict tsptr);
这里提供一个条件变量的使用例程,作用是两个线程交替打印数字。
#include <iostream>
#include <unistd.h>
using namespace std;
int num = 0;
pthread_cond_t cond_even = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_odd = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_odd = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_even = PTHREAD_MUTEX_INITIALIZER;
void* print_even(void* arg){
while(num<10){
pthread_mutex_lock(&mutex_even);
++num;
cout << "打印奇数:" << num << endl;
pthread_cond_signal(&cond_odd);
if(num>=10)pthread_exit(nullptr);
pthread_cond_wait(&cond_even, &mutex_even);
pthread_mutex_unlock(&mutex_even);
}
pthread_mutex_unlock(&mutex_even);
return nullptr;
}
void* print_odd(void* arg){
sleep(1);
while(num<10){
pthread_mutex_lock(&mutex_odd);
++num;
cout << "打印偶数:" << num << endl;
pthread_cond_signal(&cond_even);
if(num>=10)pthread_exit(nullptr);
pthread_cond_wait(&cond_odd, &mutex_odd);
pthread_mutex_unlock(&mutex_odd);
}
return nullptr;
}
int main(){
pthread_t tid[2];
if(pthread_create(&tid[0], nullptr, print_odd, nullptr)<0){
cout << "第个1线程创建失败:" << errno << endl;
}
if(pthread_create(&tid[1], nullptr, print_even, nullptr)<0){
cout << "第个2线程创建失败:" << errno << endl;
}
pthread_join(tid[1],nullptr);
pthread_join(tid[0],nullptr);
pthread_mutex_destroy(&mutex_even);
pthread_mutex_destroy(&mutex_odd);
pthread_cond_destroy(&cond_odd);
pthread_cond_destroy(&cond_even);
cout << "打印完成!" << endl;
return 0;
}
屏障
屏障是协调多个线程并行工作的同步机制,屏障可以使线程等待,直到所有合作线程都达到某点,然后从该点继续执行。
屏障的系统调用如下:
//创建和销毁屏障
pthread_barrier_init(pthread_barrier_t* barrier, const pthread_barrierattr_t* attr, unsigned int count);
pthread_barrier_destroy(pthread_barrier_t* barrier);
//到达屏障
pthread_barrier_wait(pthread_barrier_t* barrier);
初始化屏障时传入参数count为加入屏障的数量,当调用pthread_barrier_wait等待的线程数等于count时,在屏障前等待的线程继续执行。
信号量
信号量是用于管理竞争资源的数据结构,当线程释放竞争资源时,信号量通过V操作使资源加1,线程请求资源时,如果资源大于0,则通过P操作使资源减1,否则使线程阻塞,直到有线程归还信号量资源。信号量的系统调用如下:
#include <semaphore.h>
//创建信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);
//P操作
int sem_wait(sem_t* sem)
//V操作
int sem_post(sem_t* sem)
//销毁信号量
int sem_destroy(sem_t* sem)
信号量与互斥锁配合,不仅能实现线程的同步,还可以实现线程的互斥,是较为常用的资源管理方案之一。
总结
本文介绍了线程安全的概念和线程同步的方法,在这些线程同步方法的使用过程中,还可能存在其他问题,比如死锁和虚假唤醒等,在后续文章中将详细介绍。