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

系统运维 来源:RdouTyping 59℃ 0评论

什么是线程的同步

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


线程同步的重要性

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

总结

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

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