OK3568 Android11 实现 App 独占隔离 CPU 核心完整指
# OK3568 Android11 实现 App 独占隔离 CPU 核心完整指南
在嵌入式 Android 开发中，针对实时性要求高的场景（如工业控制、音频处理），常需将特定 App 绑定到独立 CPU 核心，避免进程调度干扰。本文基于 OK3568 开发板 Android11 系统，从内核配置、CPU 隔离、JNI 开发到动态库生成，完整讲解 App 独占 CPU 核心的实现流程。
## 一、前置知识：核心概念与目标
### 1. 关键技术点
* **CPU 隔离**：通过内核参数`isolcpus`将指定 CPU 核心从系统调度中剥离，仅允许手动绑定进程运行
* **无滴答模式**：`nohz_full`参数关闭隔离核心的周期性时钟中断，降低实时任务延迟
* **JNI 开发**：通过 C/C++ 调用 Linux 系统接口`sched_setaffinity`，实现进程与 CPU 核心的绑定
* **动态库生成**：使用 Android NDK 编译 JNI 代码，生成可被 App 加载的`libcpu-binder.so`
### 2. 最终目标
* 内核层面隔离 CPU 核心 3（0 基索引，即第 4 个物理核心）
* App 启动时自动绑定到隔离核心 3，实现独占运行
## 二、第一步：内核配置 —— 启用 CPU 隔离
需修改 OK3568 的设备树（DTS）文件，添加 CPU 隔离相关的启动参数，确保内核启动时生效。
### 1. 修改设备树文件
设备树路径：`kernel/arch/arm64/boot/dts/rockchip/OK3568-C-android.dts`
```
diff --git a/kernel/arch/arm64/boot/dts/rockchip/OK3568-C-android.dts b/kernel/arch/arm64/boot/dts/rockchip/OK3568-C-android.dts
index f878e354d7..4efd1df7cf 100644
\--- a/kernel/arch/arm64/boot/dts/rockchip/OK3568-C-android.dts
+++ b/kernel/arch/arm64/boot/dts/rockchip/OK3568-C-android.dts
@@ -9,7 +9,8 @@
 / {
  chosen: chosen {
\- bootargs = "earlycon=uart8250,mmio32,0xfe660000 console=ttyFIQ0";
\+ // 注释原启动参数，新增CPU隔离配置
\+ bootargs = "earlycon=uart8250,mmio32,0xfe660000 isolcpus=3 nohz\_full=3 console=ttyFIQ0";
  };
  aliases {
```
### 2. 参数说明
| 参数 | 作用 |
| ------------- | -------------------------------------- |
| `isolcpus=3` | 将 CPU 核心 3 从内核调度器隔离，禁止系统自动分配进程到该核心 |
| `nohz_full=3` | 对核心 3 启用 “完全无滴答” 模式，仅在必要时触发时钟中断，降低实时延迟 |
### 3. 验证内核配置
编译并烧录修改后的内核，设备重启后通过 ADB 验证配置是否生效：
```
\# 查看启动参数中是否包含隔离配置
adb shell cat /proc/cmdline | grep -E "isolcpus|nohz\_full"
\# 查看nohz\_full配置的核心列表
adb shell cat /sys/devices/system/cpu/nohz\_full
```
若输出包含`isolcpus=3`和`nohz_full=3`，说明内核隔离配置生效。
## 三、第二步：App 开发 —— 实现 CPU 核心绑定
Android 应用需通过 JNI 调用 Linux 系统接口，将自身进程绑定到隔离的 CPU 核心 3。需完成 Java 层声明、JNI 实现、动态库生成三部分工作。
### 1. Java 层：声明 Native 方法与加载动态库
创建`CpuBinder.java`类，声明 JNI 方法并加载动态库，确保包名与后续 JNI 函数命名匹配。
```
package com.example.myapp; // 包名需与JNI函数命名严格对应
import android.util.Log;
public class CpuBinder {
  // 声明Native方法：绑定当前进程到CPU核心3
  public native void bindToCpu3();
  // 静态代码块：加载动态库（库名"cpu-binder"对应生成的libcpu-binder.so）
  static {
  try {
  System.loadLibrary("cpu-binder");
  Log.d("CpuBinder", "动态库libcpu-binder.so加载成功");
  } catch (UnsatisfiedLinkError e) {
  Log.e("CpuBinder", "动态库加载失败：" + e.getMessage());
  }
  }
}
```
### 2. App 启动时调用绑定方法
在`Application`初始化阶段调用 JNI 方法，确保进程启动后立即完成 CPU 绑定，覆盖整个 App 的所有组件。
#### （1）自定义 Application 类
```
package com.example.myapp;
import android.app.Application;
import android.util.Log;
public class MyApplication extends Application {
  private static final String TAG = "CpuBinder";
  @Override
  public void onCreate() {
  super.onCreate();
  // 初始化CPU绑定
  bindToIsolatedCpu();
  }
  private void bindToIsolatedCpu() {
  CpuBinder cpuBinder = new CpuBinder();
  try {
  cpuBinder.bindToCpu3();
  Log.d(TAG, "App进程绑定CPU核心3请求已发送");
  } catch (Exception e) {
  Log.e(TAG, "CPU绑定失败：" + e.getMessage());
  }
  }
}
```
#### （2）配置 AndroidManifest.xml
指定自定义 Application 类，确保初始化代码生效：
```
\<application
  android:name=".MyApplication" // 关联自定义Application
  android:icon="@mipmap/ic\_launcher"
  android:label="@string/app\_name"
  android:sharedUserId="android.uid.system"> \<!-- 声明系统应用权限 -->
   
  \<!-- 声明系统级权限 -->
  \<uses-permission android:name="android.permission.SET\_PROCESS\_LIMITS" />
   
  \<!-- 其他组件配置 -->
  \<activity android:name=".MainActivity">
  \<intent-filter>
  \<action android:name="android.intent.action.MAIN" />
  \<category android:name="android.intent.category.LAUNCHER" />
  \</intent-filter>
  \</activity>
\</application>
```
## 四、第三步：JNI 开发与动态库生成
使用 Android NDK 编译 JNI 代码，生成`libcpu-binder.so`动态库，需配置 CMake 构建脚本与 NDK 参数。
### 1. 编写 JNI 代码
在`src/main/cpp`目录下创建`cpu_binder.cpp`，实现`bindToCpu3`方法，调用`sched_setaffinity`完成进程绑定。
```
\#include \<sched.h>
\#include \<jni.h>
\#include \<errno.h>
\#include \<android/log.h>
// 日志配置：标签与级别
\#define TAG "CpuBinder-JNI"
\#define LOGD(...) \_\_android\_log\_print(ANDROID\_LOG\_DEBUG, TAG, \_\_VA\_ARGS\_\_)
\#define LOGE(...) \_\_android\_log\_print(ANDROID\_LOG\_ERROR, TAG, \_\_VA\_ARGS\_\_)
// JNI方法实现：Java\_包名\_类名\_方法名
extern "C" JNIEXPORT void JNICALL
Java\_com\_example\_myapp\_CpuBinder\_bindToCpu3(JNIEnv \*env, jobject thiz) {
  // 1. 初始化CPU核心掩码
  cpu\_set\_t cpu\_mask;
  CPU\_ZERO(\&cpu\_mask); // 清空掩码
  CPU\_SET(3, \&cpu\_mask); // 将核心3加入掩码（绑定目标核心）
  // 2. 获取当前进程ID
  pid\_t current\_pid = getpid();
  LOGD("当前进程ID：%d，准备绑定CPU核心3", current\_pid);
  // 3. 调用系统接口绑定CPU核心
  int result = sched\_setaffinity(
  current\_pid, // 目标进程ID
  sizeof(cpu\_set\_t), // 掩码大小
  \&cpu\_mask // CPU核心掩码
  );
  // 4. 处理绑定结果
  if (result == -1) {
  LOGE("CPU绑定失败！错误码：%d，错误信息：%s", errno, strerror(errno));
  } else {
  LOGD("进程%d成功绑定到CPU核心3", current\_pid);
  }
}
```
### 2. 配置 CMake 构建脚本
在 App 模块根目录创建`CMakeLists.txt`，定义动态库编译规则，指定源码路径与依赖库。
```
\# 最低CMake版本要求（与NDK兼容，建议3.18+）
cmake\_minimum\_required(VERSION 3.18.1)
\# 项目名称（自定义）
project("cpu-binder")
\# 配置动态库：名称、类型、源码路径
add\_library(
  cpu-binder # 动态库名称（生成libcpu-binder.so）
  SHARED # 类型：SHARED=动态库，STATIC=静态库
  src/main/cpp/cpu\_binder.cpp # JNI源码路径
)
\# 查找Android日志库（用于JNI层打印日志）
find\_library(
  log-lib # 库别名
  log # 系统日志库名称
)
\# 链接依赖库：将日志库关联到自定义动态库
target\_link\_libraries(
  cpu-binder # 目标动态库
  \${log-lib} # 依赖的日志库
)
```
### 3. 配置 NDK 编译参数
在`app/build.gradle`（模块级）中配置 NDK 架构、CMake 路径，确保编译出适配 OK3568 的动态库。
```
android {
  compileSdk 33 # 编译SDK版本（根据项目调整）
  buildToolsVersion "33.0.2"
  defaultConfig {
  applicationId "com.example.myapp"
  minSdk 21 # 最低支持Android版本（≥21）
  targetSdk 33
  versionCode 1
  versionName "1.0"
  \# 配置NDK架构：OK3568为arm64-v8a，仅编译该架构减小体积
  ndk {
  abiFilters "arm64-v8a"
  }
  \# 关联CMake构建脚本
  externalNativeBuild {
  cmake {
  cppFlags "" # 可选：添加C++编译参数（如-std=c++11）
  version "3.22.1" # CMake版本（与Android Studio安装版本匹配）
  }
  }
  }
  \# 配置外部原生构建（指定CMake路径）
  externalNativeBuild {
  cmake {
  path "CMakeLists.txt" # CMake脚本路径（模块根目录）
  version "3.22.1"
  }
  }
  \# 签名配置：系统应用需使用平台签名
  signingConfigs {
  platform {
  storeFile file("platform.jks") # 平台签名文件路径
  storePassword "android"
  keyAlias "androiddebugkey"
  keyPassword "android"
  }
  }
  buildTypes {
  release {
  minifyEnabled false
  proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  signingConfig signingConfigs.platform # release包使用平台签名
  }
  debug {
  signingConfig signingConfigs.platform # debug包也使用平台签名
  }
  }
}
dependencies {
  \# 项目依赖（根据需求添加）
  implementation 'androidx.appcompat:appcompat:1.6.1'
  implementation 'com.google.android.material:material:1.11.0'
}
```
### 4. 编译生成动态库
1. **触发编译**：点击 Android Studio 菜单栏`Build → Make Project`（或快捷键`Ctrl+F9`）
2. **查找动态库**：编译成功后，`libcpu-binder.so`生成路径为：
```
app/build/intermediates/cmake/debug/obj/arm64-v8a/libcpu-binder.so
```
（`debug`目录对应调试版本，`release`目录对应发布版本）
## 五、第四步：权限配置与验证
App 需具备系统应用权限与 root 权限，否则 CPU 绑定会失败。以下是权限配置与验证步骤。
### 1. 配置系统应用权限
#### （1）使用平台签名
将 App 编译为 APK 后，使用 OK3568 的平台签名文件（如`platform.jks`）重新签名，确保`AndroidManifest.xml`中已配置`android:sharedUserId="android.uid.system"`。
#### （2）安装为系统应用
通过 ADB 将 APK 安装到系统分区（`/system/priv-app`目录，权限更高）：
```
\# 1. 推送APK到设备临时目录
adb push app-release.apk /data/local/tmp/
\# 2. 进入设备shell，获取root权限
adb shell
su
\# 3. 移动APK到系统应用目录
mv /data/local/tmp/app-release.apk /system/priv-app/MyCpuApp/
\# 4. 设置权限（系统应用需644权限）
chmod 644 /system/priv-app/MyCpuApp/app-release.apk
chown root:root /system/priv-app/MyCpuApp/app-release.apk
\# 5. 重启设备生效
reboot
```
### 2. 验证 CPU 绑定结果
设备重启后，启动 App，通过 ADB 日志与命令验证绑定效果。
#### （1）查看日志
```
\# 过滤CpuBinder相关日志，确认绑定状态
adb logcat -s "CpuBinder" "CpuBinder-JNI"
```
若日志输出`进程XXX成功绑定到CPU核心3`，说明绑定成功；若提示`权限拒绝（Permission denied）`，需检查系统签名与 root 权限。
#### （2）验证进程绑定状态
```
\# 1. 获取App进程ID（替换为你的包名）
adb shell ps -A | grep com.example.myapp
\# 输出示例：u0\_a123 1234 567 ... com.example.myapp
\# 2. 查看进程绑定的CPU核心（替换为实际PID）
adb shell taskset -p 1234
```
若输出`current affinity mask: 8`（二进制`1000`，对应核心 3），说明 App 进程已成功绑定到 CPU 核心 3。
#### （3）验证核心独占性
```
\# 查看CPU核心3的进程占用情况
adb shell top -H -p 1234 -d 1
```
若仅显示当前 App 的线程在核心 3 运行，无其他系统进程，说明核心独占效果生效。
## 六、常见问题与解决方案
### 1. 动态库加载失败（UnsatisfiedLinkError）
* **原因 1**：动态库架构与设备不匹配（如编译为 x86，设备为 arm64）
**解决**：确保`abiFilters`仅配置`arm64-v8a`，重新编译。
* **原因 2**：JNI 方法名与 Java 层不匹配（如包名错误、方法名拼写错误）
**解决**：严格遵循`Java_包名_类名_方法名`格式，包名中的`.`替换为`_`。
### 2. CPU 绑定失败（Permission denied）
* **原因 1**：App 未使用系统签名或未安装到系统目录
**解决**：使用平台签名重新签名 APK，安装到`/system/priv-app`。
* **原因 2**：SELinux 强制模式限制
**解决**：临时关闭 SELinux（`adb shell setenforce 0`），或添加 SELinux 规则：
```
\# 在设备SELinux配置文件中添加（需源码编译）
allow untrusted\_app self:process setaffinity;
```
### 3. 内核隔离配置不生效
* **原因 1**：设备树修改未编译到内核镜像
**解决**：重新编译内核与设备树，烧录新镜像。
* **原因 2**：核心编号错误（如将 1 基索引误认为 0 基）
**解决**：OK3568 为 4 核 CPU，核心编号为 0-3，确保`isolcpus=3`对应正确核心。
## 七、总结
本文通过 “内核配置→App 开发→JNI 实现→动态库生成→权限验证” 五个步骤，完整实现了 OK3568 Android11 系统下 App 独占隔离 CPU 核心的需求。核心关键点包括：
1. 内核参数`isolcpus`与`nohz_full`是实现 CPU 隔离的基础
2. JNI 层通过`sched_setaffinity`接口完成进程与 CPU 的绑定
3. 系统应用权限与平台签名是绑定成功的前提
4
> （注：文档部分内容可能由 AI 生成）