知识随记-----使用现代C++客户端库redis-plus-plus实现redis池缓解高并发

🚀 知识随记-----使用现代C++客户端库redis-plus-plus实现redis池缓解高并发

📅 更新时间:2025年7月31日

🏷️ 标签:现代化C++ | redis | redis-plus-plus | redis池 | 高并发

项目场景:

当我们需要用redis的时候,比如实现邮箱验证服务,我们需要判断验证码是否过期,可以使用redis,让邮箱为key,验证码为value,设置过期时间


问题描述

多客户端需验证码场景下 ,若仅用单个 Redis,每次交互均需执行 Redis 客户端实例化→建立连接→执行操作→断开连接 流程,造成高频连接创建与销毁的资源浪费


原因分析:

高频连接创建与销毁造成资源浪费的核心原因在于:​

1.连接建立的固有开销 :每次新建连接需经历 TCP 三次握手、Redis 协议协商及可能的认证流程,这些操作涉及内核态与用户态切换、网络数据包交互,会消耗客户端与服务端的 CPU 算力

2.短连接的资源低效性 :验证码存储属于短耗时操作(毫秒级), 连接建立 / 销毁的耗时(通常几十至数百毫秒)远超业务操作本身,导致大量 CPU 时间被用于非核心业务逻辑

3.连接管理的额外损耗 :Redis 服务端需为每个连接维护文件描述符、缓冲区等资源,高频创建销毁会引发这些资源的频繁分配与回收,加重内存管理负担

4.并发场景的放大效应 :多客户端并发请求时,短连接模式会瞬间产生大量连接请求,可能触发系统级别的连接数限制或端口耗尽,进一步加剧资源竞争与响应延迟


解决方案:

通过建立 Redis 连接池(Redis Pool)优化连接管理流程,具体如下:​

1.初始化连接池:项目启动时预先创建并初始化一定数量的 Redis 连接,统一纳入连接池管理,避免后续频繁创建新连接。​

2.连接获取与归还机制:​

定义 GetConnection 函数:当客户端需要操作 Redis 时(如存储 / 校验验证码),从连接池获取已建立的空闲连接,直接复用现有连接资源。​

定义 ReturnRedis 函数:操作完成后,将连接归还给连接池而非直接销毁,使其可被其他客户端再次调用,实现连接的循环复用。​

通过上述方式,可彻底规避高频连接创建与销毁的资源浪费,提升多客户端并发场景下的 Redis 操作效率与系统稳定性

实现redis池:

代码

cpp 复制代码
#pragma once
#include"const.h"

class RedisConPool
{
public:
	RedisConPool(std::size_t PoolSize, const std::string& host, const std::string& port, const std::string& password);
	~RedisConPool();
	std::unique_ptr<sw::redis::Redis> GetConnection();
	void ReturnConnection(std::unique_ptr<sw::redis::Redis> redis);
	void Close();

private:
	std::size_t _poolsize;
	std::string _host;
	std::string _port;
	std::string _password;
	std::queue<std::unique_ptr<sw::redis::Redis>> _redis_queue;
	std::condition_variable _cond;
	std::atomic<bool> _bstop;
	std::mutex _mutex;
};
cpp 复制代码
#include "RedisConPool.h"

RedisConPool::RedisConPool(std::size_t PoolSize, const std::string& host, const std::string& port, const std::string& password):_host(host),_port(port),
_password(password), _bstop(false), _poolsize(PoolSize)
{
	for (std::size_t i = 0; i < _poolsize; i++)
	{
		try
		{
			std::string path = "tcp://" + host + ":" + port;

			auto _redis = std::make_unique<sw::redis::Redis>(path);

			if (!_password.empty())
			{
				_redis->auth(_password);
			}

			std::cout << "redis尝试连接" << std::endl;
			_redis->ping();
			_redis_queue.push(std::move(_redis));
			std::cout << "redis成功放入队列" << std::endl;

		}
		catch (const sw::redis::Error& e)
		{
			std::cout << "error in RedisConPool catch and  " ;
			std::cout << "error is" <<e.what() << std::endl;
			continue;
		}
	}
}

RedisConPool::~RedisConPool()
{
	Close();
	std::lock_guard<std::mutex> lock(_mutex);
	while (!_redis_queue.empty())
	{
		_redis_queue.pop();
	}
}

void RedisConPool::Close()
{
	_bstop = true;
	_cond.notify_all();
}


std::unique_ptr<sw::redis::Redis> RedisConPool::GetConnection()
{
	if (_bstop)return nullptr;
	std::unique_lock<std::mutex> lock(_mutex);

	_cond.wait(lock, [this]() {

		if (_bstop)return false;

		return !_redis_queue.empty();

		});

	if (_bstop)return nullptr;

	auto redis =std::move( _redis_queue.front());
	_redis_queue.pop();
	return redis;
}


void RedisConPool::ReturnConnection(std::unique_ptr<sw::redis::Redis> redis)
{
	if (redis == nullptr)return;

	std::lock_guard<std::mutex> lock(_mutex);
	if (_bstop)return;

	try
	{
		redis->ping();
		_redis_queue.push(std::move(redis));
		_cond.notify_one();
	}
	catch(const sw::redis::Error& e)
	{
		std::cout << "返回无效,丢弃连接: " << e.what() << std::endl;
	}
}

细节点

std::size_t _poolsize 定义池大小

std::string _host 连接redis所需的地址

std::string _port 连接redis所需的端口号

std::string _password 连接redis所需的密码

std::queue<std::unique_ptr< sw::redis::Redis>> _redis_queue 存储redis的队列

std::condition_variable _cond 与互斥锁(如 std::mutex)配合使用 , 实现线程的等待与唤醒机制

std::atomic _bstop 原子性布尔值 用来判断是否停止

std::mutex _mutex 锁


构造函数

cpp 复制代码
RedisConPool::RedisConPool(std::size_t PoolSize, const std::string& host, 
const std::string& port, const std::string& password)

我们在构造函数中进行初始化,并且将所有redis进行连接并且放入队列


析构函数

cpp 复制代码
RedisConPool::~RedisConPool()

析构函数中我们调用Close()并且要将队列清空


Close()函数

将条件变量变为true 并且发送信号 唤醒所有正在等待的线程


获取redis函数

cpp 复制代码
std::unique_ptr<sw::redis::Redis> RedisConPool::GetConnection()

通过加锁获取池中的redis

如果暂时无法获取,通过std::condition_variable达到线程休眠的机制,提高了并发性 减少了资源浪费

std::condition_variable机制如下:

cpp 复制代码
_cond.wait(参数1,参数2)

wait() 是条件变量的核心函数,用于让当前线程进入等待状态,直到被唤醒且条件满足。它有两个参数:

第一个参数 lock :一个已经加锁的 std::unique_lock< std::mutex> 对象(必须是 unique_lock,因为 wait() 内部需要临时解锁

第二个参数 predicate :一个可调用对象(如函数、lambda 表达式 ),返回 bool,代表 "线程被唤醒后继续执行的条件

执行流程:

线程被唤醒后,会重新获取互斥锁(此时 lock 再次处于加锁状态),然后检查 predicate:

如果 predicate 返回 true:wait() 函数返回,线程继续执行后续代码(此时条件已满足)。

如果 predicate 返回 false:重复步骤 1,再次释放锁并进入休眠,等待下一次唤醒


归还redis函数

cpp 复制代码
void RedisConPool::ReturnConnection(std::unique_ptr<sw::redis::Redis> redis)

通过加锁,将用完后的redis归还到redis队列中


相关推荐
CHEN5_021 分钟前
【Java面试题】缓存穿透
java·开发语言·数据库·redis·缓存
一方热衷.1 小时前
YOLOv8/YOLOv11 C++ OpenCV DNN推理
c++·opencv·yolo
玖剹2 小时前
Linux文件系统:从内核到缓冲区的奥秘
linux·c语言·c++·笔记·ubuntu
Code季风2 小时前
深入理解 Redis 分布式锁:实现互斥保障的最佳实践
redis·分布式·微服务
凤年徐2 小时前
【数据结构与算法】21.合并两个有序链表(LeetCode)
c语言·数据结构·c++·笔记·算法·链表
jdlxx_dongfangxing3 小时前
2024 年 NOI 最后一题题解
c++·noi
民乐团扒谱机3 小时前
【微实验】圆周运动的正弦信号发生仿真及其衍生(三)
经验分享·matlab·仿真·信号与系统·声音·微实验
Dxy12393102163 小时前
报错:selenium.common.exceptions.ElementNotInteractableException: Message
selenium·测试工具·microsoft
近津薪荼5 小时前
c++详解(宏与内联函数,nullptr)
开发语言·c++
淮北4946 小时前
STL学习(十一、常用的算数算法和集合算法)
c++·vscode·学习·算法