C/C++实现redis分布式锁，与事务相比分布式锁有什么优势

最新推荐文章于 2024-10-11 09:20:04 发布
最新推荐文章于 2024-10-11 09:20:04 发布
阅读量2k 收藏 21
点赞数 3
分类专栏： redis 文章标签： redis 分布式锁 事务 SETNX 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35102066/article/details/103313479
版权

在多线程/进程程序中，有些时候会遇到竞态问题，可以使用线程进程间的同步方式解决这个问题，比如说互斥锁，条件变量等。

在redis的使用中，redis服务器是使用单线程处理请求和网络IO的，但是由于其服务于多个客户端，其实还是会存在竞态问题。在redis服务器中本身提供了事务功能，其实事务功能的本质就是一个乐观锁，现在想要在使用redis时实现一个类似于互斥锁的功能。

1.分布式锁的原理

在同一进程中，想要实现线程间的同步是很容易的，借助互斥锁将临界区锁住即可。同一主机中，进程间的同步也可以使用文件和互斥锁进行完成。但是对于redis，想要实现一个互斥锁，用这些是无法办到的，不同主机之间不可能使用某个主机上的文件或者互斥锁进行同步。正确的选择是使用redis服务器的SETNX指令实现

redis> EXISTS job                # job 不存在
(integer) 0
redis> SETNX job "programmer"    # job 设置成功
(integer) 1
redis> SETNX job "code-farmer"   # 尝试覆盖 job ，失败
(integer) 0
redis> GET job                   # 没有被覆盖
"programmer"

可以看到，如果一个键值不存在，那么SETNX可以将这个键设置成功，如果这个键已经存在，那么SETNX设置失败。可以利用这个指令来实现redis数据库的排他性访问。比如客户端在访问某个键值KEY之前，必须使用SETNX将键lock:KEY设置成功之后，才能对KEY进行操作。如果SETNX设置失败，说明别的客户端正在进行操作，需要等到这个lock:KEY被删除后才能重新SETNX成功。

Client AClient B
准备发起对键KEY的修改准备发起对键KEY的修改
SETNX LOCK:KEY 1SETNX LOCK:KEY 1
设置成功，redis服务器返回1(获得锁)设置失败，redis服务器返回0
查看并修改KEY键的值不断尝试获取锁
DEL LOCK:KEY(释放锁)不断尝试获取锁
…SETNX成功(获得锁)
…查看并修改KET键
…DEL LOCK:KEY(释放锁)

通过SETNX可以完成实现不同客户端之间的排他性访问。不过也会有问题，如果一个客户端获取锁之后挂掉了，那么这个锁就不会被释放，其他客户端都不能再获取这个锁了，所以需要给每个锁设置一个时间：

redis> SETNX job "programmer"  
(integer) 1
redis> EXPIRE job 10
(integer) 1

为了省事儿，可以用SET指令的EX模式代替上面两个指令：

SET job "programmer" NX EX 10

该指令等同于上面两个指令的原子操作。

2.分布式锁的实现

来看一下分布式锁的具体实现，使用C/C++实现，接住了C语言的hiredis库对redis服务器进行通信：

bool getLock(redisContext* conn, string& name, char* uuid_buff, int get_timeout = 10, int lock_timeout = 10)
{
	uuid_t uuid;
	uuid_generate_random(uuid);//生成唯一标识符
	uuid_unparse(uuid, uuid_buff);//将标识符转化为字符串
	string lockname = "lock:" + name;//得到锁的名字
	time_t end = time(NULL) + get_timeout;//超过end未获取到锁就放弃
	while (time(NULL) < end)//尝试获取锁
	{
		
		redisReply* reply = (redisReply*)redisCommand(conn, "SET %s %s NX EX %d", lockname.data(), uuid_buff, lock_timeout);//尝试加锁
		if (reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, "OK")==0)//加锁成功返回
		{
			freeReplyObject(reply);
			return true;
		}
		else//加锁失败
		{
			freeReplyObject(reply);
			reply = (redisReply*)redisCommand(conn, "TTL %s", lockname.data());//查看锁的剩余时间
			
			if (reply->type == REDIS_REPLY_INTEGER && reply->integer == -1)//如果锁没有设置超时时间，为它设置一个超时时间
			{
				redisCommand(conn, "EXPIRE %s %d", lockname, lock_timeout);
			}
			freeReplyObject(reply);
		}
	}
	return false;
}
bool releaseLock(redisContext* conn, string& name, char* uuid)
{
	string lockname = "lock:" + name;//获取锁的名字
	while (true)
	{
		freeReplyObject(redisCommand(conn, "WATCH %s", lockname.data()));//监视锁，防止删除过程中锁已经被别的客户端获取了
		redisReply* reply = (redisReply*)redisCommand(conn, "GET %s",lockname.data());
		if (reply->type == REDIS_REPLY_STRING && strcmp(reply->str, uuid) == 0)//查看锁的uuid，以验证是否是属于自己的锁
		{
			redisAppendCommand(conn, "MULTI");//将命令打包
			redisAppendCommand(conn, "DEL %s", lockname.data());
			redisAppendCommand(conn, "EXEC");
			redisGetReply(conn, (void**)&reply);
			freeReplyObject(reply);
			redisGetReply(conn, (void**)&reply);
			freeReplyObject(reply);
			redisGetReply(conn, (void**)&reply);
			if (reply->type!=REDIS_REPLY_NIL)//如果返回不为nil，删除成功
			{
				freeReplyObject(reply);
				return true;
			}
			else//删除过程中锁状态发生了改变，尝试重新删除
			{
				continue;
			}
		}
		freeReplyObject(redisCommand(conn, "UNWATCH", lockname.data()));
		break;
	}
	return false;
}

3.与事务的效率对比

我们现在简单的测试一下分布式锁和事务的效率问题

测试1

现有一个字符串键，键是一个商品名字，值是商品的剩余件数，共计一万件，现在有AB两个客户同时进行购买，每个客户每次只能买两件商品，实现代码如下：

void* ApurchasebyLock(string& name,redisContext* conn)
{//使用分布式锁实现购买
	gettimeofday(&t1, NULL);
	int a = 0;
	while (true)
	{
		char uuid[36];
		getLock(conn, name, uuid);//加锁
		redisReply* reply = (redisReply*)redisCommand(conn, "GET %s", name.data());//获取现有数量
		int num = atoi(reply->str);
		freeReplyObject(reply);
		if (num == 0)//如果卖玩了，就释放锁并退出
		{
			gettimeofday(&t2, NULL);
			cout << "A time:" << t2.tv_sec << "." << t2.tv_usec << "  " << t1.tv_sec << "." << t1.tv_usec << endl;
			cout <<"A"<< " num:" << a << endl;
			releaseLock(conn, name, uuid);
			return NULL;
		}
		num -= 2;//买两件
		a += 2;//a是一个全局变量，用于记录购买的物品件数
		//freeReplyObject(reply);
		freeReplyObject(redisCommand(conn, "SET %s %d",name.data(), num));
		releaseLock(conn, name, uuid);//释放锁
		
	}
	return NULL;
}

void ApurchasebyMulti(string& name,redisContext* conn)
{//使用事务功能实现购买
	gettimeofday(&t1, NULL);
	int a = 0;
	while (true)
	{
		redisReply* reply = (redisReply*)redisCommand(conn, "WATCH %s", name.data());//对这个字符串键进行监视
		freeReplyObject(reply);
		reply = (redisReply*)redisCommand(conn, "GET %s", name.data());//获取剩余件数
		int num = atoi(reply->str);
		freeReplyObject(reply);
		if (num == 0)//如果卖完了，退出
		{
			gettimeofday(&t2, NULL);
			cout << "A time:" << t2.tv_sec << "." << t2.tv_usec << "  " << t1.tv_sec << "." << t1.tv_usec << endl;
			cout << "A" << " num:" << a << endl;
			return;
		}
		num -= 2;
		redisAppendCommand(conn, "MULTI");
		redisAppendCommand(conn, "SET %s %d", name.data(), num);
		redisAppendCommand(conn, "EXEC");//修改剩余件数
		redisGetReply(conn, (void**)&reply);
		freeReplyObject(reply);
		redisGetReply(conn, (void**)&reply);
		freeReplyObject(reply);
		redisGetReply(conn, (void**)&reply);
		if (reply->type != REDIS_REPLY_NIL)//修改成功则购买成功
		{
			a += 2;
		}
		continue;//修改失败，重新进行购买
	}
}

使用两个函数实现了用分布式锁和事务进行购买，测试时使用fork创建子进程模拟两个客户端进行购买，够没完成后两个客户端的购买件数这和都是10000，证明分布式锁和事务都可以很好的解决并发问题。

从时间效率上分析，两种方式大概都用了2.5秒左右，没有特别大的区别。

但是这并不代表分布式锁没有优点，它最大的有点就是，更加灵活，粒度更小，事务功能只能对某个键进行加锁，但是分布式锁可以对键中的数据进行加锁，比如，分布式锁可以单独对哈希表中的某个键值对加锁，但是事务只能对整个哈希表进行加锁。

测试2

现在测试场景是这样的，使用一个哈希表实现一个市场的功能，哈希表中的每一对键值对表示商品的名字和其剩余的数量，每件商品两万件，现在每个客户端执行相同的操作，即从第一个商品开始购买，购买之后购买第二件商品，同种商品的购买每次购买两件，一直执行到货物购买了10000件时停止，下面用分布式锁和事务分别实现这个功能：

void* HApurchasebyLock(vector<string>& names, redisContext* conn)
{//分布式锁实现，names是存有哈希表中所有商品名字的向量
	int a = 0;//已购买的商品数
	gettimeofday(&t1, NULL);//开始购买的时间
	int i = 0;
	while (true)
	{
		if (a == 10000) //已经买够了就退出
		{
			gettimeofday(&t2, NULL);
			cout << "A time:" << t2.tv_sec << "." << t2.tv_usec << "  " << t1.tv_sec << "." << t1.tv_usec << endl;
			cout << "A" << " num:" << a << endl;
			return NULL;
		}
		string name = names[i];//将要购买的商品名字
		i += 1;
		if (i >= names.size())//买到最后一个商品了，下一买第一个商品
		{
			i = 0;
		}
		char uuid[36];
		getLock(conn, name, uuid);//加锁
		redisReply* reply = (redisReply*)redisCommand(conn, "HGET test %s", name.data());
		int num = atoi(reply->str);
		freeReplyObject(reply);
		if (num == 0)//如果卖完了，放弃这次购买
		{
			releaseLock(conn, name, uuid);
			continue;
		}
		num -= 2;
		a += 2;//购买数量加二
		//freeReplyObject(reply);
		releaseLock(conn, name, uuid);
		freeReplyObject(redisCommand(conn, "HSET test %s %d", name.data(), num));//修改剩余数量
		

	}
	return NULL;
}

下面是用事务的实现：

void HApurchasebyMulti(vector<string>& names, redisContext* conn)
{
	gettimeofday(&t1, NULL);
	int i = 0;
	int a = 0;
	while (true)
	{
		if (a == 10000)
		{
			gettimeofday(&t2, NULL);
			cout << "A time:" << t2.tv_sec << "." << t2.tv_usec << "  " << t1.tv_sec << "." << t1.tv_usec << endl;
			cout << "A" << " num:" << a << endl;
			return ;
		}
		string name = names[i];
		i += 1;
		if (i >= names.size())
		{
			i = 0;
		}
		redisReply* reply = (redisReply*)redisCommand(conn, "WATCH test");//监视市场
		freeReplyObject(reply);
		reply = (redisReply*)redisCommand(conn, "HGET test %s", name.data());
		int num = atoi(reply->str);
		freeReplyObject(reply);
		num -= 2;
		redisAppendCommand(conn, "MULTI");//尝试修改剩余数量
		redisAppendCommand(conn, "HSET test %s %d", name.data(), num);
		redisAppendCommand(conn, "EXEC");
		redisGetReply(conn, (void**)&reply);
		freeReplyObject(reply);
		redisGetReply(conn, (void**)&reply);
		freeReplyObject(reply);
		redisGetReply(conn, (void**)&reply);
		if (reply->type != REDIS_REPLY_NIL)//修改成功则购买成功
		{
			a += 2;
		}
		continue;//修改失败，放弃这次购买
	}
}

测试之前在市场中放入了1000000件商品，用8个进程模拟8个客户端进行购买，最终运行局结果：分布式锁用了8秒钟左右，事务用了25秒钟左右。

可以看到分布式锁比起事务有明显的优势。简单分析一下原因：因为锁的更加灵活，可以锁住粒度更小的键值，减少大量的访问冲突和重试，所以效率远远高于事务。且这种优势会随着哈希键内部的键值对的增多，访问客户端数量的增多而越来越大。

东东儿
关注
专栏目录
C++基于redis的分布式锁
Lc_BoYi的博客
12-12 3400
之前无意间看到了一下redis的分布式锁，都没有C++版本的，基本全是java的redission。 闲着没事就写了一个。 以前还以为是redis提供的分布式锁的服务，其实不然，只是redis提供了分布式锁的几个基本特性的服务。 1.是客户端持有锁有时间限制，redis对每个key都可以设置过期时间，所以就很方便去控制锁的过期。 2.redis有发布和订阅的服务， 这样任意...
基于go语言的redis分布式锁实现.zip
05-23
高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。...
C++基于redis的分布式锁redisAPI
12-12
C++的redis的API、 需要boost库、可直接加入工程目录编译
redis分布式锁的实现----C语言
deroy
06-29 618
main.cpp #include "redis.h" #include <unistd.h> int main() { Redis *r = new Redis(); r->connectRedis("127.0.0.1",6379,5); while (r->tryLock(40) != 0) { /* code */ sleep(10); } return 0; } redis.h #ifndef _REDI
C++实现redis分布式锁
weixin_43803780的博客
09-17 1044
如果你使用的是其他库，如`cpp_redis`或`hiredis`等，那么方法名和连接方式会有所不同。下面是一个简单的例子，展示如何使用C++和Redis实现一个基于Redis的分布式锁。- `timeout` 参数用于设置锁的过期时间，这样即使持有锁的进程崩溃了，也不会导致其他进程永远无法获取到锁。#include "your_redis_client.h" // 假设这是你的Redis客户端头文件。- 实际的Redis客户端库API可能会有所不同，请参考所使用的库的具体文档。// 删除key以释放锁。
C++ redis实现分布式锁
最新发布
恋恋风辰的技术博客
10-11 1081
在单机环境中，常见的锁机制如互斥锁（Mutex）用于保护共享资源。然而，在分布式系统中，由于多个进程可能运行在不同的机器上，单纯依赖本地锁无法实现资源的同步访问。这就需要分布式锁来确保跨多个节点的互斥访问。分布式锁的关键特性：同一时刻只有一个客户端可以获取锁。锁有超时机制，防止因客户端故障导致的死锁。即使部分节点失效，锁机制仍然可靠。
C++操作redis（实现连接池、分布式锁）
jiaoooooo的博客
03-05 1636
封装hiredis的一些基本操作，redishelper类提供包含连接，放回，存取键，push，pop，执行redis语句和执行lua脚本的函数，连接池是类模板，传入相应helper类即可实现多种连接池，后续实现mysql连接池。
distr-redis-master.zip_C++操作Redis_redis c++_redis c++_redis分布式_
09-20
本文将深入探讨C++与Redis的交互，以及如何利用C++实现Redis的分布式操作，基于你提供的标题和描述，我们将讨论以下几个关键知识点： 1. **Redis API for C++**：C++中操作Redis主要依赖于第三方库，如`hiredis`或`...
基于Go语言实现的高性能Redis分布式锁服务。.zip
05-23
高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。...
分布式锁的实现
qq_23350817的博客
06-30 1399
分布式
再有人面试问你 Redis 分布式锁的实现，把这篇文章甩给他
01-07
目录 一、写在前面二、Redisson实现Redis分布式锁的底层原理         （1）加锁机制         （2）锁互斥机制         （3）watch dog自动延期机制         （4）可重入加锁机制         （5）锁释放机制         （6）此种方案Redis分布式锁的缺陷 一、写在前面 现在面试，一般都会聊聊分布式系统这块的东西。通常面试官都会从服务框架（Spring Cloud、Dubbo）聊起，一路聊到分布式事务、分布式锁、ZooKeeper等知识。 所以咱们这篇文章就来聊聊分布式锁这块知识，具体的来看看Redis分布式锁的实现原理。 说实话，
Redis分布式锁的实现
oldshaui的博客
05-10 410
最近面试被问道了一些分布式锁相关的问题，今天打算好好把分布式锁的问题看一下 1.先看一下简单的扣库存的例子 这个是最基础的扣库存的例子，在并发问题下肯定是有问题的，有些人可能会说，加个syn或者lock锁不就好咯，但是这面我要说 你想多了吧，syn和lock锁时线程级别的锁，我们现在的项目都是多个节点部署的，都是多进程的，你这个锁时没有用的，下面我们就要来看看我们分布式项目常用的分布式锁的实现来解决这个问题. 2.学习redis的分布式锁，我们先学习这个命令set Redis Setnx（SE
【linuxC/C++】分布式锁实现流程讲解
C/C++Linux、音视频、DPDK
02-16 2307
90分钟搞懂分布式锁实现流程 1. 分布式锁类型、常见实现方式、注意事项 2. redis 实现非公平锁 3. etcd 实现公平锁 上课地址：https://ke.qq.com/course/417774?flowToken=1031343 分布式锁实现流程讲解【linuxC/C++服务器开发】 播放地址 linuxC/C++服务器开发 面试题、学习资料、教学视频和学习路线图（资料包括
redis实现分布式锁
罗布泊coding
06-07 327
1、分布式锁 分布式锁在是一种用来安全访问分式式机器上变量的安全方案，一般用在全局id生成，秒杀系统，全局变量共享、分布式事务等。一般会有两种实现方案，一种是悲观锁的实现，一种是乐观锁的实现。悲观锁的并发性能差，但是能保证不会发生脏数据的可能性小一点。 悲观锁：每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就...
c++ 读写锁_如何用Redis 实现分布式锁的思考
weixin_39824191的博客
11-26 364
锁和分布式锁在计算机中，锁的作用是解决在并发状态下的共享资源互斥问题，保证在同一时间只有一个进程/线程可以掌握资源的控制权。例如以下几种情况：文件锁的实现是为了解决不同用户同时读写同一文件的并发问题而出现的，防止导致文件的内容被破坏。使用数组实现的队列，在 push 操作的地方一般需要加锁来解决槽位的争夺问题，防止出现多次 push 冲突从而导致数据丢失问题。对于12306来说，火车票就是他的资源...
2024年C C++最新C语言--内存函数(3)，2024年最新这些面试官常问的开发面试题你都掌握好了吗
2401_84978588的博客
05-13 476
和memcpy的差别就是memmove函数处理的源内存块和⽬标内存块是。是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容。95%以上C C++开发知识点，真正体系化！出现重叠，就得使⽤memmove函数处理。
java分布式锁_分布式锁的实现
weixin_30134531的博客
02-19 192
前言我们在开发应用时，如果需要对一个共享变量进行多线程同步访问的时候，我们可以使用Java多线程的各个技能点来处理，保证完美运行无BUG。但是这里的都只是单机应用，即在同一个JVM中；然后随着业务发展、微服务化，一个应用需要部署到多台服务器上然后做负载均衡，大概的架构图如下：集群模式下的负载均衡在上图可以看到，变量A在JVM1、JVM2、JVM3三个JVM内存中(这个变量A主要体现是在一个类中的一...
分布式锁
蒙古选手巴勒蒙干
02-24 214
线程锁 在单进程的系统中，当存在多个线程可以同时改变某个变量（可变共享变量）时，就需要对变量或代码块做同步，使其在修改这种变量时能够线性执行消除并发修改变量。而同步的本质是通过锁来实现的。为了实现多个线程在一个时刻同一个代码块只能有一个线程可执行，那么需要在某个地方做个标记，这个标记必须每个线程都能看到，当标记不存在时可以设置该标记，其余后续线程发现已经有标记了则等待拥有标记的线程结束同步...
C++实现Redis分布式操作源码及Demo教程
资源摘要信息: "distr-redis-master.zip是一...通过对以上知识点的理解，开发者可以更有效地利用"distr-redis-master.zip"这份资源，实现高效且安全的Redis分布式操作，以及在C++环境中构建强大的服务器缓存解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值