如何在C++中实现分布式锁_并发控制解决方案

冰火之心

发布时间：2025-06-20 11:15:01

768人浏览过

来源于php中文网

原创

分布式锁的实现主要依赖外部系统，答案如下：1.基于redis的分布式锁：通过setnx命令结合唯一标识和过期时间保证原子性加锁；解锁时使用lua脚本验证身份并删除锁键。2.基于zookeeper的分布式锁：创建临时顺序节点，序号最小者获得锁，监听前序节点变化以实现释放锁的通知机制。3.基于etc++d的分布式锁：利用lease机制关联键与租约，put操作成功即加锁，删除键或租约过期即解锁。c++实现可选用hiredis、zookeeper c client或grpc接口。选择方案需权衡性能与可靠性，redis适合高性能场景，zookeeper和etcd适合高可靠需求。避免死锁的关键是设置过期时间和验证锁持有者，优化性能可通过减少网络通信、使用连接池和高效序列化协议实现。

如何在C++中实现分布式锁_并发控制解决方案

分布式锁，说白了，就是要在多个进程或者多个服务器之间，保证同一时间只有一个能访问某个共享资源。C++本身没有直接支持分布式锁的库，所以我们需要借助一些外部力量。

解决方案

基于Redis的分布式锁：

Redis的SETNX (SET if Not eXists) 命令是实现分布式锁的关键。它的原子性保证了只有一个客户端能成功设置锁。

立即学习“C++免费学习笔记（深入）”；

加锁: 尝试使用SETNX lock_key unique_id。如果返回1，说明加锁成功。unique_id 可以是客户端的唯一标识，用于后续的解锁。
设置过期时间: 为了防止死锁，必须设置锁的过期时间。可以使用EXPIRE lock_key timeout。这一步很重要，不然程序挂了，锁就永远释放不了了。最好是SETNX 和 EXPIRE 命令能原子执行， Redis 2.6.12 之后可以使用 SET lock_key unique_id NX EX timeout 来实现。
解锁: 解锁时，需要判断锁是否是自己加的，防止误删。可以用Lua脚本来实现原子性：

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

C++代码示例 (使用 hiredis)：

#include 
#include 
#include 
#include 

class RedisLock {
public:
    RedisLock(const std::string& key, const std::string& id, int timeout) : lock_key(key), unique_id(id), expire_time(timeout) {}

    bool lock() {
        redisReply *reply = (redisReply*) redisCommand(redis_context, "SET %s %s NX EX %d", lock_key.c_str(), unique_id.c_str(), expire_time);
        if (reply == nullptr) {
            std::cerr << "Error: " << redis_context->errstr << std::endl;
            freeReplyObject(reply);
            return false;
        }

        bool acquired = (reply->type == REDIS_REPLY_STATUS) && (strcmp(reply->str, "OK") == 0);
        freeReplyObject(reply);
        return acquired;
    }

    bool unlock() {
        std::string lua_script = R"(
            if redis.call("get",KEYS[1]) == ARGV[1] then
                return redis.call("del",KEYS[1])
            else
                return 0
            end
        )";

        redisReply *reply = (redisReply*)redisCommand(redis_context, "EVAL %s 1 %s %s", lua_script.c_str(), lock_key.c_str(), unique_id.c_str());

        if (reply == nullptr) {
            std::cerr << "Error: " << redis_context->errstr << std::endl;
            freeReplyObject(reply);
            return false;
        }

        bool released = (reply->type == REDIS_REPLY_INTEGER) && (reply->integer == 1);
        freeReplyObject(reply);
        return released;
    }

    bool connect(const char* hostname, int port) {
        redis_context = redisConnect(hostname, port);
        if (redis_context == nullptr || redis_context->err) {
            if (redis_context) {
                std::cerr << "Connection error: " << redis_context->errstr << std::endl;
                redisFree(redis_context);
            } else {
                std::cerr << "Connection error: can't allocate redis context" << std::endl;
            }
            return false;
        }
        return true;
    }

    void disconnect() {
        if (redis_context) {
            redisFree(redis_context);
            redis_context = nullptr;
        }
    }

private:
    std::string lock_key;
    std::string unique_id;
    int expire_time;
    redisContext *redis_context = nullptr;
};

int main() {
    RedisLock lock("my_resource", "client123", 10); // Lock key, unique ID, expire time in seconds
    if (!lock.connect("127.0.0.1", 6379)) {
        return 1;
    }

    if (lock.lock()) {
        std::cout << "Acquired lock!" << std::endl;
        // Do something with the resource
        // ...
        std::cout << "Releasing lock..." << std::endl;
        lock.unlock();
    } else {
        std::cout << "Failed to acquire lock." << std::endl;
    }

    lock.disconnect();
    return 0;
}