c语言跨平台共享锁封装

共享锁也称为读写锁，其特点是读和读不互斥，读写互斥，写写互斥。在多线程开发中一般使用在多个读单个写入的场景，比如将摄像头的画面读取后显示并同时编码推流。c语言做跨平台开发，实现一个共享锁封装对象还是有用的。

一、接口设计：

1、数据结构：

共享锁一般是在互斥锁的基础上实现的，所以需要用到互斥锁，这里直接使用了我另外一篇文章《c语言跨平台共享锁封装》作为互斥锁，以减少一些宏代码。为了灵活内存选择策略，直接定义字段在头文件，不采用pimp的方式。

#include "acf_mutex.h"
/// <summary>
/// 共享锁对象
/// </summary>
typedef struct {
	/// <summary>
	/// 读互斥锁
	/// </summary>
	acf_mutex readerMutex;
	/// <summary>
    /// 互斥锁
    /// </summary>
	acf_mutex mutex;
	/// <summary>
	/// 读的数量
	/// </summary>
	int readerCount;
} acf_shared_mutex;

2、方法

（1）、初始化

共享锁对象使用前需要初始化，传入共享锁对象的指针。

/// <summary>
/// 初始化
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
void  acf_shared_mutex_init(acf_shared_mutex* mutex);

（2）、反初始化

共享锁对象销毁前需要反初始化，传入共享锁对象的指针。

/// <summary>
/// 反初始化
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
void  acf_shared_mutex_deinit(acf_shared_mutex* mutex);

（3）、加读锁

以读锁的方式进入，多线程环境中调用此方法，第一个线程进入读锁的后，其他线程调用此方法同样可以进入锁，但是如果调用读锁则会等待。

/// <summary>
/// 加共享锁
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
void  acf_shared_mutex_share_lock(acf_shared_mutex* mutex);

（4）、尝试加读锁

尝试进入读锁而不等待，直接返回，返回1进入成功，0进入失败。

/// <summary>
/// 尝试加共享（读）锁
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
/// <returns>1成功，0失败</returns>
int  acf_shared_mutex_try_share_lock(acf_shared_mutex* mutex);

（5）、解读锁

执行完成读操作后，需要调用解读锁退出，将资源让出给其他线程使用。注意，“解读锁”必须与“加读锁”对应，不能与写锁混合使用。

/// <summary>
/// 解读锁
/// </summary>
/// <param name="mutex"></param>
void  acf_shared_mutex_share_unlock(acf_shared_mutex* mutex);

 （6）、加写锁

以写锁的方式进入。多线程环境中调用此方法，只有不存在读锁以及其他写锁时才能进入，否则只能等待。有一个线程进入写锁的后，其他线程想进入读锁或者写锁都只能等待。

/// <summary>
/// 加写锁
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
void  acf_shared_mutex_lock(acf_shared_mutex* mutex);

（7）、尝试加写锁

尝试进入写锁而不等待，直接返回，返回1进入成功，0进入失败。

/// <summary>
/// 尝试加写锁
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
/// <returns>1成功，0失败</returns>
int  acf_shared_mutex_try_lock(acf_shared_mutex* mutex);

 （8）、解写锁

执行完成写操作后，需要调用解写锁退出，将资源让出给其他线程使用。注意，“解写锁”必须与“加写锁”对应，不能与读锁混合使用。

/// <summary>
///  解写锁
/// </summary>
/// <param name="mutex">共享锁对象的指针</param>
void  acf_shared_mutex_unlock(acf_shared_mutex* mutex);

二、关键实现

1、读锁进入

读锁进入时需要先记录读锁的数量，第一个读锁进入时需要加互斥锁，以确保和写锁互斥，后面的读锁进入则只需要加计数即可。

void  acf_shared_mutex_share_lock(acf_shared_mutex * _this) {

	acf_mutex_lock(&_this->readerMutex);
	_this->readerCount++;
	if (_this->readerCount == 1)
	{
		acf_mutex_lock(&_this->mutex);
	}
	acf_mutex_unlock(&_this->readerMutex);
}

2、读锁退出

读锁退出时需要先更新读锁的数量，最后一个读锁退出需要解互斥锁，确保其他锁能够正常进入。

void  acf_shared_mutex_share_unlock(acf_shared_mutex * _this) {
	acf_mutex_lock(&_this->readerMutex);
	_this->readerCount--;
	if (_this->readerCount == 0)
	{
		acf_mutex_unlock(&_this->mutex);
	}
	acf_mutex_unlock(&_this->readerMutex);
}

三、使用例子

#include"Thread/acf_thread.h"
#include"Thread/acf_shared_mutex.h"
#include<stdio.h>
static acf_shared_mutex _mutex;
static void write(void* arg) {
	printf("thread %d request write lock\n", (int)arg);
	//进入写锁
	acf_thread_sleep(100);
	acf_shared_mutex_lock(&_mutex);
	printf("thread %d got write lock\n", (int)arg);
	acf_thread_sleep(3000);
	//退出写锁
	acf_shared_mutex_unlock(&_mutex);
	printf("thread %d leave write lock\n", (int)arg);
}
static void read(void* arg) {
	printf("thread %d request read lock\n", (int)arg);
	acf_thread_sleep(200);
	//进入写锁
	acf_shared_mutex_share_lock(&_mutex);
	printf("thread %d got read lock\n", (int)arg);
	acf_thread_sleep(2000);
	//退出写锁
	acf_shared_mutex_share_unlock(&_mutex);
	printf("thread %d leave read lock\n", (int)arg);
}
int main(int argc, char** argv) {
	//初始化共享锁
	acf_shared_mutex_init (&_mutex);
	//创建写线程1
	acf_thread thead1 = acf_thread_create(write, 1);
	//创建读线程2
	acf_thread thead2 = acf_thread_create(read, 2);
	//创建读线程3
	acf_thread thead3 = acf_thread_create(read, 3);
	acf_thread_wait_destroy(thead1);
	acf_thread_wait_destroy(thead2);
	acf_thread_wait_destroy(thead3);
	//反初始化共享锁
	acf_shared_mutex_deinit(&_mutex);
	return 0;
}

四、完整代码

https://download.csdn.net/download/u013113678/24347928