线程同步

线程安全

多线程程序共享虚拟地址空间，使得多个线程可以操作同一变量，但这也可能带来意料之外的问题，比如下面的代码：

#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)

信号量与互斥锁配合，不仅能实现线程的同步，还可以实现线程的互斥，是较为常用的资源管理方案之一。

总结

本文介绍了线程安全的概念和线程同步的方法，在这些线程同步方法的使用过程中，还可能存在其他问题，比如死锁和虚假唤醒等，在后续文章中将详细介绍。