在鸿蒙（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 的限制。在复杂多任务场景下，需结合共享内存与线程池进行架构优化。

1. 匿名共享内存（Shared Memory）：在相机滤镜、视频编辑等高频大数据场景中，严禁通过 IPC 直接传输图像帧。应使用 ipc.SharedMemory 创建共享内存区，通过 IPC 仅传递内存句柄和读写状态。
2. 防死锁与超时控制：RPC 调用应设置合理的超时时间（如 3秒），超时后触发降级策略（如回退到本地处理），避免主线程阻塞。
3. TaskPool 线程池：对于非跨进程但耗时的本地任务（如 JSON 解析、图像压缩），使用 ThreadPoolExecutor 或 TaskPool 进行管理，避免频繁创建销毁线程带来的开销。

核心代码示例（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 类进行业务调用

1. 子进程数量限制：从 API 15 开始，单个主进程最多支持启动 50 个原生子进程（早期版本仅支持 1 个）。在架构设计时需做好进程池管理，避免频繁创建销毁。
2. 通信模式选择：对于无需等待返回值的广播类消息（如状态同步），务必使用 OneWay 模式（设置 MessageOption 为 TF_SYNC 为 false），这能极大提升 IPC 吞吐量。
3. 跨设备 RPC 限制：鸿蒙的 RPC 依赖分布式软总线。需注意，不支持把跨设备的 Proxy 对象传递回该 Stub 所在的设备，这会导致序列化异常。
4. 线程安全与生命周期：IPC 的回调（如 onConnect、OnRemoteRequest）通常在 Binder 线程池中执行。在回调中更新 UI 或访问共享资源时，必须使用 TaskPool 或主线程调度器，且使用完毕后务必调用 OH_IPCRemoteProxy_Destroy 释放资源，防止内存泄漏。