个人redis连接池，hiredis,欢迎共同探讨

最新推荐文章于 2024-05-29 11:36:12 发布
最新推荐文章于 2024-05-29 11:36:12 发布
阅读量495 收藏 2
点赞数
分类专栏： hiredis 文章标签： hiredis实现连接池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/abqchina/article/details/100577955
版权
本文档展示了使用hiredis库实现的一个名为MyRedisPool的Redis连接池，包括初始化连接、获取连接、发布/订阅、管道操作等功能。通过连接池管理Redis连接，提高了代码的复用性和效率。

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

#ifndef _MY_REDIS_POOL_HPP_
#define _MY_REDIS_POOL_HPP_


#include <cstdio>
#include <cstdlib>
#include <string>
#include <time.h>
#include <vector>
#include <queue>
#include<mutex>
#include <hiredis/hiredis.h>

#ifdef _WIN32
//编译 hiredis 会生成这2个库
#pragma comment(lib, "hiredis.lib")
#pragma comment(lib,"Win32_Interop.lib")
#endif // _WIN32

typedef struct RedisNode
{
    int id;
    redisContext *c;
    bool isUsed;
};

class MyRedisPool
{
public:
    static MyRedisPool& GetInstance();
protected:
    MyRedisPool();
    ~MyRedisPool();
private:
    MyRedisPool(const MyRedisPool& rhs) {}
    MyRedisPool& operator = (const MyRedisPool& rhs) {}

public:
    bool InitConnect(std::string const& host, std::string const& password, int port,int count);
    RedisNode& GetConnect(bool& isSuccess);
    bool GetRedisReply(redisReply *&reply);
    bool AddConnect();
    bool DisConnect();
    bool BackConnect(RedisNode& node);
    bool GetLPOP(std::string const&key, std::string&value, int dbName);
    bool SetLPUSH(std::string const&key, std::string&value, int dbName);
    bool GetLRange(std::string const&key, int dbName, int start, int end, std::vector<std::string>& result);
    bool SetString(std::string const&key, std::string&value, int dbName);
    bool GetString(std::string const&key, std::string&value, int dbName);
    bool SetInt(std::string const&key, int &number, int dbName);
    bool GetInt(std::string const&key, int &number, int dbName);
    bool SUBSCRIBE(std::string const&theme);
    bool PUBLISH(std::string const& theme, std::string const& content);
    bool GetLPOPByPipeline(std::string const&key, std::string&value, int dbName);
    bool SetLPUSHByPipeline(std::string const&key, std::string&value, int dbName);
    bool GetLRangeByPipeline(std::string const&key, int dbName, int start, int end, std::vector<std::string>& result);
    bool SetStringByPipeline(std::string const&key, std::string&value, int dbName);
    bool GetStringByPipeline(std::string const&key, std::string&value, int dbName);
    bool SetIntByPipeline(std::string const&key, int &number, int dbName);
    bool GetIntByPipeline(std::string const&key, int &number, int dbName);
protected:
    bool CreateOneConnect(redisContext *&c);
private:
    std::string m_Host;
    int m_Port;
    std::string m_PassWord;
    int m_MaxConnects;
    int m_CurConnects;
    std::vector<RedisNode> m_RedisVec;
    std::queue<int> m_QueueId;
    std::mutex m_Lock;
    std::mutex m_PrintLock;
    bool m_runing;
};

MyRedisPool::MyRedisPool()
{
    m_runing = true;
}
MyRedisPool::~MyRedisPool()
{
    DisConnect();
    printf("析构了...\n");
}
bool MyRedisPool::GetRedisReply(redisReply *&reply)
{
    if (reply)
    {
        if (reply->type == REDIS_REPLY_ERROR)
        {
            std::lock_guard<std::mutex> lck(m_PrintLock);
            fprintf(stderr, "error: %s\n", reply->str);
            freeReplyObject(reply);
            return false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
}
bool MyRedisPool::GetLPOPByPipeline(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "LPOP %s", key.data());
        redisReply *reply = NULL;
        redisGetReply(node.c,(void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                value = reply->str;
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::SetLPUSHByPipeline(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "LPUSH %s %s", key.data(), value.data());
        redisReply *reply = NULL;
        redisGetReply(node.c, (void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::GetLRangeByPipeline(std::string const&key, int dbName, int start, int end, std::vector<std::string>& result)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "LRANGE %s %d %d", key.data(), start, end);
        redisReply *reply = NULL;
        redisGetReply(node.c, (void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->type == REDIS_REPLY_ARRAY) {
                    for (int j = 0; j < reply->elements; j++) {
                        //printf("%u) %s\n", j, reply->element[j]->str);
                        result.push_back(reply->element[j]->str);
                    }
                }
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::SetStringByPipeline(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "SET %s %s", key.data(), value.data());
        redisReply *reply = NULL;
        redisGetReply(node.c, (void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::GetStringByPipeline(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "GET %s", key.data());
        redisReply *reply = NULL;
        redisGetReply(node.c, (void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->len > 0)
                {
                    value = reply->str;
                }
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::SetIntByPipeline(std::string const&key, int &number, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "SET %s %s", key.data(), number);
        redisReply *reply = NULL;
        redisGetReply(node.c, (void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::GetIntByPipeline(std::string const&key, int &number, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisAppendCommand(node.c, "SELECT %d", dbName);
        redisAppendCommand(node.c, "GET %s", key.data());
        redisReply *reply = NULL;
        redisGetReply(node.c, (void**)&reply);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            redisGetReply(node.c, (void**)&reply);
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->len > 0)
                {
                    number = std::atoi(reply->str);
                }
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
}
bool MyRedisPool::SetLPUSH(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
        
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "LPUSH %s %s", key.data(),value.data());
            ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::GetLPOP(std::string const&key, std::string&value,int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
            value = reply->str;
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "LPOP %s", key.data());
            ret = GetRedisReply(reply);
            if (ret)
            {
                value = reply->str;
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::GetLRange(std::string const&key, int dbName, int start, int end, std::vector<std::string>& result)
{
    bool isSuccess = false;
    bool ret = false;
    result.clear();
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "LRANGE %s %d %d", key.data(),start,end);
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->type == REDIS_REPLY_ARRAY) {
                    for (int j = 0; j < reply->elements; j++) {
                        //printf("%u) %s\n", j, reply->element[j]->str);
                        result.push_back(reply->element[j]->str);
                    }
                }
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::SetString(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "SET %s %s", key.data(), value.data());
            ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::GetString(std::string const&key, std::string&value, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "GET %s", key.data());
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->len > 0)
                {
                  value = reply->str;
                }
            
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::SetInt(std::string const&key, int &number, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "SET %s %d", key.data(), number);
            ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::GetInt(std::string const&key, int &number, int dbName)
{
    bool isSuccess = false;
    bool ret = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "SELECT %d", dbName);
        ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
            reply = (redisReply *)redisCommand(node.c, "GET %s", key.data());
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->len > 0) 
                {
                   number = std::atoi(reply->str);
                }
                freeReplyObject(reply);
            }
        }
        BackConnect(node);
    }
    return ret;
}
bool MyRedisPool::PUBLISH(std::string const& theme,std::string const& content)
{
    bool isSuccess = false;
    RedisNode &node = GetConnect(isSuccess);
    if (isSuccess)
    {
        redisReply *reply = (redisReply *)redisCommand(node.c, "PUBLISH %s %s", theme.data(), content.data());
        bool ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
        }
        BackConnect(node);
        return ret;
    }
    return isSuccess;
}
bool MyRedisPool::SUBSCRIBE(std::string const&theme)
{
    redisContext *c = NULL;
    bool ret = CreateOneConnect(c);
    if (ret)
    {
        redisReply *reply = (redisReply *)redisCommand(c, "SUBSCRIBE %s", theme.data());
        freeReplyObject(reply);
        while (redisGetReply(c,(void**)&reply) == REDIS_OK) {
            // consume message
            ret = GetRedisReply(reply);
            if (ret)
            {
                if (reply->elements>0)
                {
                    for (size_t i = 0; i < reply->elements; i++)
                    {
                        std::cout << reply->element[reply->elements-1]->str << std::endl;
                        break;
                    }
                 
                }
            
                freeReplyObject(reply);
            }
            
        }
        if (c)
        {
            redisFree(c);
        }
    }
    return ret;
}
bool MyRedisPool::BackConnect(RedisNode& node)
{
    std::lock_guard<std::mutex> lck(m_Lock);
    for (size_t i = 0; i < m_RedisVec.size(); i++)
    {
        RedisNode& n = m_RedisVec[i];
        if (node.id == n.id)
        {
            n.isUsed = false;
            break;
        }
    }
    return true;
}
bool MyRedisPool::DisConnect()
{
    std::lock_guard<std::mutex> lck(m_Lock);
    for (size_t i = 0; i < m_RedisVec.size(); i++)
    {
        RedisNode& node = m_RedisVec[i];
        if (node.c)
        {
            redisFree(node.c);
        }
    }
    return true;
}
bool MyRedisPool::AddConnect()
{
    size_t size = m_MaxConnects - m_CurConnects;
    struct timeval timeout = { 1, 500000 }; // 1.5 seconds
    for (size_t i = 0; i < size; i++)
    {
        RedisNode node;
#ifdef _WIN32
            node.c = redisConnectWithTimeout(m_Host.data(), m_Port, timeout);
#else
            node.c = redisConnectUnixWithTimeout(hostname, timeout);
#endif
            if (node.c == NULL || node.c->err) {
                if (node.c) {
                    std::lock_guard<std::mutex> lck(m_PrintLock);
                    printf("Connection error: %s\n", node.c->errstr);
                    redisFree(node.c);
                }
                else {
                    std::lock_guard<std::mutex> lck(m_PrintLock);
                    printf("Connection error: can't allocate redis context\n");
                }
                continue;
            }
            if (m_PassWord.length()>0)
            {
                redisReply *reply = (redisReply *)redisCommand(node.c, "AUTH %s ", m_PassWord.data());
                bool ret = GetRedisReply(reply);
                if (ret)
                {
                    freeReplyObject(reply);
                }
                else
                {
                    redisFree(node.c);
                    continue;
                }
            }
            
            if (m_QueueId.size()>0)
            {
                node.id = m_QueueId.front();
                m_QueueId.pop();
            }
            else
            {
                node.id = i;
            }
        
            node.isUsed = false;
            m_RedisVec.push_back(node);
            m_CurConnects++;
    }
    return true;
}
bool MyRedisPool::CreateOneConnect(redisContext *&c)
{
    struct timeval timeout = { 1, 500000 }; // 1.5 seconds
#ifdef _WIN32
    c = redisConnectWithTimeout(m_Host.data(), m_Port, timeout);
#else
    c = redisConnectUnixWithTimeout(hostname, timeout);
#endif
    if (c == NULL || c->err) {
        if (c) {
            printf("Connection error: %s\n", c->errstr);
            redisFree(c);
        }
        else {
            printf("Connection error: can't allocate redis context\n");
        }
        return false;
    }
    if (m_PassWord.length()>0)
    {
        redisReply *reply = (redisReply *)redisCommand(c, "AUTH %s ", m_PassWord.data());
        bool ret = GetRedisReply(reply);
        if (ret)
        {
            freeReplyObject(reply);
        }
        else
        {
            redisFree(c);
            return false;
        }
    }
    return true;
}
RedisNode& MyRedisPool::GetConnect(bool& isSuccess)
{
    std::lock_guard<std::mutex> lck(m_Lock);
    bool used = false;
    isSuccess = false;
    for (size_t i = 0; i<m_RedisVec.size(); i++)
    {
        RedisNode& node = m_RedisVec[i];
        if (!node.isUsed)
        {
            redisReply *reply = (redisReply *)redisCommand(node.c, "PING");
            bool ret = GetRedisReply(reply);
            if (ret)
            {
                std::lock_guard<std::mutex> lck(m_PrintLock);
                printf("PING: %s\n", reply->str);
                freeReplyObject(reply);
                node.isUsed = true;
                isSuccess = true;
                return node;
            }
            else
            {
                redisFree(node.c);
                m_RedisVec.erase(std::begin(m_RedisVec) + i);
            }
            
            
        }
    }
    if (m_RedisVec.size()<=0)
    {
        AddConnect();
        for (size_t i = 0; i < m_RedisVec.size(); i++)
        {
            RedisNode& node = m_RedisVec[i];
            if (!node.isUsed)
            {
                redisReply *reply = (redisReply *)redisCommand(node.c, "PING");
                bool ret = GetRedisReply(reply);
                if (ret)
                {
                    std::lock_guard<std::mutex> lck(m_PrintLock);
                    printf("PING: %s\n", reply->str);
                    freeReplyObject(reply);
                    node.isUsed = true;
                    isSuccess = true;
                    return node;
                }
                else
                {
                    redisFree(node.c);
                    m_RedisVec.erase(std::begin(m_RedisVec) + i);
                }


            }
        }
    }
    return (RedisNode&)isSuccess;
}
bool MyRedisPool::InitConnect(std::string const& host, std::string const& password,int port,int count)
{
    m_RedisVec.clear();
    m_Host = host;
    m_PassWord = password;
    m_Port = port;

    m_MaxConnects = count;
    struct timeval timeout = { 1, 500000 }; // 1.5 seconds
    for (size_t i = 0; i < count; i++)
    {
        RedisNode node;
#ifdef _WIN32
        node.c = redisConnectWithTimeout(m_Host.data(), m_Port, timeout);
#else
        node.c = redisConnectUnixWithTimeout(hostname, timeout);
#endif
        if (node.c == NULL || node.c->err) {
            if (node.c) {
                printf("Connection error: %s\n", node.c->errstr);
                redisFree(node.c);
            }
            else {
                printf("Connection error: can't allocate redis context\n");
            }
            return false;
        }
        if (m_PassWord.length()>0)
        {
            redisReply *reply = (redisReply *)redisCommand(node.c, "AUTH %s ", m_PassWord.data());
            bool ret = GetRedisReply(reply);
            if (ret)
            {
                freeReplyObject(reply);
            }
            else
            {
                redisFree(node.c);
                continue;
            }
        }
        node.id = i;
        node.isUsed = false;
        m_RedisVec.push_back(node);
        m_CurConnects++;
        m_QueueId.push(i);
    }
}
MyRedisPool& MyRedisPool::GetInstance()
{
    static MyRedisPool _instance;
    return _instance;
}
#endif // _MY_REDIS_POOL_HPP_
 

hiredispool:为hiredis提供连接池和自动重新连接。 它也极简且易于定制
05-06
出租出租 该库提供hireddis的连接池和自动重新连接。 它也是简约的，易于定制。 该代码已在多线程应用程序中经过全面测试，并在生产环境中使用了很长时间。 它被证明是线程安全的，并且没有内存泄漏。 特征 用纯C实现的连接池 自动重新连接并在首次出现故障时立即重试 全面的日志记录以进行诊断 除hiredis外，没有第三方依赖性 具有自动内存管理功能的线程安全C ++包装器 [高级]可以配置多个服务器端点，并具有自动负载平衡和故障转移功能，以支持诸如高可用性redis-cluster和redis-proxy中间件之类的方案。 [实验]类似于Jedis的C ++包装器 [实验性]动态重新配置 局限性 要支持自动重新连接和重试，必须使用hiredis同步API的包装器 如何使用 要构建它，请克隆仓库并make 。 请查看test_*.cpp以获取示例。 编译 git clone < hired
vs2003-hiredis-vc++客户端连接池，线程安全
02-21
vs2003-hiredis-vc++客户端连接池，线程安全
Redisclient连接方式Hiredis简单封装使用,连接池、屏蔽连接细节
weixin_34112030的博客
06-05 542
工作须要对Hiredis进行了简单封装，实现功能： 1、API进行统一，对外仅仅提供一个接口。 2、屏蔽上层应用对连接的细节处理； 3、底层採用队列的方式保持连接池，保存连接会话。 4、重连时採用时间戳进行控制，每隔一定时间(3s)重连一次。防止频繁重试造成的不必要浪费。 先看一下Hiredis的经常使用数据结构与API： //hiredis/hiredis.h /* Co...
redis 连接池 hiredis
weixin_34198453的博客
06-24 284
对Hiredis进行了简单封装 1、API进行统一，对外只提供一个接口； 2、屏蔽上层应用对连接的细节处理； 3、底层采用队列的方式保持连接池，保存连接会话； 4、重连时采用时间戳进行控制，每隔一定时间(3s)重连一次，防止频繁重试造成的不必要浪费。 先看一下Hiredis的常用数据结构与API： //hiredis/hiredis.h/* Context for a connecti...
hiredis php,redis 连接池 hiredis
weixin_28717431的博客
04-10 231
对Hiredis进行了简单封装1、API进行统一，对外只提供一个接口；2、屏蔽上层应用对连接的细节处理；3、底层采用队列的方式保持连接池，保存连接会话；4、重连时采用时间戳进行控制，每隔一定时间(3s)重连一次，防止频繁重试造成的不必要浪费。先看一下Hiredis的常用数据结构与API：//hiredis/hiredis.h/* Context for a connection to Redis ...
利用hiredis库连接redis源码
11-05
在本文中，我们将深入探讨如何使用`hiredis`库连接到`Redis`数据库，并以C++编程语言实现这一过程。`hiredis`是一个高效、简洁的C语言`Redis`客户端库，它使得与`Redis`服务器进行交互变得更加简单。 首先，我们...
兼容Redis 3.0的hiredis-master库文件
3. 连接池机制：为了提高性能和资源利用效率，hiredis 库可能实现了连接池机制，使得客户端可以复用连接，减少频繁创建和销毁连接的开销。 4. 错误处理：在与 Redis 服务器交互过程中，可能会遇到网络问题、命令...
C++ Redis 客户端简单使用
最新发布
06-17
`cpp-redis`库提供了一些配置选项，如设置超时时间，以及连接池管理等。 总结起来，C++与Redis的集成使得开发者能够方便地利用Redis的强大功能。通过选择合适的客户端库，如cpp-redis，可以轻松地实现数据的存取、...
Ubuntu环境下Redis源码安装与C驱动hiredis使用教程
在实际应用中，确保对Redis的连接管理得当，例如使用连接池来复用连接，避免频繁创建和销毁连接带来的开销。此外，合理设置Redis的配置参数，如超时时间、最大连接数等，以优化服务器性能。 总结，本文介绍了在...
hiredis-0.14.0：Redis客户端库的最新稳定版发布
总结来说，hiredis-0.14.0是一个专为C语言开发者设计的Redis客户端库，它通过高效的数据通信协议、同步和异步接口、连接池支持、易于集成、支持多种Redis协议、灵活的错误处理机制以及丰富的社区和文档资源，极大地...
redis源码以及哨片分片连接池实现
06-15
包含redis源码，哨兵多节点分片连接池扩展实现代码，ShardedJedisPool分片连接池测试类实现，JedisSentinelPool哨兵连接池测试类实现，JedisPool连接池测试实现类，
redispool:Redis的连接池
04-29
RedisPool Redis的连接池 依存关系 RedisPool只需要hiredis 安装 在Debian系统上安装hiredis： sudo apt-get install libhiredis-dev 或手动： git clone https://github.com/redis/hiredis.git cd hiredis & make & make install 或使用RedisPool中的makefile： make hiredis 安装RedisPool： git clone https://github.com/msempere/redispool.git cd redispool & make & make install 执照 根据MIT许可分发。 有关更多信息，请参见LICENSE 。
redis使用c++ API 的hiredis连接详解
10-18
此代码实现了redis使用hiredis c接口开发，具体实现了string和list类型的存取，具体信息请看 https://blog.youkuaiyun.com/bwangk/article/details/83060374
redis工具类以及redis 连接池配置
07-01
创建jedis池配置实例，redis各种crud方法，包括使用主从同步，读写分离。工具类中包括存放hash表键值对，键值对以map的方式储存，删除键值对，永久存放键值对，设置过期时间，需要的直接去gitHab上看https://github.com/1610220353/advancedGiants/tree/master/src/main
Redis客户端连接方式Hiredis简单封装使用,连接池、屏蔽连接细节
xcw_1987的博客
05-18 2910
转：https://blog.youkuaiyun.com/gdutliuyun827/article/details/44339007对Hiredis进行了简单封装，实现功能：1、API进行统一，对外只提供一个接口；2、屏蔽上层应用对连接的细节处理；3、底层采用队列的方式保持连接池，保存连接会话；4、重连时采用时间戳进行控制，每隔一定时间(3s)重连一次，防止频繁重试造成的不必要浪费。先看一下Hiredis...
C++操作redis（实现连接池、分布式锁）
jiaoooooo的博客
03-05 1761
封装hiredis的一些基本操作，redishelper类提供包含连接，放回，存取键，push，pop，执行redis语句和执行lua脚本的函数，连接池是类模板，传入相应helper类即可实现多种连接池，后续实现mysql连接池。
连接池
weixin_44231698的博客
12-21 82
Java的连接池理解
Redis连接池
weixin_57023347的博客
05-29 826
连接池中的每一个连接有一个唯一标识，通过标识来获取对一个连接，标识可以是对应表冈功能(比如：如果是游戏中的排行榜，可以是不同的排行榜，也可以是不同玩家，每个玩家对应一个redis)。主要实现的功能为：读取配置，将配置中对应建立redis连接并加入到连接池中，然后从连接池中取出连接使用。有些类是利用RAII思想，构造时获得对象，初始化锁，加锁等，析构时释放对象，释放锁资源，释放锁等。连接池主要实现了将连接加入到连接池中，和从连接池中拿出连接。对应的连接池和读取配置只需要一个对象，可以实现为单例。
Redis连接池C/C++设计
locahuang的博客
12-04 2389
一、概述 Redis的C/C++编程，可以借助Hiredis。我们可以借助Hiredis提供的接口 ，实现对redis的读写操作。 Hiredis是一个Redis的C客户端库函数，基本实现了Redis的协议的最小集。 二、hiredis的使用 1、hiredis安装 安装步骤： 1）解压：tar -zxvf hiredis-0.14.0.tar.gz 2）编译：make 3）安装：make install 2、同步API接口的说明 项目中我一般使用的hireds接口都是同步的API，所谓同步意思就是使用
Spring mvc与redis连接池整合实例详解
在整合的过程中，我们经常会使用到Redis的连接池技术，这是因为Redis是一个基于客户端-服务器模型的数据库，操作数据库通常需要建立连接，而频繁地建立和关闭连接将导致性能开销。因此，连接池技术被广泛用于在应用...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值