多线程---互斥锁和读写锁

明小白的笔记

已于 2024-02-18 23:03:48 修改

阅读量447

点赞数 5

分类专栏： Linux自学笔记文章标签： linux

于 2024-02-18 20:22:35 首次发布

本文链接：https://blog.csdn.net/qq_53137764/article/details/136157110

版权

Linux自学笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.互斥锁

互斥锁也叫互斥量，互斥锁是用一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态，即加锁（lock）和解锁（unlock）。

操作流程如下：

在访问共享资源后临界区域前，对互斥锁进行加锁。
在访问完成后释放互斥锁上的锁
对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程会被阻塞

API

初始化互斥锁

#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                       const pthread_mutexattr_t *restrict attr);
功能：初始化一个互斥锁
参数：
    mutex: 互斥锁地址。类型是pthread_mutex_t
    attr: 设置互斥量的属性，通常可采用默认属性，即可将attr设为NULL

    可以使用宏PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁，比如：
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    这种方法等价于使用NULL指定的attr参数调用pthread_mutex_init()来完成动态初始化，
    不同之处在于PTHREAD_MUTEX_INITIALIZER宏不进行错误检查。
返回值：
    成功：0，成功申请的锁默认是打开的
    失败：非0错误码

restrict,C语言中的一种类型限定符，用于告诉编译器，对象已经被指针所引用，
不能通过除该指针外所有其他直接或间接的方式修改该对象的内容

销毁互斥锁

#include<pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：
    销毁指定的一个互斥锁。互斥锁在使用完毕后，必须对互斥锁进行销毁，以释放资源
参数：
    mutex: 互斥锁地址
返回值：
    成功：0
    失败：非0错误码

上锁

#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：
    对互斥锁上锁，若互斥锁已经上锁，则调用者阻塞，直到互斥锁解锁后再上锁。
参数：
    mutex: 互斥锁地址
返回值：
    成功：0
    失败：非0错误码

#include<pthread.h>
int pthread_mutex_trylock(pthread_mutex_t *mutex);
    调用该函数时，若互斥锁未加锁，则上锁，返回0
    若互斥锁已加锁，则函数直接返回失败，即EBUSY。

解锁

#include<pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：
    对指定互斥锁解锁。
参数：
    mutex: 互斥锁地址
返回值：
    成功：0
    失败：非0错误码

代码示例：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
 
#define MAX 10000
int number = 0;
pthread_mutex_t mutex; //创建互斥锁
 
void* funA(void* arg)
{
	for(int i = 0;i<MAX;i++)
	{
		// 上锁
		pthread_mutex_lock(&mutex);
 
		int ret = number;
		ret++;
		number = ret;
		printf("funA num is %d\n", number);
 
		// 解锁
		pthread_mutex_unlock(&mutex);
 
		usleep(10);
	}
}
 
void* funB(void* arg)
{
	for(int i = 0;i<MAX;i++)
	{
		// 上锁
		pthread_mutex_lock(&mutex);
 
		int ret = number;
		ret++;
		number = ret;
		printf("funB num is %d\n", number);
 
		// 解锁
		pthread_mutex_unlock(&mutex);
 
		usleep(10);
	}
}
 
 
int main()
{
	// 初始化锁
	pthread_mutex_init(&mutex,NULL);
 
	pthread_t pth1,pth2;
	pthread_create(&pth1,NULL,funA,NULL);
	pthread_create(&pth2,NULL,funB,NULL);
 
    // 回收进程
	pthread_join(pth1,NULL);
	pthread_join(pth2,NULL);
 
    // 销毁锁
	pthread_mutex_destroy(&mutex);
 
	return 0;
}

2.读写锁

读读不互斥，读写互斥，写写互斥

API

初始化读写锁

#include<pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                        const pthread_rwlockattr_t* restrict attr);
功能：
    用来初始化rwlock所指向的读写锁
参数：
    rwlock：指向要初始化的读写锁指针。
    attr：读写锁的属性指针，如果attr为NULL则会使用默认的属性初始化读写锁，
          否则使用指定的attr初始化读写锁

    可以使用宏PTHREAD_RWLOCK_INITIALIZER静态初始化读写锁，比如：
    pthread_rwlock_t my_rwlock = PTHREAD_RWLOCK_INITIALIZER;
    这种方法等价于使用NULL指定的attr参数调用pthread_rwlock_init()来完成动态初始化，
    不同指出在于PTHREAD_RWLOCK_INITIALIZER宏不进行错误检查。

返回值：
    成功：0，读写锁的状态将成为已初始化和已解锁。
    失败：非0错误码。

加读锁

#include<pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
功能：
    以阻塞方式在读写锁上获取读锁（读锁定）。
    如果没有写者持有该锁，并且没有写者阻塞在该锁上，则调用线程会获取读锁。
    如果调用线程未获取读锁，则它将阻塞直到它获取了该锁。一个线程可以在一个读写锁上多次执行读锁定
    线程可以成功调用pthread_rwlock_rdlock()函数n次，但是之后该线程必须调用pthread_rwlock_unlock()函数n次才能解除锁定
参数：
    rwlock: 读写锁指针。
返回值：
    成功：0
    失败：非0错误码

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
用于尝试以非阻塞的方式来在读写锁上获取读锁
如果有任何的写者持有该锁或有写者阻塞在该读写锁上，则立即失败返回。

加写锁

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

解锁

#include<pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
功能：
    无论是读锁或写锁，都可以通过此函数解锁。
参数：
    rwlock：读写锁指针。
返回值：
    成功：0
    失败：非0错误码。