Linux多线程之读写锁

最新推荐文章于 2024-10-02 03:43:26 发布
最新推荐文章于 2024-10-02 03:43:26 发布
阅读量2.6k 收藏 11
点赞数 3
分类专栏： Linux线程同步 文章标签： Linux 读写锁 代码实现 条件变量 互斥锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/delongwang520/article/details/79713064
版权

概述

一般大家对读写锁应该有一个认知，当读数据比修改数据频繁，我们可以采用读写锁。读写锁的分配规则如下：

  1. 只要没有线程持有某个给定的读写锁用于写时，那么任意数目的线程可以持有该读写锁用于读；
  2. 仅当没有线程持有某个给定的读写锁用于读或写时，才能分配该读写锁用于读。

获取与释放读写锁

     读写锁的类型是pthread_rwlock_t，如果这个类型的某个变量是静态分配的，那么可以通过PTHREAD_RWLOCK_INITIALIZER来初始化它。

            pthread_rwlock_rdlock获取一个读出锁，如果对应的读写锁已由某个写入者持有，那就阻塞调用线程。pthread_rwlock_wrlock获取一个写入锁，如果对应的读写锁已由另一个写入者持有，或者已由一个或多个读出者持有，那就阻塞调用线程。pthread_rwlock_unlock释放一个读出锁或写入锁。

	pthread_rwlock_rdlock(pthread_rwlock_t *rwpt);
	pthread_rwlock_wrlock(pthread_rwlock_t *rwpt);
	pthread_rwlock_unlock(pthread_rwlock_t *rwpt);

               下面两个函数尝试获取一个读出锁或写入锁，但是如果该锁不能马上取得，那就返回一个EBUSY错误，而不是把调用线程投入睡眠。

	pthread_rwlock_tryrdlock(pthread_rwlock_t *rwpt);
	pthread_rwlock_trywrlock(pthread_rwlock_t *rwpt);

读写锁属性

       之前提到过，可通过一个静态分配的读写锁赋常值PTHREAD_RWLOCK_INITIALIZER来初始化它。读写锁变量也可以通过调用pthread_rwlock_init来动态地初始化它。当一个线程不再需要某个读写锁时，可以调用pthread_rwlock_destroy摧毁它。

	pthread_rwlock_init(pthread_rwlock_t *rwpt, const pthread_rwlockattr_t *attr);
	pthread_rwlock_destroy(pthread_rwlock_t *rwpt);

      初始化某个读写锁时，如果attr是空指针，那就使用默认属性。要赋予它非默认的属性，需使用下面两个函数。

	pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
	pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);

     数据类型为pthread_rwlockattr_t的某个属性对象一旦初始化，就通过调用不同的函数来启用或禁止特定属性。当前定义了唯一属性是PTHREAD_PROCESS_SHARED,它指定相应的读写锁将在不同进程间共享，而不仅仅是在单个进程内的不同线程间共享。以下两个函数分别获取和设置这个属性。

	pthread_rwlockattr_getpshared(pthread_rwlockattr_t *attr, int *valptr);
	pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int value);

     第一个函数在由valptr指向的整数中返回该属性的当前值。第二个函数把该属性的当前值设置为value,其值或为PTHREAD_PROCESS_PRIVATE，或为PTHREAD_PROCESS_SHARED。

使用互斥锁和条件变量实现读写锁

       只需要使用互斥锁和条件变量就能实现读写锁。下面将看到一种可能的实现，该实现优先考虑等待着的写入者。当然可以有其它方案。

       首先给出pthread_rwlock.h的头文件，它定义了基本的pthread_rwlock_t的数据类型和操作读写锁的各个函数的函数原型，通常情况下它们是在<pthread.h>头文件中。

      

#ifndef __pthread_rwlock_h
#define __pthread_rwlock_h
typedef struct
{
	pthread_mutex_t rw_mutex;
	pthread_cond_t  rw_condreaders;
	pthread_cond_t  rw_condwriters;

	int rw_magic;
	int rw_nwaitreaders;
	int rw_nwaitwriters;
	int rw_refcount;
}pthread_rwlock_t;

#define RW_MAGIC 0x19283746
#define PTHREAD_RWLOCK_INITIALIZER { PTHREAD_MUTEX_INITIALIZER,\
	PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER,\
	RW_MAGIC,0,0,0}
typedef int pthread_rwlockattr_t;

int pthread_rwlock_destroy(pthread_rwlock_t *);
int pthread_rwlock_init(pthread_rwlock_t *, pthread_rwlockattr_t* );
int pthread_rwlock_rdlock(pthread_rwlock_t *);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
int pthread_rwlock_trywrlock(pthread_rwlock_t *);
int pthread_rwlock_wrlock(pthread_rwlock_t *);
int pthread_rwlock_unlock(pthread_rwlock_t *);
#endif

pthread_rwlock_t数据类型含有一个互斥锁、两个条件变量、一个标志及三个计数器。无论何时检查或操作该结构，都必须持有其中的互斥锁成员rw_mutex。该结构初始化成功后，标志成员rw_magic就被设置成RW_MAGIC。所有函数都测试该成员，以检查调用者是否向某个已初始化的读写锁传递了指针。该读写锁被摧毁时，这个成员就被设置为0。

注意计数器成员之一rw_refcount总是指示着本读写锁的当前状态：-1表示它是一个写入锁，0表示它是可用的，大于0的值则意味着它当前容纳着那么多的读出锁。

下面给出phread_rwlock_int函数的实现，它动态地初始化一个读写锁。

int pthread_rwlock_init(pthread_rwlock_t *rw, pthread_rwlockattr_t *attr)
{
	int result;

	if (attr != NULL)
	{
		return (EINVAL);
	}

	if ((result = pthread_mutex_init(&rw->rw_mutex, NULL)) != 0)
		goto err1;
	if ((result = pthread_cond_init(&rw->rw_condreaders, NULL)) != 0)
		goto err2;
	if ((result = pthread_cond_init(&rw->rw_condwriters, NULL)) != 0)
		goto err3;
	rw->rw_nwaitreaders = 0;
	rw->rw_nwaitwriters = 0;
	rw->rw_refcount = 0;
	rw->rw_magic = RW_MAGIC;
	return 0;
err3:
	pthread_cond_destroy(&rw->rw_condreaders);
err2:
	pthread_mutex_destroy(&rw->rw_mutex);
err1:
	return(result);
}

该函数不支持给读写锁赋属性，因此检查其attr是否为一个空指针。

初始化由调用者指定其指针的读写锁结构中的互斥锁和两个条件变量的成员。所有三个计数器成员都设置为0，rw_magic成员则设置为表示该结构已初始化完毕的值。

如果互斥锁或条件变量的初始化失败，那么小心地确保摧毁已初始化的对象，然后返回一个错误。

pthread_rwlock_destroy函数，当其所在的所有线程都不再持有也不试图持有某个读写锁的时候摧毁该锁。

int pthread_rwlock_destroy(pthread_rwlock_t *rw)
{
	if (rw->rw_magic != RW_MAGIC)
		return (EINVAL);
	if ((rw->rw_refcount != 0)
		|| (rw->rw_nwaitreaders != 0)
		|| (rw->rw_nwaitwriters != 0))
	{
		return (EBUSY);
	}
	pthread_mutex_destroy(&rw->rw_mutex);
	pthread_cond_destroy(&rw->rw_condreaders);
	pthread_cond_destroy(&rw->rw_condwriters);
	rw->rw_magic = 0;
	return 0;
}

首先检查由调用者指定的读写锁已不在使用中，然后给其中的互斥锁和两个条件变量成员调用合适的摧毁函数。

pthread_rwlock_rdlock函数的实现如下所示：

int pthread_rwlock_rdlock(pthread_rwlock_t *rw)
{
	int result;

	if (rw->rw_magic != RW_MAGIC)
		return EINVAL;
	if ((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return result;
	while ((rw->rw_refcount < 0)
		|| ( rw->rw_nwaitwriters > 0 ))
	{
		rw->rw_nwaitreaders++;
		result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);
		rw->rw_nwaitreaders--;
		if (result != 0)
			break;
	}

	if (0 == result)
		rw->rw_refcount++;
	pthread_mutex_unlock(&rw->rw_mutex);
	return result;

}

无论何时操作pthread_rwlock_t类型的结构，都必须给其中的rw_mutex成员上锁。

如果rw_refcount小于0,意味着当前有一个写入者持有由调用者指定的读写锁，或者有线程正等着获取该读写锁的一个写入锁，rw_waitwriters大于0，那么我们无法获取该读写锁的一个读出锁。如果这两个条件有一个为真，那么我们就把rw_waitreaders加1。并在rw_condreaders条件变量上调用pthread_cond_wait。取得读出锁之后，把rw_refcount加1。互斥锁旋即释放。

pthread_rwlock_tryrdlock函数在尝试获取一个读出锁时并不阻塞，它的实现如下：

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rw)
{
	if (rw->rw_magic != RW_MAGIC)
		return EINVAL;
	if ((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return result;
	if ((rw->rw_refcount < 0)
		|| (rw->rw_nwaitwriters > 0))
		return EBUSY;
	else
		rw->rw_refcount++;
	pthread_mutex_unlock(&rw->rw_mutex);
	return result;
}

如果当前有一个写入者持有调用者指定的读写锁，或者线程在等待该读写锁的一个写入锁，那么就返回EBUSY错误，否则，把rw_refcount加1获取该读写锁。

pthread_rwlock_wrlock函数获取一个写入锁，实现如下：

int pthread_rwlock_wrlock(pthread_rwlock_t *rw)
{
	int result;

	if (rw->rw_magic != RW_MAGIC)
		return EINVAL;
	if ((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return result;
	while (rw->rw_refcount != 0 )
	{
		rw->rw_nwaitwriters++;
		result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);
		rw->rw_nwaitwriters--;
		if (result != 0)
			break;
	}

	if (0 == result)
		rw->rw_refcount = -1;
	pthread_mutex_unlock(&rw->rw_mutex);
	return result;
}

只要有读出者持有由调用者指定的读写锁的读出锁，或者有一个写入持有该读写锁的唯一写入锁，这两者情况rw_refcount都不为0，调用线程就得阻塞，为此，把rw_nwaitwriters加1，然后在rw_condwaitwriters条件变量上调用pthread_cond_wait,可以看到，向该条件变量发送信号的前提是，读写锁被释放并且有写入者在等待。

取得写入锁之后，把rw_refcount置为-1。

下面是pthread_rwlock_trywrlock函数的实现，该函数不是阻塞的。

int pthread_rwlock_trywrlock(pthread_rwlock_t *rw)
{
	if (rw->rw_magic != RW_MAGIC)
		return EINVAL;
	if ((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return result;
	if ( rw->rw_refcount != 0 )
		return EBUSY;
	else
		rw->rw_refcount = -1
	pthread_mutex_unlock(&rw->rw_mutex);
	return result;
}

该函数的实现和pthread_rwlock_tryrdlock很相似。

最后一个函数就是pthread_rwlock_unlock的实现：

int pthread_rwlock_unlock(pthread_rwlock_t *rw)
{
	int result;

	if (rw->rw_magic != RW_MAGIC)
		return EINVAL;
	if ((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return result;
	if (rw->rw_refcount > 0)
		rw->rw_refcount--;
	else if (-1 == rw->rw_refcount)
		rw->rw_refcount = -1;
	else
		printf("rw->rw_refcount=%d\n", rw->rw_refcount);
	if (rw->rw_nwaitwriters > 0)
	{
		if (0 == rw->rw_refcount)
			result = pthread_cond_signal(&rw->rw_condwriters);
	}
	else if (rw->rw_nwaitreaders > 0)
	{
		result = pthread_cond_broadcast(&rw->rw_condreaders);
	}
	pthread_mutex_unlock(&rw->rw_mutex);
	return result;
}

如果rw_refcount当前大于0，那么有一个读出者准备释放一个读出锁。如果rw_refcount为-1，那么有一个写入者准备释放一个写入锁。


cncoderwang
关注
专栏目录
linux多线程之读写锁
daiyudong2020的博客
08-13 2573
基本概念： 读写锁也叫做共享互斥锁。 当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态，所有试图以读模式对它进行加锁的线程都可以得到访问权。 与互斥量相比，读写锁在使用之前必须初始化，在释放它们底层的内存之前必须销毁。 一、锁的初始化与销毁 PTHREAD_RWLOCK_DESTROY(P) POSIX Programmer
Linux多线程同步机制—读写锁(Read-Write Lock)
wjianwei666的专栏
07-09 956
读写锁（Read-Write Lock）是一种线程同步机制，用于管理对共享资源的访问。与互斥锁（Mutex）不同，读写锁允许多个线程同时以读模式访问共享资源，但只允许一个线程以写模式访问资源。这种机制特别适用于读操作远多于写操作的场景，可以显著提高程序的并发性能。自定义实现读写锁代码需要开发者更深入地理解读写锁的底层实现原理。完全自行实现读写锁的逻辑，通过互斥锁、条件变量以及自定义的读计数和写标志来管理读写操作的同步。// 定义读写锁结构体// 互斥锁，用于保护读写锁的内部状态。
linux线程同步(3)-读写锁
qq_31901665的博客
01-20 263
linux线程同步(3)-读写锁 一.概述                                                    读写锁与互斥量的功能类似，对临界区的共享资源进行保护！互斥量一次只让一个线程进入临界区，读写锁比它有更高的并行性。读写锁有以下特点： 1.如果一个线程用读锁锁定了临界区，那么其他线程也可以用读锁来进入临界区，这样就可以多个线程并行操作。但这个时
漫话linux：线程锁
最新发布
whcwhc111111的博客
10-02 750
一个函数在重入的情况下，运行结果不会 出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数，可重入的一般也是线程安全的。临界区中，线程可以切换，在线程被切出去的时候，是持有锁被切走的。我不在期间，照样没有人能进入临界区访问临界资源，对于其他线程来讲，一个线程要么么有锁，要么释放锁，当前线程访问临界区的过程，对于其他线程是原子的。交换的本质：把内存中的数据（共享），交换到 CPU 的寄存器中，其实是换到 CPU 此时执行的线程的硬件上下文中，数字 1 （锁）只有一个，随着上下文走了。
Linux 读写锁
FixTheCoder
09-04 696
1.读写锁是几把锁 一把锁 pthread_rwlock_t lock; 2.读写锁的类型 读锁 - 对内存做读操作 写锁 - 对内存做写操作 3.读写锁的特性 线程A加读锁成功，又来了三个线程，做读操作，可以加锁成功 线程A加写锁成功，又来了三个线程，做读操作，三个线程阻塞 线程A加读锁成功，又来了B线程加写锁阻塞，又来了C线程加读锁阻塞 4.主要操作函数 ...
Linux多线程的同步------读写锁
qq_45829112的博客
12-05 1732
前面介绍过Linux多线程同步的另外两个方法------互斥锁和信号量 Linux多线程的同步-----信号量和互斥锁_神厨小福贵！的博客-CSDN博客 下面来看一下读写锁： 读写锁和互斥锁都带有一个锁，那么他们有什么区别呢？ 读写锁： 读写锁 互斥锁 多个读操作可以同时进行 一次只有一个线程拥有互斥锁，其他线程只有等待 写操作之间必须互斥 读写操作之间也是互斥的，且写操作的应优先于读操作(写操作执行的时候，其他函数都在阻塞) 上面说...
Linux系统应用编程 --- 多线程同步之读写锁【rwlock】
M2嵌入式
04-18 331
1. 读写锁函数 1.1 读写锁概念介绍 读写锁是互斥锁的升级版，在做读操作的时候可以提高程序的执行效率，如果所有的线程都是做读操作, 那么读是并行的，但是使用互斥锁，读操作也是串行的。 读写锁是一把锁，锁的类型为 pthread_rwlock_t，有了类型之后就可以创建一把互斥锁了： pthread_rwlock_t rwlock; 之所以称其为读写锁，是因为这把锁既可以锁定读操作，也可以锁定写操作。为了方便理解，可以大致认为在这把锁中记录了这些信息： 锁的状态：锁定 / 打开 锁定的是什
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
linux 多线程读写文件
jiletianzun的博客
03-04 1464
#include <stdio.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #include <fcntl.h> #include <assert.h> #include <sys/stat.h> #include <sys/types.h> #include <pthread.h> #include<iostre
Linux多线程编程_linux多线程_Linux多线程；应用笔记_columnc9g_
10-03
在Linux多线程编程中，我们通常使用POSIX线程库（pthread），它提供了跨平台的线程创建、同步和通信功能。下面是一些关键知识点： 1. **线程创建**：pthread库的`pthread_create()`函数用于创建新线程。它需要传入...
linux读写锁
fengdijiang的专栏
09-15 625
class API_EXPORT CReadWriteLock { public: CReadWriteLock(); ~CReadWriteLock(); ///获得读锁 /** *@return 非零 表示失败，原因需检查系统错误， 0表示成功 */ i
linux下实现高性能读写锁（read/write lock）
07-07
在linux下按照windows的slim read/write lock算法实现的读写锁源码。
linux顺序锁
疯狂学linux
09-30 1381
#include #include #include #include #include #include//顺序锁头文件 static int i=0,j=100;//一个线程从0开始加，一个线程从100开始加 struct task_struct *MyThread1=NULL;//线程1 struct task_struct *MyThread2=NULL;//线程2 st
Linux读写锁
qq_34999565的博客
08-12 338
读写锁和互斥锁类似，但是读写锁允许更高的并行性。互斥锁要么是锁住状态，要么是不加锁状态，而且一次只有一个线程可以对其加锁。考虑这样一种场景，多个线程对一个文件进行读写操作，线程操作前先加锁，通常对文件的只读操作不会改变文件的状态，因此可以允许多个线程同时读取文件。如果使用互斥锁是做不到这一点的，这时候读写锁就上场了。读写锁就是用来解决这个问题的，读操作可以共享，写操作是排他的，可以有多个线程同时在读，但同一时间只能有一个线程写，同时线程写的时候不允许其它线程读。 读写锁可以有三种状态：读模式加锁状态，写模
线程同步---互斥锁的升级版：读写锁
DongZhaoCheng
07-09 188
读写锁的读锁锁定临界区之后，线程对临界区的访问是并行的，读锁是共享的；多个线程可以同时访问被读锁锁定的区域 读写锁的写锁锁定临界区之后，线程对临界区的访问是串行的，读锁是独占的；类似互斥锁，写锁被锁定时，其他的线程无法获取锁 使用读写锁，同时对两个临界区加了读锁和写锁，两个线程需要同时访两个临界区，此时访问写锁临界区的线程优先执行，因为其优先级高于读锁.........
Linux读写锁实现多线程读写示例
本资源提供了一个使用Linux读写锁（`pthread_rwlock_t`）的典型应用实例，展示了如何在多线程环境下实现并发读写操作。在这个例子中，创建了四个线程，其中两个用于读取数据（线程1和线程2），另外两个用于写入数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值