第2章 线程同步基础：锁、信号量、条件变量适用场景与Java/C++原语对比

在多语言RTL（Right-to-Left）环境下，TalkBack的读屏线程与UI渲染线程、计算线程之间需要精确同步，否则会导致“抢读”、“跳读”、朗读顺序错乱甚至ANR。理解锁（Lock）、信号量（Semaphore）、条件变量（Condition Variable）的适用场景，以及Android Java与C++（NDK）同步原语的差异，是实现线程安全RTL引擎的基石。

2.1 核心原理与适用场景

三种基元解决不同维度的并发问题：

2.2 实现流程与代码示例

2.2.1 Android Java 实现

锁（ReentrantLock + tryLock）

import java.util.concurrent.locks.ReentrantLock;

final ReentrantLock rtlLock = new ReentrantLock();
boolean acquired = false;
try {
    acquired = rtlLock.tryLock(200, TimeUnit.MILLISECONDS);
    if (acquired) {
        // 修改RTL方向标记表
    } else {
        // 上报超时，不阻塞主线程
        Log.w("RTL", "尝试获取锁超时，跳过本次更新");
    }
} finally {
    if (acquired) rtlLock.unlock();
}

信号量（Semaphore）

import java.util.concurrent.Semaphore;

final Semaphore glyphExtractors = new Semaphore(2); // 最多2个线程同时提取字形
glyphExtractors.acquire(); // 可能阻塞
try {
    // 提取该段RTL字符字形
} finally {
    glyphExtractors.release();
}

条件变量（Condition + ReentrantLock）

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

final ReentrantLock lock = new ReentrantLock();
final Condition reflowDone = lock.newCondition();
volatile boolean isReflowComplete = false;

// 渲染线程：
lock.lock();
try {
    // 完成RTL重排
    isReflowComplete = true;
    reflowDone.signalAll();
} finally {
    lock.unlock();
}

// TalkBack朗读线程：
lock.lock();
try {
    while (!isReflowComplete) {
        reflowDone.await(); // 释放锁并等待信号
    }
    // 继续朗读
} finally {
    lock.unlock();
}

2.2.2 C++ NDK 实现

锁（std::mutex + std::lock_guard / std::unique_lock）

#include <mutex>

std::mutex rtl_mutex;
void update_rtl_table() {
    std::lock_guard<std::mutex> guard(rtl_mutex);
    // 更新RTL方向表
}

信号量（无标准实现，可用 std::counting_semaphore C++20 或自定义）

#include <semaphore> // C++20

std::counting_semaphore<2> glyph_sem(2); // 最大并发2
void extract_glyph() {
    glyph_sem.acquire();
    // 提取字形
    glyph_sem.release();
}

条件变量（std::condition_variable + std::unique_lock）

#include <condition_variable>
#include <mutex>

std::mutex cv_mtx;
std::condition_variable cv;
bool reflow_ready = false;

// 渲染线程
{
    std::lock_guard<std::mutex> lk(cv_mtx);
    reflow_ready = true;
    cv.notify_all();
}

// TalkBack线程
{
    std::unique_lock<std::mutex> lk(cv_mtx);
    cv.wait(lk, []{ return reflow_ready; });
    // 继续
}

2.3 Android Java 与 C++ 同步原语对比

2.4 调试与性能优化

调试技巧

• 启用死锁检测：Java中可使用ThreadMXBean.findDeadlockedThreads()；C++中使用AddressSanitizer + ThreadSanitizer。
• 统计锁竞争：Android Studio Profiler的Lock Contention视图显示等待时间；C++中可包装std::mutex并记录阻塞时长。
• 信号量泄漏：确保release()放在finally或RAII作用域内，否则资源数逐渐耗尽。

性能优化策略

2.5 同步原语适用决策图