Linux系统中读写锁的使用详解-优快云博客

本文链接：https://blog.youkuaiyun.com/CSLQM/article/details/53243492

这篇博客深入探讨了Linux线程同步的第二部分，重点介绍了读写锁的概念，包括如何进行初始化和清理、读写锁的功能、加锁与解锁的机制，并通过具体的Unix环境高级编程实例进行了详细说明。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程同步2

读写锁

读写锁与互斥锁类似，不过读写锁允许更高的并行性。读写锁可以有三种状态：(1) 读模式下的加锁状态；(2)写模式下的加锁状态(3)不加锁状态。这个区别与互斥锁的，因为互斥锁只有加锁和不加锁的两种状态。一次只能有一个线程的写状态的读写锁，但是可以有多个线程占有读状态的读写锁。

初始化和清理

#include <pthread.h>

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,

const pthread_rwlockattr_t *restrict attr);

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

功能

读写锁通过调用pthread_rwlock_init进行初始化的，attr =NULL时使用缺省的属性。在释放读写锁占用的内存之前，需要调用pthread_rwlock_destroy函数做清理工作。

加锁和解锁

#include <pthread.h>

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); //写模式下的加锁

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); //读模式下的加锁

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); //无论那种模式都可以用的解锁

unix环境高级编程的例子

//使用读写锁
#include <stdlib.h>
#include <pthread.h>

struct job
{
	struct job *j_next;
	struct job *j_prev;
	pthread_t j_id;
};

struct queue
{
	struct job *q_head;
	struct job *q_tail;
	pthread_rwlock_t q_lock;
};

int queue_init(struct queue *qp)
{
	int err;

	qp->q_head = NULL;
	qp->q_tail = NULL;
	err= pthread_rwlock_init(&qp->q_lock, NULL);

	if(err != 0)
	{
		return(err);
	}

	return(0);
}

void job_insert(struct queue *qp, struct job *jp)
{
	pthread_rwlock_wrlock(&qp->q_lock);
	jp->j_next = qp->q_head;
	jp->j_prev = NULL;
	if(qp->q_head != NULL)
	{
		qp->q_head->j_prev = jp;
	}
	else
	{
		qp->q_tail = jp;
	}

	qp->q_head = jp;
	pthread_rwlock_unlock(&qp->q_lock);
}

void job_append(struct queue *qp, struct job *jp)
{
	pthread_rwlock_wrlock(&qp->q_lock);
	jp->j_next = NULL;
	jp->j_prev = qp->q_tail;
	if(qp->q_tail != NULL)
	{
		qp->q_tail->j_next = jp;
	}
	else
	{
		qp->q_head = jp;
	}
	qp->q_tail = jp;
	pthread_rwlock_unlock(&qp->q_lock);
}

void job_remove(struct queue *qp,struct job *jp)
{
	pthread_rwlock_wrlock(&qp->q_lock);
	if(jp == qp_q_head)
	{
		qp->q_head = jp->next;
		if(qp->q_tail == jp)
		{
			qp->q_tail = NULL;
		}
	}
	else if(jp == qp->q_tail)
	{
		qp->q_tail = jp->j_prev;
		if(qp->q_head == jp)
		{
			qp->q_head = NULL;
		}
	}
	else
	{
		jp->j_prev->j_next = jp->j_next;
		jp->j_next->j_prev = jp->j_prev;
	}
	pthread_rwlock_unlock(&qp->q_lock);
}

struct job *job_find(struct queue *qp, pthread_t id)
{
	struct job *jp;

	if(pthread_rwlock_rdlock(&qp->q_lock) != 0)
	{
		return(NULL);
	}

	for(jp = qp->q_head; jp != NULL; jp = ip->j_next)
	{
		if(pthread_equal(jp->j_id, id))
		{
			break;
		}
	}
	pthread_rwlock_unlock(&qp->q_lock);
	return(jp);
}