深入解析 Hiredis：从阻塞与非阻塞 I/O 到高并发优化

Hiredis 是一个简单的 C 客户端库，用于与 Redis 数据库通信。它以高效、轻量级和易于集成而著称，通常用于需要与 Redis 进行低级别、高性能交互的场景。Hiredis 主要包括以下几个特点：

1. 高效性：Hiredis 使用阻塞 I/O 模型，这意味着它在发送命令时会等待服务器的响应，适合在性能要求很高的环境中使用。
2. 易用性：Hiredis 提供了简单易用的 API，开发者可以轻松地构建与 Redis 的通信逻辑。
3. 低内存占用：由于其轻量级的特性，Hiredis 在内存使用上非常节省，适合在资源有限的环境中使用。
4. 多种数据类型支持：Hiredis 可以处理 Redis 的多种数据类型，如字符串、列表、集合、哈希表等。
5. 扩展性：Hiredis 可以与事件库（如 libev 或 libuv）集成，支持异步 I/O 操作，适合高并发场景。

使用场景

• Web应用的缓存层：通过 Hiredis，可以高效地从 Redis 获取缓存数据。
• 实时数据处理：在需要实时处理大量数据的应用中，Hiredis 可以快速读取和写入 Redis。
• 分布式系统：在分布式系统中，Hiredis 可以用来管理和协调多个 Redis 实例。

简单示例

以下是使用 Hiredis 连接 Redis 并执行简单命令的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <hiredis/hiredis.h>

int main() {
    redisContext *c = redisConnect("127.0.0.1", 6379);
    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");
        }
        exit(1);
    }

    redisReply *reply;
    reply = redisCommand(c,"PING");
    printf("PING: %s\n", reply->str);
    freeReplyObject(reply);

    redisFree(c);
    return 0;
}

Hiredis 的阻塞 I/O 与非阻塞 I/O 有什么区别？

Hiredis 默认使用阻塞 I/O 模型，即在发出请求后，会等待 Redis 服务器返回结果，阻塞当前线程。这种模式简单直接，适合不需要并发处理的场景，但在高并发或实时性要求高的环境中，可能导致性能瓶颈。

非阻塞 I/O 则不等待服务器响应，而是立即返回，允许应用程序继续执行其他任务。要在 Hiredis 中使用非阻塞 I/O，可以通过设置 redisConnectNonBlock() 函数来实现。这种模式需要结合事件循环（如 libev、libuv）来处理 I/O 多路复用，从而在高并发场景下提供更好的性能。

如何在 Hiredis 中实现异步操作？

要在 Hiredis 中实现异步操作，需要使用 Hiredis 的异步 API，并结合事件库（如 libev 或 libuv）来管理 I/O 事件。Hiredis 提供了 redisAsyncContext，允许在异步模式下进行 Redis 通信。以下是实现异步操作的基本步骤：

1. 使用 redisAsyncConnect 连接 Redis 服务器。
2. 设置回调函数处理服务器响应。
3. 将 Hiredis 的事件处理集成到选择的事件库中，如 libev。
4. 启动事件循环。

#include <stdio.h>
#include <hiredis/async.h>
#include <hiredis/adapters/libev.h>
#include <ev.h>

void getCallback(redisAsyncContext *c, void *r, void *privdata) {
    redisReply *reply = (redisReply *)r;
    if (reply == NULL) return;
    printf("GET reply: %s\n", reply->str);
    redisAsyncDisconnect(c);
}

int main() {
    struct ev_loop *loop = EV_DEFAULT;
    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
    if (c->err) {
        printf("Error: %s\n", c->errstr);
        return 1;
    }

    redisLibevAttach(loop, c);
    redisAsyncCommand(c, getCallback, NULL, "GET key");
    ev_loop(loop, 0);
    return 0;
}

Hiredis 如何处理 Redis 的管道命令？

Redis 的管道（Pipeline）允许客户端一次性发送多个命令，而不必等待每个命令的响应，从而提高通信效率。Hiredis 通过阻塞 API 支持管道操作。您可以连续发送多个命令，并在最后一次 redisGetReply() 调用时，批量接收所有响应。

redisAppendCommand(context, "SET key1 value1");
redisAppendCommand(context, "SET key2 value2");
redisAppendCommand(context, "GET key1");

redisReply *reply;
redisGetReply(context, (void **)&reply); // 收到第一个命令的响应
freeReplyObject(reply);
redisGetReply(context, (void **)&reply); // 收到第二个命令的响应
freeReplyObject(reply);
redisGetReply(context, (void **)&reply); // 收到第三个命令的响应
printf("GET key1: %s\n", reply->str);
freeReplyObject(reply);

如何在 Hiredis 中进行错误处理？

Hiredis 提供了一些内置的错误处理机制。每个 redisContext 和 redisAsyncContext 结构体都包含 err 字段，指示是否发生错误，并且 errstr 字段包含错误消息。常见错误包括连接失败、命令格式错误等。

redisContext *c = redisConnect("127.0.0.1", 6379);
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");
    }
    exit(1);
}

在异步模式下，可以通过设置回调函数处理错误。例如，通过 redisAsyncSetDisconnectCallback() 设置断开连接时的回调函数。

Hiredis 的内存管理机制是怎样的？

Hiredis 通过动态内存分配来处理请求和响应的存储。开发者需要显式地释放由 Hiredis 分配的内存，以防止内存泄漏。常见的内存管理操作包括：

• 使用 redisCommand() 返回的 redisReply 结构体必须使用 freeReplyObject() 释放。
• 使用 redisFree() 释放连接上下文。
• 在异步模式下，通过回调函数确保正确释放资源。

redisReply *reply = redisCommand(context, "GET key");
printf("GET key: %s\n", reply->str);
freeReplyObject(reply);
redisFree(context);

如何将 Hiredis 集成到现有的 C 项目中？

要将 Hiredis 集成到现有的 C 项目中，可以按照以下步骤操作：

1. 下载和安装 Hiredis：可以通过包管理器（如 apt、brew）安装，或者从源码编译。
2. 链接 Hiredis 库：在编译项目时，将 Hiredis 库添加到链接选项中。例如，在 GCC 中使用 -lhiredis。
3. 包含头文件：在需要使用 Hiredis 的源文件中包含 #include <hiredis/hiredis.h>。

编译示例：

gcc -o myprogram myprogram.c -lhiredis

使用 Hiredis 进行大规模数据写入时需要注意什么？

在大规模数据写入场景下，使用 Hiredis 需要注意以下几点：

1. 管道化处理：使用 Redis 的管道功能减少网络往返延迟。
2. 批量写入：尽量将多个写入操作合并成一个命令批次，以减少命令处理时间。
3. 异步操作：在高并发环境中，考虑使用 Hiredis 的异步模式来提高吞吐量。
4. 连接池管理：在大量并发连接下，使用连接池来复用连接资源，减少连接建立和释放的开销。

Hiredis 与其他 Redis C 客户端库相比有哪些优势？

Hiredis 相较于其他 Redis C 客户端库，具有以下优势：

1. 轻量级：Hiredis 代码库小且易于集成，适合嵌入式系统或资源受限的环境。
2. 简单易用：API 简洁明了，易于上手。
3. 高效：Hiredis 经过优化，能够提供较高的性能，适合高吞吐量的应用。
4. 异步支持：Hiredis 提供了与主流事件库集成的异步 API，适合并发场景。

如何在 Hiredis 中处理复杂的 Redis 数据类型？

Hiredis 支持 Redis 的所有原生数据类型，包括字符串、列表、集合、哈希和有序集合。通过 redisReply 结构体，可以解析和处理这些数据类型。例如，处理哈希表时，可以遍历 redisReply 中的元素。

redisReply *reply = redisCommand(context, "HGETALL myhash");
if (reply->type == REDIS_REPLY_ARRAY) {
    for (size_t i = 0; i < reply->elements; i += 2) {
        printf("%s: %s\n", reply->element[i]->str, reply->element[i+1]->str);
    }
}
freeReplyObject(reply);

Hiredis 是否支持 Redis 的事务处理？

Hiredis 支持 Redis 的事务处理，使用 MULTI 和 EXEC 命令来实现事务的原子性。可以通过管道化命令，确保事务中所有命令在同一事务上下文中执行。

redisAppendCommand(context, "MULTI");
redisAppendCommand(context, "SET key1 value1");
redisAppendCommand(context, "SET key2 value2");
redisAppendCommand(context, "EXEC");

redisReply *reply;
for (int i = 0; i < 4; i++) {
    redisGetReply(context, (void **)&reply);
    freeReplyObject(reply);
}

如何使用 Hiredis 处理 Redis 的订阅/发布功能？

Hiredis 支持 Redis 的订阅/发布功能，可以使用阻塞或异步模式处理消息。在阻塞模式下，可以使用 redisGetReply() 来处理来自频道的消息。

redisCommand(context, "SUBSCRIBE mychannel");
while (redisGetReply(context, (void **)&reply) == REDIS_OK) {
    if (reply->type == REDIS_REPLY_ARRAY) {
        printf("Received message: %s\n", reply->element[2]->str);
    }
    freeReplyObject(reply);
}

在异步模式下，通过回调函数处理消息响应。

如何优化 Hiredis 在高并发场景下的性能？

在高并发场景下，可以通过以下方式优化 Hiredis 的性能：

1. 异步 I/O

：使用异步 API 提高并发处理能力。 2. 连接池：实现连接池管理，复用连接资源。 3. 批量操作：使用管道和批量命令减少网络往返。 4. 事件库优化：选择性能较优的事件库（如 libev、libuv）以提高事件处理效率。

Hiredis 的源码结构是怎样的？

Hiredis 的源码结构简单明了，主要包含以下几个部分：

1. hiredis.c：核心库代码，处理 Redis 协议解析、I/O 操作。
2. hiredis.h：主头文件，定义了所有公共 API 和数据结构。
3. async.c：异步 API 的实现，处理非阻塞 I/O 操作。
4. net.c：网络相关的辅助函数，如连接、读写操作。
5. adapters：事件库适配器代码，如 libev、libuv、libevent 的适配。

如何为 Hiredis 添加自定义命令？

要为 Hiredis 添加自定义命令，可以通过 redisCommand() 函数发送自定义的 Redis 命令，并解析返回的 redisReply 结果。例如，如果 Redis 支持 CUSTOM 命令，可以这样使用：

redisReply *reply = redisCommand(context, "CUSTOM arg1 arg2");
if (reply->type == REDIS_REPLY_STRING) {
    printf("Result: %s\n", reply->str);
}
freeReplyObject(reply);

在嵌入式系统中使用 Hiredis 时需要注意哪些问题？

在嵌入式系统中使用 Hiredis 时，需要注意以下几点：

1. 资源限制：嵌入式系统的内存和计算资源有限，确保 Hiredis 的内存使用和性能优化符合系统需求。
2. 编译环境：为特定嵌入式平台编译 Hiredis 时，确保交叉编译工具链配置正确。
3. 网络可靠性：嵌入式设备的网络连接可能不稳定，需要处理可能的连接超时和断开。
4. 轻量级实现：在可能的情况下，裁剪 Hiredis 的不必要功能，以减少代码尺寸和资源占用。

---

如何在高延迟网络环境下优化 Hiredis 的性能？

在高延迟网络环境中，优化 Hiredis 的性能可以从以下几个方面入手：

1. 使用管道（Pipeline）：将多个命令批量发送，减少网络往返次数，从而降低延迟对性能的影响。
2. 异步操作：通过异步 API 与事件驱动库结合，使得网络延迟期间程序可以执行其他任务，提升整体吞吐量。
3. 本地缓存：在本地缓存常用数据，减少对远程 Redis 的请求频率。
4. 连接优化：尽量减少不必要的连接建立与释放，保持长连接以减少网络开销。
5. 数据压缩：在网络传输前对数据进行压缩，减小数据包大小，从而减少传输时间。

在Hiredis中使用SSL/TLS加密通信的最佳实践是什么？

在 Hiredis 中使用 SSL/TLS 加密通信需要结合第三方 SSL 库，如 OpenSSL。以下是使用 SSL/TLS 的基本步骤：

1. 编译 Hiredis SSL：确保 Hiredis 使用了支持 SSL 的分支或扩展。
2. 初始化 SSL 库：在程序开始时初始化 OpenSSL 或其他 SSL 库。
3. 创建 SSL 上下文：使用 SSL 库创建和配置 SSL 上下文，设置证书和密钥等参数。
4. 连接到 Redis 服务器：使用 SSL 套接字连接 Redis 服务器。
5. 错误处理：确保在通信过程中处理可能的 SSL 错误，如证书验证失败、握手失败等。

代码示例：

SSL_CTX *ssl_ctx = SSL_CTX_new(TLS_method());
SSL_CTX_load_verify_locations(ssl_ctx, "ca.crt", NULL);

redisContext *c = redisConnect("127.0.0.1", 6379);
redisInitiateSSLWithContext(c, ssl_ctx);

Hiredis 的错误处理机制如何与 Redis Sentinel 集成？

Redis Sentinel 用于管理 Redis 服务器的高可用性，提供自动故障切换功能。Hiredis 可以通过检测错误码和错误消息来处理与 Sentinel 的交互。

1. 连接错误处理：在连接失败时，检查错误类型并根据需要查询 Sentinel 获取新的主节点地址。
2. 命令错误处理：在执行命令时，如果收到类似 MOVED 错误，表明主节点已切换，需要重新连接到新的主节点。
3. 自动故障切换：结合 Sentinel API（如 SENTINEL get-master-addr-by-name），在检测到错误时自动切换到新主节点。

示例：

redisReply *reply = redisCommand(c, "GET key");
if (reply == NULL && c->err == REDIS_ERR_IO) {
    // 查询 Sentinel，获取新的主节点地址
    redisFree(c);
    c = redisConnect("new_host", 6379);
}

如何通过 Hiredis 实现 Redis 的自动故障切换？

实现 Redis 的自动故障切换可以通过结合 Redis Sentinel 和 Hiredis 的错误处理机制来实现：

1. 监控 Sentinel：使用 Hiredis 定期查询 Sentinel，获取主节点地址。
2. 故障检测：在命令执行失败时，检查是否因为主节点故障导致，并重新查询 Sentinel。
3. 自动重连：在主节点故障后，使用 Sentinel 提供的新主节点地址重新连接 Redis。

示例：

// 在启动时或定期获取主节点地址
redisContext *c = redisConnect("master_host", 6379);

// 检测到主节点故障时，自动重连到新主节点
if (c->err) {
    redisFree(c);
    c = redisConnect("new_master_host", 6379);
}

Hiredis 支持 Redis 的哪些高级功能（如脚本执行、集群模式）？

Hiredis 支持 Redis 的大多数高级功能，包括：

1. 脚本执行：通过 EVAL 命令，Hiredis 支持 Lua 脚本在 Redis 上的执行。
2. Redis 集群模式：Hiredis 支持 Redis 集群，但需要手动处理 MOVED 和 ASK 重定向响应。
3. 管道与事务：Hiredis 支持通过管道和事务命令组合，实现原子性操作。
4. 发布/订阅：通过阻塞模式或异步 API，支持 Redis 的发布/订阅功能。
5. 哨兵模式：Hiredis 可以与 Sentinel 交互，用于管理 Redis 的高可用性。

Hiredis 如何在内存受限的环境中优化资源使用？

在内存受限的环境中使用 Hiredis 时，可以考虑以下优化策略：

1. 减小缓冲区大小：调整 Hiredis 的输入和输出缓冲区大小，以减少内存占用。
2. 避免大对象操作：尽量避免处理过大的 Redis 数据对象，减少内存消耗。
3. 及时释放资源：确保在使用完 redisReply 对象后立即调用 freeReplyObject() 释放内存。
4. 最小化命令集：只编译和链接 Hiredis 中所需的部分，去除不必要的功能代码。

如何扩展 Hiredis 以支持自定义的 Redis 协议扩展？

Hiredis 的核心设计简单明了，可以通过以下方式扩展以支持自定义的 Redis 协议：

1. 修改命令解析：在 hiredis.c 中扩展或修改现有的命令解析逻辑，以处理自定义协议命令。
2. 新增数据类型支持：如果 Redis 扩展协议中包含新的数据类型，需要在 redisReply 结构中添加相应的解析逻辑。
3. 增加新的 API：为自定义命令提供新的 API 接口，简化与自定义协议的交互。

在使用 Hiredis 进行批量操作时，如何处理可能的超时问题？

在进行批量操作时，可能由于网络延迟或服务器负载导致超时。可以通过以下方法处理：

1. 设置超时时间：在连接 Redis 时，指定合理的超时时间。使用 redisSetTimeout() 函数设置操作超时。
2. 管道化发送命令：使用管道化方式减少单个请求的等待时间，从而减少超时风险。
3. 批量处理失败重试：对因超时失败的批量操作，进行合理的重试机制。
4. 并发执行：将批量操作拆分为并发执行的小批量，减少每个批次的超时概率。

Hiredis 如何与 Redis 的过期机制结合使用，以实现自动缓存失效？

Hiredis 本身不直接处理过期机制，但可以通过以下方式与 Redis 的过期机制结合使用：

1. 设置过期时间：在使用 Hiredis 写入缓存时，通过 SETEX 或 PSETEX 命令为键设置过期时间。
2. 主动检查过期：在读取缓存数据时，可以先检查键是否存在，避免读取已过期的数据。
3. 订阅键事件：使用 Hiredis 订阅 Redis 的键事件频道，当某个键过期时接收通知，执行相应的清理或更新操作。

---

redisSetTimeout() 是 Hiredis 提供的一个函数，用于设置与 Redis 服务器通信时的超时时间。该函数可以设置连接、读、写操作的超时，从而防止在网络不稳定或 Redis 服务器响应缓慢的情况下导致程序无限制地等待。

redisSetTimeout() 函数使用方法

#include <hiredis/hiredis.h>

int redisSetTimeout(redisContext *c, const struct timeval tv);

• 参数：

• c：指向 redisContext 结构体的指针，表示与 Redis 服务器的连接。
• tv：struct timeval 结构体，表示超时时间。包含两个字段：

• tv_sec：秒数。
• tv_usec：微秒数（1000000 微秒 = 1 秒）。

• 返回值：该函数返回 REDIS_OK 表示设置成功，返回 REDIS_ERR 表示设置失败。

示例代码

#include <hiredis/hiredis.h>
#include <sys/time.h>

int main() {
    // 连接到 Redis 服务器
    redisContext *c = redisConnect("127.0.0.1", 6379);
    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 1;
    }

    // 设置超时时间为2.5秒
    struct timeval timeout = {2, 500000}; // 2秒500毫秒
    if (redisSetTimeout(c, timeout) != REDIS_OK) {
        printf("Set timeout failed\n");
        redisFree(c);
        return 1;
    }

    // 执行命令
    redisReply *reply = redisCommand(c, "PING");
    if (reply == NULL) {
        printf("Command error: %s\n", c->errstr);
        redisFree(c);
        return 1;
    }

    // 输出命令结果
    printf("PING: %s\n", reply->str);
    freeReplyObject(reply);

    // 释放连接
    redisFree(c);
    return 0;
}

详细解释

1. 设置超时：在上面的代码中，通过 redisSetTimeout() 函数设置了2.5秒的超时时间（2秒500毫秒）。如果在2.5秒内无法完成与 Redis 的通信（包括连接、读写操作），程序将超时并返回错误。
2. 连接管理：如果 redisSetTimeout() 设置失败，可能是由于连接已经关闭或其他网络问题，此时应适当处理错误并释放资源。
3. 常见用途：在高延迟或不稳定的网络环境中，通过设置超时时间，可以避免程序长期等待无响应的 Redis 服务器，提高系统的健壮性。

---

如何选择合适的超时时间以平衡性能和稳定性？

选择合适的超时时间需要根据以下因素进行平衡：

1. 网络延迟：测量并分析应用环境中的平均网络延迟，设置的超时时间应略高于正常情况下的网络延迟。
2. 服务器负载：在高负载情况下，Redis 响应时间可能增加，适当延长超时时间以减少误判。
3. 应用需求：根据应用对响应时间的要求，选择合理的超时时间。实时性要求高的应用可能需要较短的超时时间。
4. 错误恢复策略：考虑到在超时后是否有足够的时间执行重试操作，应为超时时间留出余地。

redisSetTimeout() 对高并发场景的影响是什么？

redisSetTimeout() 在高并发场景下的影响主要体现在以下几个方面：

1. 资源消耗：设置较长的超时时间可能导致资源被长时间占用，增加系统的负载压力。
2. 响应速度：在高并发下，较短的超时时间有助于快速释放资源，提升整体响应速度。
3. 失败率：如果超时时间过短，可能导致更多的请求因超时失败，影响请求的成功率。

在分布式系统中，超时设置是否需要根据不同的节点进行调整？

在分布式系统中，超时设置通常需要根据以下因素进行调整：

1. 节点地理位置：不同地理位置的节点网络延迟不同，需要设置不同的超时时间。
2. 节点负载：不同节点的负载情况不同，超时时间应根据节点的处理能力进行调整。
3. 网络带宽：根据不同节点的网络带宽，设置合适的超时时间以防止网络拥堵。

超时发生时，如何实现重试机制来保证操作的成功？

实现重试机制的方法包括：

1. 指数退避：每次重试时增加等待时间，避免短时间内连续重试对服务器造成压力。
2. 最大重试次数：设置一个最大重试次数，防止无限制的重试。
3. 检查错误类型：在重试之前，检查错误类型，仅在适合重试的情况下进行重试。

如果 Redis 服务器在设定的超时内没有响应，如何处理未完成的事务？

处理未完成事务的方法包括：

1. 回滚操作：检查事务状态，必要时执行回滚操作以恢复数据一致性。
2. 重试提交：在检测到超时后，重新提交事务，以确保事务能够成功完成。
3. 日志记录：记录未完成的事务，以便在事后分析和处理。

是否可以在不同操作（如连接、读、写）上设置不同的超时时间？

在 Hiredis 中，目前 redisSetTimeout() 函数设置的超时时间是全局的，适用于所有操作（连接、读、写）。如果需要为不同操作设置不同的超时时间，需要在每次操作前动态调整超时时间。

Hiredis 是否支持动态调整超时时间？如果是，如何实现？

Hiredis 支持动态调整超时时间。可以在不同操作前调用 redisSetTimeout() 函数设置不同的超时时间。例如：

struct timeval timeout1 = {1, 0}; // 1秒
redisSetTimeout(c, timeout1); // 设置连接超时
// 执行连接操作

struct timeval timeout2 = {2, 0}; // 2秒
redisSetTimeout(c, timeout2); // 设置读写超时
// 执行读写操作

超时后断开重连对 Redis 服务器的性能有什么影响？

超时后频繁断开重连可能会对 Redis 服务器的性能造成以下影响：

1. 连接开销增加：每次重连都会产生额外的连接和认证开销，影响 Redis 服务器的整体性能。
2. 资源占用：频繁的连接建立与释放可能导致服务器资源耗尽，特别是在高并发环境下。

如何监控和记录超时事件以分析网络或服务器问题？

监控和记录超时事件的方法包括：

1. 日志记录：在超时发生时记录详细日志，包括操作类型、时间、重试次数等信息。
2. 监控工具：使用网络和服务器监控工具（如 Prometheus、Grafana）来实时监控超时事件频率和分布。
3. 报警机制：设置报警机制，当超时事件超过一定阈值时，及时通知运维人员。

使用 redisSetTimeout() 时，如何确保数据一致性，特别是在高负载环境下？

确保数据一致性的方法包括：

1. 原子操作：尽量使用 Redis 提供的原子操作和事务（如 MULTI 和 EXEC）以减少数据不一致的风险。
2. 超时处理：在超时后，检查事务状态，确保事务的完整性和一致性。
3. 幂等性设计：设计操作时保证幂等性，即多次执行同一操作结果一致，避免因超时导致数据异常。

redisSetTimeout() 与其他 Redis 客户端库的超时处理方式有何异同？

不同的 Redis 客户端库在超时处理上可能有所不同：

1. Hiredis：通过 redisSetTimeout() 设置全局超时时间，适用于所有操作。
2. Jedis（Java）：提供不同级别的超时设置（如连接超时、读写超时），可以分别配置。
3. StackExchange.Redis（C#）：支持为每个操作单独设置超时时间，并提供更细粒度的超时控制。