Java高优先级线程：如何用锁实现渲染线程阻塞其他线程并优化帧率

核心逻辑梳理 #

你需要的是渲染线程定期唤醒后，独占所有资源完成渲染，其他游戏逻辑线程在渲染期间阻塞，其余时间正常按调度运行。之前帧率低的核心问题大概率是渲染线程持有锁休眠，导致逻辑线程长期阻塞，或者锁的粒度不合理。下面给出两种可行的锁实现方案：

方案1：全局独占锁（ReentrantLock） #

适合逻辑线程之间也需要互斥执行的场景：

1. 定义全局可重入锁：

private final ReentrantLock gameLock = new ReentrantLock();

2. 游戏逻辑线程（ArrayList中的线程）实现：
   每个线程在执行调度任务时，先获取锁，执行完核心逻辑后立即释放：

@Override
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        // 这里替换成你的调度触发逻辑（比如等待定时器/事件）
        waitForScheduledEvent();
        
        gameLock.lock();
        try {
            // 执行游戏状态修改、逻辑计算等核心操作
            updateGameLogic();
        } finally {
            // 必须在finally里释放锁，避免异常导致锁泄漏
            gameLock.unlock();
        }
    }
}

3. 渲染线程实现：
   休眠放在锁外部，仅在渲染阶段获取锁阻塞所有逻辑线程：

@Override
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(10000); // 每10秒休眠，此时不持有锁，逻辑线程正常运行
        } catch (InterruptedException e) {
            // 响应中断，优雅退出
            Thread.currentThread().interrupt();
            break;
        }
        
        gameLock.lock();
        try {
            // 独占锁期间，所有逻辑线程阻塞，执行渲染
            renderGameBoard();
        } finally {
            gameLock.unlock();
        }
    }
}

方案2：读写锁（ReadWriteLock） #

如果游戏逻辑线程之间可以并行执行（比如各自处理独立的游戏对象，无状态竞争），用读写锁可以提升整体运行效率：

1. 定义读写锁：

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock logicLock = rwLock.readLock(); // 逻辑线程用读锁，允许多个并行
private final Lock renderLock = rwLock.writeLock(); // 渲染线程用写锁，独占所有线程

2. 逻辑线程实现：

@Override
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        waitForScheduledEvent();
        
        logicLock.lock();
        try {
            updateGameLogic();
        } finally {
            logicLock.unlock();
        }
    }
}

3. 渲染线程实现：

@Override
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            break;
        }
        
        renderLock.lock();
        try {
            renderGameBoard();
        } finally {
            renderLock.unlock();
        }
    }
}

提升渲染帧率的关键优化 #

• 绝对不要持有锁休眠：把Thread.sleep放在锁外部是核心，之前的低帧率很可能是渲染线程拿着锁休眠，导致逻辑线程全程阻塞，渲染触发自然受影响。
• 缩小锁的粒度：锁只包裹游戏状态修改/读取的核心代码，不要把调度等待、IO操作等无关逻辑放在锁范围内，减少线程阻塞时间。
• 快照渲染优化：如果渲染耗时较长，可以在获取锁后先拷贝一份游戏状态快照，释放锁后再渲染，这样锁的持有时间仅为拷贝快照的时间，大幅降低对逻辑线程的阻塞：

// 渲染线程修改后的逻辑
renderLock.lock();
GameState stateSnapshot = null;
try {
    stateSnapshot = copyCurrentGameState(); // 快速拷贝状态
} finally {
    renderLock.unlock();
}
// 锁外渲染，不影响逻辑线程运行
renderGameBoard(stateSnapshot);

• 用调度器替代Thread.sleep：如果需要更高精度的渲染触发，用ScheduledExecutorService替代Thread.sleep，避免休眠精度误差：

ScheduledExecutorService renderScheduler = Executors.newSingleThreadScheduledExecutor();
renderScheduler.scheduleAtFixedRate(() -> {
    renderLock.lock();
    try {
        renderGameBoard();
    } finally {
        renderLock.unlock();
    }
}, 0, 10, TimeUnit.SECONDS); // 初始延迟0秒，每10秒执行一次

内容的提问来源于stack exchange，提问作者hjmu