Linux编程学习笔记 | Linux多线程学习[2] - 线程的同步

什么是线程的同步

当有多个线程要同时对一个共享的内存空间进行读写时，我们要保证这个内存空间对于多个线程来说是一致的。当多个线程同时读/写这个内存空间时，就需要对线程进行同步，以确保任何时刻只有一个线程能修改该内存空间，这样才能保证线程不会访问到无效的数据。
我通过下面这幅图解释下线程同步的重要性：

在这个例子中，两个线程A和B都要按顺序做以下3件事：

1. 将变量 i 写入寄存器

2. 寄存器加1

3. 将寄存器内容重新写回变量 i

线程A先运行，线程B在线程A运行到第2步时开始运行，我们期待的结果是最终变量 i 的值会加2，但由于这两个线程没有进行同步，最后变量 i 的值只加了1。因此，对于多线程程序来说，线程的同步是很重要的。

线程的同步既然这么重要，那我们能通过什么办法来对其进行同步呢？我这里介绍三种基本的线程同步方法：

1. 互斥量(mutex)

2. 读写锁(rwlock)

3. 条件变量(cond)

互斥量

简单来说，互斥量就是一把锁住共享内存空间的锁，有了它，同一时刻只有一个线程可以访问该内存空间。当一个线程锁住内存空间的互斥量后，其他线程就不能访问这个内存空间，直到锁住该互斥量的线程解开这个锁。

互斥量的初始化

对于一个互斥量，我们首先需要对它进行初始化，然后才能将其锁住和解锁。我们可以使用动态分配和静态分配两种方式初始化互斥量。

分配方式	说明
动态分配	调用pthread_mutex_init()函数，在释放互斥量内存空间前要调用pthread_mutex_destroy()函数
静态分配	pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

下面是 pthread_mutex_init() 和 pthread_mutex_lock() 函数的原型：

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                       const pthread_mutexattr_t *restrict attr);
                       
args:
    pthread_mutex_t *restrict mutex         : 指向需要被初始化的互斥量的指针
    const pthread_mutexattr_t *restrict attr: 指向需要被初始化的互斥量的属性的指针

return:
    互斥量初始化的状态，0是成功，非0是失败
    


int pthread_mutex_destroy(pthread_mutex_t *mutex);

args:
    pthread_mutex_t *mutex: 指向需要被销毁的互斥量的指针
    
return:
    互斥量销毁的状态，0是成功，非0是失败

互斥量的操作

互斥量的基本操作有三种：

互斥量操作方式	说明
pthread_mutex_lock()	锁住互斥量，如果互斥量已经被锁住，那么会导致该线程阻塞。
pthread_mutex_trylock()	锁住互斥量，如果互斥量已经被锁住，不会导致线程阻塞。
pthread_mutex_unlock()	解锁互斥量，如果一个互斥量没有被锁住，那么解锁就会出错。

上面三个函数的原型：

int pthread_mutex_lock(pthread_mutex_t *mutex);

args:
    pthread_mutex_t *mutex: 指向需要被锁住的互斥量的指针
    
return:
    互斥量锁住的状态，0是成功，非0是失败
    


int pthread_mutex_trylock(pthread_mutex_t *mutex);

args:
    pthread_mutex_t *mutex: 指向需要被锁住的互斥量的指针
return:
    互斥量锁住的状态，0是成功，非0是失败
    


int pthread_mutex_unlock(pthread_mutex_t *mutex);

args:
    pthread_mutex_t *mutex: 指向需要被解锁的互斥量的指针
    
return:
    互斥量解锁的状态，0是成功，非0是失败

死锁

如果互斥量使用不当可能会造成死锁现象。死锁指的是两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象。比如线程1锁住了资源A，线程2锁住了资源B；我们再让线程1去锁住资源B，线程2去锁住资源A。因为资源A和B已经被线程1和2锁住了，所以线程1和2都会被阻塞，他们会永远在等待对方资源的释放。

为了避免死锁的发生，我们应该注意以下几点；

1. 访问共享资源时需要加锁

2. 互斥量使用完之后需要销毁

3. 加锁之后一定要解锁

4. 互斥量加锁的范围要小

5. 互斥量的数量应该少

读写锁

读写锁和互斥量相似，不过具有更高的并行性。互斥量只有锁住和解锁两种状态，而读写锁可以设置读加锁，写加锁和不加锁三种状态。对于写加锁状态而言，任何时刻只能有一个线程占有写加锁状态的读写锁；而对于读加锁状态而言，任何时刻可以有多个线程拥有读加锁状态的读写锁。下面是一些读写锁的特性：

特性	说明
1	当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。
2	当读写锁是读加锁状态时，所有处于读加锁状态的线程都可以对其进行加锁。
3	当读写锁是读加锁状态时，所有处于写加锁状态的线程都必须阻塞直到所有的线程释放该锁。
4	当读写锁是读加锁状态时，如果有线程试图以写模式对其加锁，那么读写锁会阻塞随后的读模式锁请求。

读写锁的初始化

同互斥量类似，我们需要先初始化读写锁，然后才能将其锁住和解锁。要初始化读写锁，我们使用 pthread_rwlock_init() 函数，同互斥量类似，在释放读写锁内存空间前，我们需要调用 pthread_rwlock_destroy() 函数来销毁读写锁。

下面是 pthread_rwlock_init() 和 pthread_rwlock_destroy() 函数的原型：

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                        const pthread_rwlockattr_t *restrict attr);
                        
args:
    pthread_rwlock_t *restrict rwlock:          指向需要初始化的读写锁的指针
    const pthread_rwlockattr_t *restrict attr： 指向需要初始化的读写锁属性的指针 

return:
    读写锁初始化的状态，0是成功，非0是失败

    

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

args:
    pthread_rwlock_t *rwlock: 指向需要被销毁的读写锁的指针

return:
    读写锁销毁的状态，0是成功，非0是失败

读写锁的操作

同互斥量类似，读写锁的操作也分为阻塞和非阻塞，我们先来看看读写锁有哪些基本操作：

读写锁操作方式	说明
int pthread_rwlock_rdlock()	读写锁读加锁，会阻塞其他线程
int pthread_rwlock_tryrdlock()	读写锁读加锁，不阻塞其他线程
int pthread_rwlock_wrlock()	读写锁写加锁，会阻塞其他线程
int pthread_rwlock_trywrlock()	读写锁写加锁，不阻塞其他线程
int pthread_rwlock_unlock()	读写锁解锁

下面是这几个函数的原型：

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

args:
    pthread_rwlock_t *rwlock: 指向需要加锁的读写锁的指针

return:
    读写锁加锁的状态，0是成功，非0是失败



int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

args:
    pthread_rwlock_t *rwlock: 指向需要加锁的读写锁的指针

return:
    读写锁加锁的状态，0是成功，非0是失败



int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

args:
    pthread_rwlock_t *rwlock: 指向需要加锁的读写锁的指针 

return:
    读写锁加锁的状态，0是成功，非0是失败



int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

args:
    pthread_rwlock_t *rwlock: 指向需要加锁的读写锁的指针 

return:
    读写锁加锁的状态，0是成功，非0是失败
    


int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

args:
    pthread_rwlock_t *rwlock: 指向需要解锁的读写锁的指针 

return:
    读写锁解锁的状态，0是成功，非0是失败

条件变量

条件变量是和互斥量一起使用的。如果一个线程被互斥量锁住，但这个线程却不能做任何事情时，我们应该释放互斥量，让其他线程工作，在这种情况下，我们可以使用条件变量；如果某个线程需要等待系统处于某种状态才能运行，此时，我们也可以使用条件变量。

条件变量的初始化

同互斥量一样，条件变量可以使用动态分配和静态分配的方式进行初始化：

分配方式	说明
动态分配	调用pthread_cond_init()函数，在释放条件变量内存空间前需要调用pthread_cond_destroy()函数
静态分配	pthread_cond_t cond = PTHREAD_COND_INITIALIZER

下面是 pthread_cond_init() 和 pthread_cond_destroy() 函数的原型：

int pthread_cond_init(pthread_cond_t *restrict cond,
                      const pthread_condattr_t *restrict attr);
                      
args:
    pthread_cond_t *restrict cond          : 指向需要初始化的条件变量的指针
    const pthread_condattr_t *restrict attr: 指向需要初始化的条件变量属性的指针
    
return:
    条件变量初始化的状态，0是成功，非0是失败



int pthread_cond_destroy(pthread_cond_t *cond);

args:
    pthread_cond_t *cond: 指向需要被销毁的条件变量的指针

return:
    条件变量销毁的状态，0是成功，非0是失败

条件变量的操作

条件变量的操作分为等待和唤醒，等待操作的函数有 pthread_cond_wait() 和 pthread_cond_timedwait() ；唤醒操作的函数有 pthread_cond_signal() 和 pthread_cond_broadcast() 。

我们来看看 pthread_cond_wait() 是怎么使用的，下面是函数原型：

int pthread_cond_wait(pthread_cond_t *restrict cond,
                      pthread_mutex_t *restrict mutex);
                      
args:
    pthread_cond_t *restrict cond  : 指向需要等待的条件变量的指针
    pthread_mutex_t *restrict mutex: 指向传入互斥量的指针

return:
    0是成功，非0是失败

当一个线程调用 pthread_cond_wait() 时，需要传入条件变量和互斥量，这个互斥量必须要是被锁住的。当传入这两个参数后，

1. 该线程将被放到等待条件的线程列表中

2. 互斥量被解锁

这两个操作都是原子操作。当这两个操作结束后，其他线程就可以工作了。当条件变量为真时，系统切换回这个线程，函数返回，互斥量重新被加锁。

当我们需要唤醒等待的线程时，我们需要调用线程的唤醒函数，下面是函数的原型：

int pthread_cond_signal(pthread_cond_t *cond);

args:
    pthread_cond_t *cond: 指向需要唤醒的条件变量的指针
    
return:
    0是成功，非0是失败


    
int pthread_cond_broadcast(pthread_cond_t *cond);
 
args:
    pthread_cond_t *cond: 指向需要唤醒的条件变量的指针 
    
return:
    0是成功，非0是失败

pthread_cond_signal() 和 pthread_cond_broadcast() 的区别在于前者用于唤醒一个等待条件的线程，而后者用于唤醒所有等待条件的线程。

总结

这篇文章主要介绍了多线程中同步的重要性和线程同步的三种方法。在下篇文章中我将通过程序实例来演示如何在代码中使用多线程。

如果觉得本文对你有帮助，请多多点赞支持，谢谢！