在鸿蒙（HarmonyOS）开发中，多任务处理的核心在于平衡“系统资源管控”与“业务连续性”。一方面，系统会在应用退至后台时挂起主线程以保障续航；另一方面，复杂业务（如音视频、跨进程渲染）又需要突破单进程的资源隔离。以下是关于后台运行与进程间通信（IPC）的完整技术架构与实战代码。
一、 后台任务管理：分级调度与生命周期控制
鸿蒙提供了分级的后台任务解决方案，开发者需根据任务的紧迫性、持续时间及用户感知程度，选择合适的机制。
1. 长时任务（Continuous Task）
适用场景：用户感知明显的持续性任务（如音频播放、导航、大文件下载）。
核心机制：通过申请豁免机制保持 CPU 唤醒和网络连接。必须在 module.json5 中声明 backgroundModes 和 ohos.permission.KEEP_BACKGROUND_RUNNING 权限，且运行时必须绑定一个持续的通知（Notification）以保障用户知情权。
核心代码示例：
import { backgroundTaskManager } from '@kit.BackgroundTasksKit';
import { common } from '@kit.AbilityKit';
// 申请长时任务（以数据传输为例）
let longTimeTaskId: number = -1;
let wantAgentObj: WantAgent; // 需提前通过 wantAgent 模块创建
async function startContinuousTask(context: common.UIAbilityContext) {
try {
let wantAgentInfo: wantAgent.WantAgentInfo = {
wants: [{ bundleName: 'com.example.app', abilityName: 'EntryAbility' }],
actionType: wantAgent.OperationType.START_ABILITY,
requestCode: 0,
actionFlags: [wantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG]
};
wantAgentObj = await wantAgent.getWantAgent(wantAgentInfo);
// 申请长时任务
longTimeTaskId = backgroundTaskManager.startBackgroundRunning(
context,
"dataTransferTask",
wantAgentObj
);
console.info('长时任务启动成功，ID:', longTimeTaskId);
} catch (err) {
console.error('启动长时任务失败:', err);
}
}
2. 临时任务（Transient Task / Suspend Delay）
适用场景：应用退至后台时，需要短暂延迟挂起以完成收尾工作（如保存进度、等待几秒的下载完成）。
核心机制：通过 requestSuspendDelay 获取一个临时执行窗口，超时后系统会强制挂起应用。
核心代码示例：
import { backgroundTaskManager } from '@kit.BackgroundTasksKit';
let suspendDelayId: number = -1;
function requestSuspendGracefully() {
suspendDelayId = backgroundTaskManager.requestSuspendDelay('Saving user data…', () => {
// 超时回调：系统即将挂起应用，需立即执行紧急保存或取消任务
console.warn('临时任务超时，强制保存数据');
saveUserDataSync();
});
console.info('临时任务已申请，ID:', suspendDelayId);
}
// 任务完成后主动取消
function cancelSuspend() {
if (suspendDelayId !== -1) {
backgroundTaskManager.cancelSuspendDelay(suspendDelayId);
suspendDelayId = -1;
}
}
二、 进程间通信（IPC/RPC）：跨进程数据与服务调用
鸿蒙的 IPC Kit 采用客户端-服务端（Client-Server）模型。IPC 依赖 Binder 驱动用于设备内跨进程通信，RPC 依赖软总线驱动用于跨设备通信。
1. 基础架构：Stub 与 Proxy 模型
通信双方需继承统一的接口类。服务端（Stub）注册系统能力（SA）到系统能力管理者（SAMgr），客户端（Client）通过 SAMgr 获取代理对象（Proxy）进行方法调用。
核心代码示例（Native C++ 侧接口定义）：
// 1. 定义 IPC 接口
class ITestAbility : public IRemoteBroker {
public:
DECLARE_INTERFACE_DESCRIPTOR(u"com.example.ITestAbility");
virtual int SetValue(int value) = 0;
};
// 2. 服务端（Stub）实现
class TestAbilityStub : public ITestAbility, public IRemoteStub {
public:
int SetValue(int value) override {
this->currentValue = value;
return 0;
}
// 处理来自 Proxy 的请求
int OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option) override {
if (code == SET_VALUE) {
int val = data.ReadInt32();
SetValue(val);
}
return 0;
}
};
2. ArkTS 侧：服务连接与死亡监听
在 ArkTS 中，通常通过 connectServiceExtensionAbility 建立连接，并强烈建议注册死亡监听（DeathRecipient），以防止服务端进程崩溃导致客户端空指针异常。
核心代码示例：
import { rpc } from '@kit.IPCKit';
import { common, Want } from '@kit.AbilityKit';
let proxy: rpc.IRemoteObject | undefined;
let connectId: number | undefined;
// 死亡通知监听
class MyDeathRecipient implements rpc.DeathRecipient {
onRemoteDied() {
console.error('服务端进程已死亡，准备重连或降级处理');
proxy = undefined;
}
}
const deathRecipient = new MyDeathRecipient();
// 连接服务
function connectService(context: common.UIAbilityContext) {
let want: Want = {
bundleName: 'com.example.ipc_stub',
abilityName: 'ServiceAbility',
};
let connectOptions: common.ConnectOptions = {
onConnect: (elementName, remoteProxy) => {
proxy = remoteProxy;
// 注册死亡监听
proxy.registerDeathRecipient(deathRecipient, 0);
console.info('IPC 服务连接成功');
},
onDisconnect: () => {
proxy?.unregisterDeathRecipient(deathRecipient, 0);
proxy = undefined;
},
onFailed: (code) => console.error('连接失败，错误码:', code)
};
connectId = context.connectServiceExtensionAbility(want, connectOptions);
}
三、 进阶优化：大文件传输与多线程调度
IPC 通信存在单次传输数据量最大约 1MB 的限制。在复杂多任务场景下，需结合共享内存与线程池进行架构优化。
核心代码示例（TaskPool 并发调度）：
import { taskPool } from '@kit.ArkTS';
// 标记为并发安全函数
@Concurrent
async function heavyDataProcess(data: ArrayBuffer): Promise<string> {
// 耗时操作，不阻塞 UI 主线程
await new Promise(resolve => setTimeout(resolve, 2000));
return '处理完成';
}
// 在 UI 线程中调度
async function startBatchTasks() {
try {
const result = await taskPool.execute(heavyDataProcess, new ArrayBuffer(1024));
console.info('后台任务结果:', result);
} catch (err) {
console.error('任务执行失败:', err);
}
}
四、 架构隔离：创建 Native 原生子进程
当应用需要执行极其消耗 CPU 资源且可能导致崩溃的任务（如复杂的音视频编解码、AI 模型推理）时，为避免主进程被系统 OOM（Out of Memory）回收，可以通过 AbilityKit 创建独立的 Native 子进程。
核心代码示例：
// 1. 主进程：启动 Native 子进程并建立 IPC 通道
import { ability } from '@kit.AbilityKit';
let childProcessProxy: rpc.IRemoteObject | undefined;
const callback: ability.NativeChildProcessCallback = {
onChildProcessStarted: (errCode: number, remoteProxy: rpc.IRemoteObject) => {
if (errCode === 0 && remoteProxy) {
childProcessProxy = remoteProxy;
console.info('Native 子进程启动成功，IPC 通道已建立');
}
}
};
ability.createNativeChildProcess('libchildprocess.so', callback);
// 2. 子进程侧 (C++)：实现子进程入口与 IPC Stub
#include <IPCKit/ipc_kit.h>
extern "C" {
// 子进程连接回调，返回 Stub 对象供主进程调用
OHIPCRemoteStub* NativeChildProcess_OnConnect() {
return CreateMyCustomStub();
}
// 子进程主业务逻辑
void NativeChildProcess_MainProc() {
// 在此执行耗时且隔离的计算任务
while (true) {
// 业务循环…
}
}
}
五、 Native 层通信：C++ 侧的 Stub 与 Proxy 实现
对于底层 C++ 模块，鸿蒙提供了 IPCKit 的 C API。通过在 Native 层直接定义 Stub（服务端）和 Proxy（客户端），可以实现零开销的跨进程二进制数据交互。
核心代码示例：
// Native 服务端 (Stub) 实现
class IpcCapiStubTest {
public:
IpcCapiStubTest() {
// 创建 Stub 对象并绑定请求处理函数
stub_ = OH_IPCRemoteStub_Create("testIpc", &IpcCapiStubTest::OnRemoteRequest, nullptr, this);
}
static int OnRemoteRequest(uint32_t code, const OHIPCParcel *data, OHIPCParcel *reply, void *userData) {
if (code == 1001) {
// 解析数据包并处理业务
int32_t value = OH_IPCParcel_ReadInt32(data);
// 返回结果
OH_IPCParcel_WriteInt32(reply, value * 2);
}
return OH_IPC_SUCCESS;
}
private:
OHIPCRemoteStub *stub_;
};
六、 突破瓶颈：匿名共享内存（Shared Memory）传输
鸿蒙 IPC 基于 Binder 机制，单次跨进程通信的数据量上限约为 1MB。在传输高清图像帧、大型音频流或大文件时，必须使用匿名共享内存，通过 IPC 仅传递内存句柄（File Descriptor）。
核心代码示例：
import { ipc } from '@kit.IPCKit';
// 1. 分配共享内存（例如分配 10MB）
const sharedMem = new ipc.SharedMemory(10 * 1024 * 1024);
// 2. 写入数据
const buffer = new ArrayBuffer(1024);
// … 填充数据到 buffer
sharedMem.write(buffer, 0);
// 3. 通过 IPC 发送内存句柄给另一个进程
let data = rpc.MessageParcel.obtain();
data.writeFileDescriptor(sharedMem.fd);
proxy.sendRequest(REQUEST_CODE, data, reply, option);
// 4. 接收端通过 fd 映射到内存直接读取，避免数据拷贝
七、 系统级能力：注册与获取系统服务（SA）
如果应用提供的服务需要被整个设备上的其他应用调用（类似 Android 的 System Service），则需要将 Stub 注册到系统能力管理者（SAMgr），其他进程通过 SA 的唯一标识获取 Proxy。
核心代码示例：
// 服务端：将 Stub 注册到 SAMgr
int32_t RegisterSystemAbility() {
sptr<IRemoteObject> stub = new MySystemAbilityStub();
// 申请系统 SA 唯一标识并注册
return SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager()->AddSystemAbility(SA_ID, stub);
}
// 客户端：通过 SA ID 获取 Proxy 并通信
sptr<IRemoteObject> proxy = SystemAbilityManagerClient::GetInstance()
.GetSystemAbilityManager()->GetSystemAbility(SA_ID);
// 随后将 proxy 强转为对应的 Proxy 类进行业务调用
