文档开发者中心
我的
|

ArkTS

原生模块 NAPI,长连接子线程持续回调 ArkTS,偶现 callback 回调卡死,是否和主线程队列拥塞有关?

原生模块 NAPI,长连接子线程持续回调 ArkTS,偶现 callback 回调卡死,是否和主线程队列拥塞有关?
点赞
收藏
4
回复
8
分享
举报
浏览41 发布于5天前广西
全部评论
最多点赞
最新发布
最早发布

有可能。 如果线程安全函数(TSFN)是在 UI 主线程创建的,回调就要等该线程处理。主线程忙于布局、同步 I/O 或前一批回调时,后续消息会排队。如果主线程又在 join() 等待 Native 子线程,而子线程正在等队列腾出空间或等 ArkTS 回调完成,就可能死锁。华为 Node-API 常见问题

用同一个消息序号记录 投递前后、回调进入和退出 的时间,以及 napi_status,通常能定位卡在哪一段:

  • 投递调用迟迟不返回:检查是否用了 napi_tsfn_blocking,以及两边是否在互相等锁或等结果。
  • 投递很快返回 napi_ok,回调很晚才进入:查主线程是否繁忙、回调是否积压。若回调已经进入但迟迟不退出,则重点查回调本身的耗时和锁等待。
  • 返回 napi_queue_full 或 napi_closing:前者是队列已满,后者应检查断连、重连时 TSFN 的释放与重建。华为 Node-API 状态码说明

长连接建议用 非阻塞投递+有界队列,让 ArkTS 回调尽快返回。高频状态可以合并为最新值,必须逐条处理的消息则按顺序做限流或背压。

5楼回复于5天前 来自广东

有可能是 JS 队列积压,但先排除两种更直接的问题:子线程直接调用 napi_call_function,以及 JS 线程与生产线程互相等待形成死锁。子线程应通过线程安全函数投递,在对应 JS 环境线程执行回调。

有限队列配非阻塞投递时,要检查返回值,不能把“投递成功”当成“回调已执行”:

收起
自动换行
深色代码主题
复制
// payload 为本次分配的数据;成功后由消费回调负责释放
napi_status status = napi_call_threadsafe_function(
    tsfn, payload, napi_tsfn_nonblocking);
if (status != napi_ok) {
    delete payload; // 本次未入队,生产方归还所有权
    if (status == napi_queue_full) {
        // 按业务合并、限速或放入有界补偿队列
    } else if (status == napi_closing) {
        // 停止向正在关闭的 JS 环境投递
    }
}
收起
自动换行
深色代码主题
复制
子线程生产 → 有界队列 → JS 回调轻量消费 → 批量刷新UI
             满时背压       不做重解析/同步等待

记录入队时间、回调开始时间、单次处理耗时和返回码。入队到消费延迟持续增长才支持“队列拥塞”的判断。TSFN 创建时 max_queue_size=0 代表不限队列,不能靠无限排队解决吞吐不匹配;需要保证不丢的消息应持久化/确认,而非直接丢弃。

销毁时停止生产,按线程持有关系 release,并覆盖环境销毁时的 payload 清理路径,避免回调与页面释放竞争。

参考:Node-API 状态与错误码。

展开全部
8楼回复于5天前 来自四川

队列拥塞是一个方向,但也要排除阻塞入队、错误线程调用 NAPI、环境销毁和 JS 回调自身长时间不返回。解码/长连线程通过 TSFN 回传时,先观察非阻塞入队返回值:

收起
自动换行
深色代码主题
复制
napi_status status = napi_call_threadsafe_function(
    tsfn, packet, napi_tsfn_nonblocking);
if (status != napi_ok) {
    // 未入队的数据仍由生产者释放,并按业务做背压/合并
}

不要在 UI 线程用阻塞入队等自己消费队列,也不要持锁等待 JS 回调。限制待处理包数,允许时批量回传;关闭时先停生产者再按计数释放 TSFN,收尾回调负责释放已入队数据。仅把线程池调大通常解决不了主线程消费不足。

7楼回复于5天前 来自四川
期待AI分享
6楼回复于5天前 来自湖北

主线程 EventLoop 拥塞只会让回调延迟,不会让它永久卡死。偶现"卡死"大概率是下面两个原因之一,而且都能从 napi_call_threadsafe_function 的返回值直接看出来。

  1. tsfn 被提前释放了。线程安全函数在引用计数归零、或以 napi_tsfn_abort 模式调用 napi_release_threadsafe_function 之后就失效了,再 call 会返回 napi_closing,回调永远不会执行,表现出来就是"卡死"。长连接场景很典型:ArkTS 侧页面销毁时把 tsfn 释放了,子线程还在持续 call。官方 FAQ 列了意外释放的两种情况:引用计数变 0、abort 模式释放,见线程安全函数使用问题汇总。另外 tsfn 必须在 JS 线程创建,子线程创建会莫名崩溃,同一篇 FAQ 里有说明。

  2. blocking 模式撞上队列满。napi_tsfn_blocking 模式下队列满时调用线程会一直阻塞,直到队列腾出空间;napi_tsfn_nonblocking 则立即返回 napi_queue_full,这是Node-API 数据类型和接口里的明确定义。主线程持续忙时,blocking 调用就卡在子线程里出不来。如果你创建时 max_queue_size 传了 0(不限长),队列不会满,但任务会持续堆积、内存涨、回调越来越慢,观感也一样。

排查顺序就三步:每次 call 都检查返回的 napi_status;拿到 napi_closing 说明 tsfn 已释放,去查 release 时机和 acquire/release 配对;拿到 napi_queue_full 说明队列满了,降频丢帧或加大 max_queue_size。回调本身也别做重活,重活扔给 TaskPool,否则主线程被拖慢,回调排队变慢,看着也像卡了。有保序保优先级的需求,可以改用 napi_call_threadsafe_function_with_priority,见带优先级投递任务。

给个能直接跑的最小 demo(API 23 编译验证通过):子线程模拟长连接持续回调,nonblocking + 返回值检查 + 先停线程再释放。

C++ 侧 napi_init.cpp:

收起
自动换行
深色代码主题
复制
#include "napi/native_api.h"
#include "hilog/log.h"
#include <atomic>
#include <chrono>
#include <thread>

static napi_threadsafe_function g_tsfn = nullptr;
static std::atomic<bool> g_running(false);

// 主线程执行:转调 ArkTS 回调
static void CallJs(napi_env env, napi_value jsCb, void *context, void *data)
{
    if (env == nullptr || jsCb == nullptr) {
        return; // env 销毁后系统可能还会触发一次空 env 回调,必须判空
    }
    napi_handle_scope scope = nullptr;
    napi_open_handle_scope(env, &scope);
    napi_value undefined = nullptr;
    napi_get_undefined(env, &undefined);
    napi_value argv = nullptr;
    int32_t *msg = static_cast<int32_t *>(data);
    napi_create_int32(env, *msg, &argv);
    napi_value result = nullptr;
    napi_call_function(env, undefined, jsCb, 1, &argv, &result);
    delete msg;
    napi_close_handle_scope(env, scope);
}

// 长连接读线程:持续回调,nonblocking + 检查返回值
static void LongConnThread()
{
    int32_t seq = 0;
    while (g_running.load()) {
        int32_t *msg = new int32_t(seq++);
        napi_status status = napi_call_threadsafe_function(g_tsfn, msg, napi_tsfn_nonblocking);
        if (status == napi_queue_full) {
            delete msg; // 队列满:丢帧或降频,不要死等
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        } else if (status != napi_ok) {
            delete msg; // napi_closing 等:tsfn 已释放,退出
            break;
        } else {
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
    OH_LOG_INFO(LOG_APP, "long conn thread exit");
}

static napi_value StartCallback(napi_env env, napi_callback_info info)
{
    if (g_tsfn != nullptr) {
        return nullptr;
    }
    size_t argc = 1;
    napi_value jsCb = nullptr;
    napi_get_cb_info(env, info, &argc, &jsCb, nullptr, nullptr);
    napi_value resName = nullptr;
    napi_create_string_utf8(env, "LongConnTsfn", NAPI_AUTO_LENGTH, &resName);
    // 必须在 JS 线程创建;max_queue_size=64,队列满时 nonblocking 返回 napi_queue_full
    napi_status status = napi_create_threadsafe_function(env, jsCb, nullptr, resName, 64, 1,
        nullptr, nullptr, nullptr, CallJs, &g_tsfn);
    if (status != napi_ok) {
        g_tsfn = nullptr;
        return nullptr;
    }
    g_running.store(true);
    std::thread(LongConnThread).detach();
    return nullptr;
}

static napi_value StopCallback(napi_env env, napi_callback_info info)
{
    g_running.store(false); // 先停线程,再释放 tsfn,避免 call 撞上 release
    if (g_tsfn != nullptr) {
        napi_release_threadsafe_function(g_tsfn, napi_tsfn_abort);
        g_tsfn = nullptr;
    }
    return nullptr;
}

EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports)
{
    napi_property_descriptor desc[] = {
        {"startCallback", nullptr, StartCallback, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"stopCallback", nullptr, StopCallback, nullptr, nullptr, nullptr, napi_default, nullptr},
    };
    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
    return exports;
}
EXTERN_C_END

static napi_module demoModule = {
    .nm_version = 1,
    .nm_flags = 0,
    .nm_filename = nullptr,
    .nm_register_func = Init,
    .nm_modname = "entry",
    .nm_priv = ((void *)0),
    .reserved = {0},
};

extern "C" __attribute__((constructor)) void RegisterModule()
{
    napi_module_register(&demoModule);
}

index.d.ts:

收起
自动换行
深色代码主题
复制
export const startCallback: (callback: (msg: number) => void) => void;
export const stopCallback: () => void;

ArkTS 侧:

收起
自动换行
深色代码主题
复制
import testNapi from 'libentry.so';

@Entry
@Component
struct Index {
  @State message: string = 'tsfn demo';

  build() {
    Column({ space: 20 }) {
      Text(this.message)
        .fontSize(20)
        .onClick(() => {
          this.message = 'started';
          testNapi.startCallback((msg: number) => {
            // 回调里别做重活,否则主线程 EventLoop 被拖慢,回调排队变慢
            this.message = `recv: ${msg}`;
          });
        })
      Text('stop')
        .fontSize(20)
        .onClick(() => {
          this.message = 'stopped';
          testNapi.stopCallback();
        })
    }
    .justifyContent(FlexAlign.Center)
    .height('100%')
    .width('100%')
  }
}

工程配置两处别漏:entry 的 build-profile.json5 里加 externalNativeOptions 指向 CMakeLists.txt,oh-package.json5 里加 libentry.so 的 file 依赖。

如果你把每次 call 的 status 打出来发现既不是 closing 也不是 queue_full,回调还是不来,那再往主线程拥塞方向查(比如回调里是否同步等了子线程的锁,形成互等)。我在模拟器上没复现过你的长连接场景,上面的写法基于官方文档和 FAQ,你先拿 demo 对一下你的 release 时机。

相关文档:Node-API 线程安全开发 | tsfn 释放后 js_cb 仍执行的处理

展开全部
4楼回复于5天前 来自四川

是的,大概率就是主线程 EventLoop 队列拥塞导致的。下面把机制和解决办法说清楚。

为什么会卡死

ArkTS 主线程是单线程模型,所有 JS 回调都通过 EventLoop 串行执行。你用 napi_call_threadsafe_function 从 Native 子线程往主线程投递任务,本质是把一个回调塞进主线程的 EventLoop 队列里等待调度。如果主线程正忙着——渲染 UI、处理用户输入、跑其他异步回调——你的 callback 就得排队。

长连接场景下子线程持续高频回调,队列会快速积压。偶现卡死的典型表现:不是回调完全不来,而是回调延迟越来越大,极端情况下主线程被某个耗时任务阻塞超过 5 秒,直接触发 APP_INPUT_BLOCK 或 AppFreeze,看门狗把应用杀了。

官方文档明确说了:napi_env 和 ArkTS 线程强绑定,子线程不能直接调用需要 napi_env 的 NAPI 函数,线程安全函数的 call_js 回调是在主线程 EventLoop 中执行的。

参考:

解决思路

1. 用带优先级的投递接口

napi_call_threadsafe_function_with_priority 可以指定任务优先级和入队位置(队头/队尾),让关键回调优先执行:

收起
自动换行
深色代码主题
复制
// 高优先级 + 队头入队,确保关键回调尽快被调度
napi_call_threadsafe_function_with_priority(
    tsfn, data, napi_priority_high, false);

参考:使用Node-API接口从异步线程向ArkTS线程投递指定优先级和入队方式的任务

2. Native 侧节流,别无脑往主线程塞任务

长连接高频回调时,Native 侧做采样或聚合,比如 16ms 合并一次数据再投递,而不是每收到一个包就 napi_call_threadsafe_function 一次。

3. 回调里别做重活

ArkTS 侧 callback 里只做轻量操作(更新状态、派发事件),把计算、JSON 解析等耗时逻辑放到 TaskPool 或 Worker 里。

4. 数据传递用深拷贝

官方 FAQ 提到 tsfn 回调里可能拿到脏数据,传给 ArkTS 侧的数据要做深拷贝,避免 Native 侧已释放导致野指针。

5. TSFN 生命周期管理好

  • 创建 tsfn 必须在主线程,子线程创建会概率闪退
  • 用 napi_acquire_threadsafe_function / napi_release_threadsafe_function 管理引用计数
  • env 退出时用 napi_tsfn_abort 模式释放,注册 napi_add_env_cleanup_hook 防止泄漏

参考:napi_threadsafe_function内存泄漏处理

完整示例

Native 侧:创建 tsfn + 子线程节流回调

收起
自动换行
深色代码主题
复制
// napi_init.cpp
#include "napi/native_api.h"
#include <hilog/log.h>
#include <thread>
#include <chrono>
#include <mutex>

#undef LOG_DOMAIN
#undef LOG_TAG
#define LOG_DOMAIN 0x2342
#define LOG_TAG "TSFN_DEMO"

struct LongConnCtx {
    napi_threadsafe_function tsfn;
    std::mutex mtx;
    bool running = false;
};

static void CallJs(napi_env env, napi_value jsCb, void *context, void *data) {
    if (env == nullptr || jsCb == nullptr) {
        return;
    }
    napi_handle_scope scope = nullptr;
    napi_open_handle_scope(env, &scope);

    int32_t *val = reinterpret_cast<int32_t *>(data);
    napi_value argv = nullptr;
    napi_create_int32(env, *val, &argv);
    napi_value undefined = nullptr;
    napi_get_undefined(env, &undefined);
    napi_value result = nullptr;
    napi_call_function(env, undefined, jsCb, 1, &argv, &result);

    delete val;
    napi_close_handle_scope(env, scope);
}

static void TsfnFinalize(napi_env env, void *data, void *hint) {
    LongConnCtx *ctx = reinterpret_cast<LongConnCtx *>(data);
    if (ctx != nullptr) {
        ctx->running = false;
        delete ctx;
    }
}

static void LongConnThread(LongConnCtx *ctx) {
    ctx->running = true;
    int32_t count = 0;
    while (ctx->running) {
        int32_t *data = new int32_t(count++);
        napi_status status = napi_call_threadsafe_function_with_priority(
            ctx->tsfn, data, napi_priority_high, false);
        if (status != napi_ok) {
            delete data;
            OH_LOG_WARN(LOG_APP, "tsfn call failed: %{public}d", status);
        }
        // 50ms 间隔节流,避免队列拥塞
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
}

static napi_value StartLongConn(napi_env env, napi_callback_info info) {
    size_t argc = 1;
    napi_value jsCb = nullptr;
    napi_get_cb_info(env, info, &argc, &jsCb, nullptr, nullptr);

    LongConnCtx *ctx = new LongConnCtx();
    napi_value workName = nullptr;
    napi_create_string_utf8(env, "LongConnTSFN", NAPI_AUTO_LENGTH, &workName);

    napi_create_threadsafe_function(env, jsCb, nullptr, workName,
        0, 1, nullptr, TsfnFinalize, ctx, CallJs, &ctx->tsfn);
    napi_acquire_threadsafe_function(ctx->tsfn);

    std::thread t(LongConnThread, ctx);
    t.detach();

    napi_value result = nullptr;
    napi_get_undefined(env, &result);
    return result;
}

EXTERN_C_START
napi_value Init(napi_env env, napi_value exports) {
    napi_property_descriptor desc[] = {
        { "startLongConn", nullptr, StartLongConn, nullptr, nullptr, nullptr, napi_default, nullptr }
    };
    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
    return exports;
}
EXTERN_C_END

static napi_module demoModule = {
    .nm_version = 1,
    .nm_flags = 0,
    .nm_filename = nullptr,
    .nm_register_func = Init,
    .nm_modname = "entry",
    .nm_priv = ((void *)0),
    .reserved = { 0 }
};
extern "C" __attribute__((constructor)) void RegisterEntryModule(void) {
    napi_module_register(&demoModule);
}

ArkTS 侧:回调保持轻量

收起
自动换行
深色代码主题
复制
import entry from 'libentry.so'

@Entry
@Component
struct Index {
  @State msg: string = 'waiting...'
  private count: number = 0

  build() {
    Column() {
      Text(this.msg)
        .fontSize(24)
        .padding(20)
      Button('Start')
        .onClick(() => {
          entry.startLongConn((val: number) => {
            this.count = val
            this.msg = `recv: ${val}`
          })
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

总结一下:卡死的原因就是主线程 EventLoop 队列拥塞,解法是节流 + 优先级投递 + 回调内轻量操作。如果你现在回调频率特别高(比如每帧都调),先把频率降到业务能接受的最低值试试。

展开全部
3楼回复于5天前 来自四川

你的判断方向是对的,主线程队列拥塞是导致 TSFN 回调“卡死”的最常见原因之一,但需要先排除一个更底层的前提:你的回调是否真的通过 napi_threadsafe_function 投递到了主线程。

先确认:回调走的是不是 TSFN

如果 Native 子线程是直接调用 napi_call_function 来触发 ArkTS 回调,那问题不是“队列拥塞”,而是跨线程访问 Runtime,行为未定义,偶现卡死或崩溃都是正常表现。必须使用 napi_create_threadsafe_function 创建 TSFN,子线程只调用 napi_call_threadsafe_function 投递数据,真正的 ArkTS 回调在主线程的 call_js_cb 中执行。

如果确认走的是 TSFN,主线程拥塞如何导致“卡死”

TSFN 的机制是:子线程投递的任务进入一个内部队列,最终在 env 所在的 ArkTS 线程(通常是主线程)的事件循环中调度执行。如果主线程事件循环被长任务阻塞,TSFN 回调就不会被调度,表现就是“卡死”。

官方文档明确列出了 napi_call_threadsafe_function 回调不执行的原因之一:env 所在的 ArkTS 线程被阻塞。主线程上任何耗时操作(大数组遍历、同步 I/O、复杂计算)都会让排在后面的 TSFN 回调延迟执行,如果阻塞时间足够长,看起来就是“卡死”。

排查与验证步骤

第一步:检查投递返回值。 在子线程中,每次调用 napi_call_threadsafe_function 后检查返回值。如果不是 napi_ok,根据状态码排查原因。高频场景建议使用 napi_tsfn_nonblocking,队列满时返回 napi_queue_full,此时应丢弃或合并数据,绝不能阻塞子线程等待。

第二步:确认主线程是否有长任务。 抓取 trace 或 hilog,观察 TSFN 回调预期执行的时间点,主线程是否正在执行其他耗时任务。如果主线程空闲但回调仍未执行,问题可能在 TSFN 本身(如已释放、引用计数错误);如果主线程忙碌,就是拥塞。

第三步:检查队列是否积压。 TSFN 内部队列有上限(创建时指定 max_queue_size)。如果子线程产生回调的速度远高于主线程消费速度,队列会满,后续投递会被拒绝或阻塞。高频长连接场景常见的问题是没有合并回调,每次数据到达就投递一次,主线程处理不过来就会积压。

修复方向

合并高频回调。 长连接场景下,不需要每个数据包都回调一次 ArkTS。在 Native 侧维护一个缓冲区,只保留最新数据,TSFN 回调触发时批量或取最新值处理。官方在触摸事件场景中明确建议“MOVE 事件合并,只展示最新坐标,避免每个触摸点都排队”。

限制队列并做丢弃策略。 创建 TSFN 时设置合理的 max_queue_size(例如 8~16),使用 napi_tsfn_nonblocking 投递。队列满时主动丢弃或合并,而不是让内存和延迟无限增长。

确保主线程回调里不做耗时操作。 call_js_cb 中只做轻量数据传递和状态更新,耗时逻辑应继续留在 Native 子线程或迁到 TaskPool,避免阻塞主线程事件循环导致后续 TSFN 回调排队。

检查 TSFN 生命周期。 如果回调“卡死”发生在页面切换或组件销毁后,可能是 TSFN 被释放而子线程仍在投递,或释放顺序不当。页面退出时应先停止子线程投递,再以 napi_tsfn_abort 模式释放 TSFN。

总结

“主线程队列拥塞”是 TSFN 回调卡死的高概率原因,但前提是你的回调确实通过 TSFN 投递到了主线程。如果确认走了 TSFN,下一步就是检查投递是否用了非阻塞模式、队列是否积压、主线程是否有长任务阻塞事件循环。修复的核心是合并高频回调、限制队列、保持主线程回调轻量,而不是试图“解决”队列拥塞本身。

展开全部
2楼回复于5天前 来自浙江
AI 生成内容,仅供参考

是的,callback 偶现卡死与主线程事件循环拥塞存在直接关联,但这通常只是表象之一。线程安全函数(napi_threadsafe_function)的回调最终是在创建它的 ArkTS 线程(一般是主线程)的事件循环中被调度执行的,一旦该线程被长任务阻塞或事件队列积压,回调就会表现为"卡死"或"丢失"。除此之外,还有两类高频踩坑的原因需要一并排查。

原理说明

线程安全函数的底层基于 libuv 的 uv_async_t 机制实现:Native 子线程调用 napi_call_threadsafe_function 后,数据只是被放入一个内部任务队列,并通过异步信号通知 ArkTS 线程的事件循环去消费。因此回调能否及时执行,取决于三个环节:

  1. 入队是否成功。napi_call_threadsafe_function 有两种模式:
    • napi_tsfn_nonblocking:队列满时立即返回 napi_queue_full,数据被丢弃,表现为"回调丢失";
    • napi_tsfn_blocking:队列满时子线程被挂起等待空间,表现为"子线程卡死",长连接场景下若主线程消费不及时,极易造成级联阻塞。
  2. ArkTS 线程是否在正常运转事件循环。若主线程存在长耗时同步任务(大循环、同步 IO、复杂布局计算等),或事件队列被其他任务积压,线程安全函数的回调就得不到执行机会。
  3. 线程安全函数是否被意外失效。若工程中存在某个 uv_async_t 句柄被重复初始化(再次执行了 uv_async_init),在其影响范围内创建的所有线程安全函数都会失效,回调将永远不再触发,这是官方 FAQ 中明确列出的隐蔽原因。

排查建议

按以下顺序定位:

  • 检查 napi_call_threadsafe_function 的每次返回值。若偶发 napi_queue_full,说明队列容量(max_queue_size)不足或主线程消费过慢,需做回调合并或降频。
  • 检查主线程是否存在长任务。可以在卡死时段用 HiTrace/HiLog 观察主线程是否长时间无事件循环心跳,重点排查回调链路中是否有同步耗时操作、await 前的重计算等。
  • 检查工程内是否有对同一 uv_async_t 句柄重复 init 的代码,尤其是自绘、XComponent 场景中反复创建/销毁的地方。
  • 确认线程安全函数的生命周期管理正确:创建后需要 napi_acquire_threadsafe_function 持有,不再使用时必须调用 napi_release_threadsafe_function 释放,重复创建不释放会导致句柄与队列异常。

示例代码

Native 侧正确用法(子线程持续回调场景,检查返回值并正确管理生命周期):

收起
自动换行
深色代码主题
复制
#include "napi/native_api.h"

static napi_threadsafe_function g_tsFn = nullptr;

// 该函数运行在 ArkTS 主线程,负责真正调用 ArkTS 回调
static void CallJs(napi_env env, napi_value jsCallback, void *context, void *data)
{
    // context 为创建时传入的上下文,data 为子线程投递的数据
    auto *ctx = static_cast<napi_ref *>(context);
    napi_value callback = nullptr;
    napi_get_reference_value(env, *ctx, &callback);
    napi_value undefined = nullptr;
    napi_get_undefined(env, &undefined);
    // 调用 ArkTS 传入的回调函数
    napi_call_function(env, undefined, callback, 0, nullptr, nullptr);
}

// ArkTS 侧调用该接口注册回调
static napi_value RegisterCallback(napi_env env, napi_callback_info info)
{
    size_t argc = 1;
    napi_value jsCallback = nullptr;
    napi_get_cb_info(env, info, &argc, &jsCallback, nullptr, nullptr);

    // 保存 ArkTS 回调的引用,防止被 GC 回收
    static napi_ref callbackRef = nullptr;
    napi_create_reference(env, jsCallback, 1, &callbackRef);

    napi_value name = nullptr;
    napi_create_string_utf8(env, "LongConnTsfn", NAPI_AUTO_LENGTH, &name);
    // max_queue_size 传 0 表示队列大小不限,长连接高频场景建议显式设置上限
    napi_create_threadsafe_function(env, jsCallback, nullptr, name,
        0, 1, nullptr, &callbackRef, nullptr, CallJs, &g_tsFn);
    return nullptr;
}

// 长连接子线程中的投递逻辑
void OnSocketMessage(const char *msg)
{
    if (g_tsFn == nullptr) {
        return;
    }
    // 关键:检查返回值,nonblocking 模式下队列满会返回 napi_queue_full
    napi_status status = napi_call_threadsafe_function(g_tsFn,
        const_cast<char *>(msg), napi_tsfn_nonblocking);
    if (status == napi_queue_full) {
        // 队列满,说明主线程消费过慢,此处应做丢弃/合并/计数告警
        // 切勿静默忽略,否则表现为回调偶现丢失
    }
}

// 模块卸载或连接关闭时释放
static void ReleaseTsfn()
{
    if (g_tsFn != nullptr) {
        napi_release_threadsafe_function(g_tsFn, napi_tsfn_release);
        g_tsFn = nullptr;
    }
}

ArkTS 侧注册回调:

收起
自动换行
深色代码主题
复制
import nativeModule from 'libentry.so';

// 注册长连接消息回调,回调将在主线程事件循环中执行
nativeModule.registerCallback(() => {
  // 此处可安全更新 UI 状态
});

补充说明

针对长连接高频回调的工程化建议:

  • 回调合并与降频:Native 侧对高频消息做聚合(例如按 16ms 一帧或按数量阈值批量投递),避免逐条投递打满队列,这是解决偶现卡死最有效的手段。
  • 回调内容下沉到 Taskpool:若回调处理逻辑本身耗时,建议在 ArkTS 侧用 Taskpool 承接处理,主线程回调只做轻量分发,避免回调本身又成为阻塞主线程的长任务:
收起
自动换行
深色代码主题
复制
import nativeModule from 'libentry.so';
import { taskpool } from '@kit.ArkTS';

@Concurrent
function handleMessage(msg: string): void {
  // 耗时的消息解析与处理放到 Taskpool 线程执行
  console.info('handle message in taskpool:', msg);
}

nativeModule.registerCallback((msg: string) => {
  // 主线程回调保持轻量,只做任务分发
  taskpool.execute(handleMessage, msg);
});
  • 优先级投递:若使用 API 12 及以上版本,可使用 napi_call_threadsafe_function_with_priority 指定任务优先级和入队方式,让关键消息优先被主线程消费。
  • 避免 napi_tsfn_blocking 模式用于长连接子线程:队列满时它会挂起子线程,一旦主线程阻塞,会形成双向等待,表现为整个链路彻底卡死,风险高于 nonblocking 模式。

总结来看,偶现卡死大概率是"主线程事件循环被长任务阻塞或队列积压"与"nonblocking 模式下队列满静默丢任务"的组合表现,建议先加返回值日志确认 napi_queue_full 的出现频率,再对回调做合并降频,并排查主线程长任务。

展开全部
1楼回复于5天前 来自广东
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要提问题

了解社区公约,与您携手共创和谐专业的开发者社区。