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

摘要：死锁指的是两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象。总结这篇文章主要介绍了多线程中同步的重要性和线程同步的三种方法。

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

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

将变量 i 写入寄存器

寄存器加1

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

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

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

互斥量(mutex)

读写锁(rwlock)

条件变量(cond)

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

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

下面是 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是失败

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

上面三个函数的原型：

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都会被阻塞，他们会永远在等待对方资源的释放。

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

访问共享资源时需要加锁

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

加锁之后一定要解锁

互斥量加锁的范围要小

互斥量的数量应该少

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

同互斥量类似，我们需要先初始化读写锁，然后才能将其锁住和解锁。要初始化读写锁，我们使用 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(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() 函数的原型：

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() 时，需要传入条件变量和互斥量，这个互斥量必须要是被锁住的。当传入这两个参数后，

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

互斥量被解锁

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

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

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() 的区别在于前者用于唤醒一个等待条件的线程，而后者用于唤醒所有等待条件的线程。

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

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