跳到主要内容

concurrent_running

简介​

是一个用于并发执行函数的工具库，特别适用于处理 IO 密集型任务，如网络请求、文件读写等操作, 并需要等待所有任务完成。通过并发执行可以显著提高程序的执行效率

concurrent_running 并发执行函数库

概述​

concurrent_running 是一个用于并发执行函数的工具库，特别适用于处理 IO 密集型任务，如网络请求、文件读写等操作, 并需要等待所有任务完成。通过并发执行可以显著提高程序的执行效率。

功能特性​

  • ✅ 支持并发执行多个函数调用
  • ✅ 异常安全：如果某次调用失败，会等待其他调用完成后抛出异常
  • ✅ 高性能：使用 copool 的 co_pool_execute_in 实现
  • ✅ 支持两种调用模式：统一函数多参数 / 多函数多参数

API 文档​

concurrent_running(function f, array params)​

并发执行同一个函数，使用不同的参数。

参数：

  • f (function): 要执行的函数
  • params (array): 参数数组，每个元素是一个数组，包含每次调用函数的参数

返回值：

  • array: 结果数组，按照参数数组的顺序返回每次函数调用的结果

示例：

// 定义一个示例函数
int add(int a, int b) {
    return a + b;
}

// 准备参数数组
array params = [
    [1, 2],    // 第一次调用: add(1, 2)
    [3, 4],    // 第二次调用: add(3, 4)
    [5, 6]     // 第三次调用: add(5, 6)
];

// 并发执行
array results = concurrent_running.exec((: add :), params);
// results = [3, 7, 11]

concurrent_running_ex(array funcAndParams)​

并发执行不同的函数，支持为每个函数指定不同的参数。

参数：

  • funcAndParams (array): 函数和参数的组合数组，每个元素包含：
    • [0] (function): 要执行的函数
    • [1] (array): 该函数的参数数组

返回值：

  • array: 结果数组，按照输入数组的顺序返回每次函数调用的结果

示例：

// 定义示例函数
int multiply(int a, int b) {
    return a * b;
}

int subtract(int a, int b) {
    return a - b;
}

// 准备函数和参数的组合
array funcAndParams = [
    [(: add :), [10, 20]],        // 调用 add(10, 20)
    [(: multiply :), [3, 7]],     // 调用 multiply(3, 7)
    [(: subtract :), [100, 30]]   // 调用 subtract(100, 30)
];

// 并发执行
array results = concurrent_running.exec_ex(funcAndParams);
// results = [30, 21, 70]

使用场景示例​

1. 并发网络请求​

// 定义网络请求函数
function fetchData(string url) {
    // 模拟网络请求
    return http_get(url);
}

// 准备多个URL
array urls = [
    ["https://api1.example.com/data"],
    ["https://api2.example.com/data"],
    ["https://api3.example.com/data"]
];

// 并发请求所有URL
array responses = concurrent_running.exec(fetchData, urls);

2. 并发文件处理​

// 定义文件处理函数
function processFile(string filename) {
    string content = fs.read_all(filename);
    // 进行一些处理...
    return processed_content;
}

// 准备文件列表
array files = [
    ["file1.txt"],
    ["file2.txt"],
    ["file3.txt"]
];

// 并发处理所有文件
array results = concurrent_running.exec(processFile, files);

3. 混合任务并发执行​

// 定义不同类型的任务函数
mixed dbQuery(string sql) {
    return database_execute(sql);
}

mixed cacheGet(string key) {
    return cache_retrieve(key);
}

mixed apiCall(string endpoint) {
    return http_request(endpoint);
}

// 组合不同的任务
array tasks = [
    [dbQuery, ["SELECT * FROM users"]],
    [cacheGet, ["user_session_123"]],
    [apiCall, ["https://external-api.com/status"]]
];

// 并发执行所有任务
array results = concurrent_running.exec_ex(tasks);

异常处理​

当任何一个并发执行的函数发生异常时，库会等待所有其他函数执行完成，然后抛出异常。这确保了：

  1. 资源清理：所有启动的并发任务都能正确完成或清理
  2. 一致性：不会因为单个任务失败而导致其他任务被强制中断
  3. 调试友好：可以收集到所有任务的执行状态
try {
    array results = concurrent_running.exec(someFunction, params);
    // 处理成功结果
} catch (e) {
    // 处理异常情况
    log("并发执行过程中发生错误: " + e);
}

性能说明​

  • 适用场景：IO 密集型任务（网络请求、文件读写、数据库操作等）
  • 不适用场景：CPU 密集型计算任务
  • 内存使用：
    • 参数：会发生复制，适中的内存开销
    • 结果：不发生复制，内存效率高
  • 并发机制：基于 copool 的协程池实现

注意事项​

  1. 函数要求：传入的函数必须是可调用的函数对象
  2. 参数格式：参数数组的每个元素必须是数组形式，即使只有一个参数也要写成 [param]
  3. 结果顺序：返回的结果数组顺序与输入参数数组顺序一致
  4. 异常安全：确保在异常情况下程序能够正确处理和清理资源
  5. 性能考虑：主要适用于 IO 密集型任务，对于 CPU 密集型任务效果有限

导入方式​

import pkg.concurrent_running;

确保在使用前正确导入该包。

组件接口​

concurrent_running.gs​

函数原型函数作用
array exec_ex(array funcAndParams)并发运行函数，返回结果数组
array exec(function f, array params)并发运行函数，返回结果数组