C+OpenGL开发Minecraft克隆：多线程Chunk生成优化求助

核心问题分析 #

• 锁粒度与顺序错误：同时锁定所有互斥量完全违背多线程并行初衷，单独给计数器加锁属于冗余操作，且锁持有时间覆盖了整个地形生成过程，导致主线程完全无法并行操作。
• 空轮询浪费CPU：while(true)无休眠循环，即使没有待生成Chunk也持续占用CPU资源。
• 线程安全漏洞：部分函数（如world_get_block）未做线程同步，访问共享数据时会引发未定义行为。

具体修复方案 #

1. 精简互斥量与添加条件变量 #

只保留必要的互斥量，搭配条件变量实现线程休眠唤醒，避免空轮询：

#include <pthread.h>

// 保护已加载Chunk链表及chunks_count
pthread_mutex_t chunks_mutex = PTHREAD_MUTEX_INITIALIZER;
// 保护待生成队列及chunks_to_generate_count，搭配条件变量实现唤醒
pthread_mutex_t chunks_to_generate_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t chunks_to_generate_cond = PTHREAD_COND_INITIALIZER;

2. 重构生成线程逻辑 #

仅在操作共享数据时加锁，地形生成等耗时操作完全在锁外执行，用条件变量替代空轮询：

void *generation_thread_main(void *world_arg) {
    world *world_pointer = (world *)world_arg;

    while (true) {
        pthread_mutex_lock(&chunks_to_generate_mutex);
        
        // 无任务时休眠，释放CPU资源
        while (world_pointer->chunks_to_generate_count == 0) {
            pthread_cond_wait(&chunks_to_generate_cond, &chunks_to_generate_mutex);
        }

        // 取出待生成Chunk后立即释放队列锁
        chunk *chunk = queue_dequeue(&world_pointer->chunks_to_generate);
        world_pointer->chunks_to_generate_count--;
        pthread_mutex_unlock(&chunks_to_generate_mutex);

        // 地形生成（耗时操作，无需加锁）
        generate_chunk_terrain(world_pointer, chunk, 0);
        generate_chunk_terrain(world_pointer, chunk, 1);
        chunk_update(chunk);

        // 更新可见性时仅锁定已加载Chunk链表
        pthread_mutex_lock(&chunks_mutex);
        chunk->visible = true;
        pthread_mutex_unlock(&chunks_mutex);

        printf("Chunk Generated - %d, %d, %d\n", chunk->position.x,
               chunk->position.y, chunk->position.z);
    }

    return NULL;
}

3. 修正主线程Chunk加载逻辑 #

仅锁定必要的互斥量，添加任务后唤醒生成线程：

void world_load_chunk(world *world, vector3i position) {
    // 先检查Chunk是否已加载，仅锁定chunks_mutex
    pthread_mutex_lock(&chunks_mutex);
    int chunk_index = get_chunk_index(world, position);
    if (chunk_index != -1) {
        pthread_mutex_unlock(&chunks_mutex);
        return;
    }

    // 创建Chunk并加入已加载链表
    chunk *new_chunk = malloc(sizeof(chunk));
    chunk_init(new_chunk, position, &world->tilemap);
    new_chunk->visible = false;
    linked_list_insert_end(&world->chunks, new_chunk);
    world->chunks_count++;
    pthread_mutex_unlock(&chunks_mutex);

    // 添加到待生成队列并唤醒生成线程
    pthread_mutex_lock(&chunks_to_generate_mutex);
    queue_enqueue(&world->chunks_to_generate, new_chunk);
    world->chunks_to_generate_count++;
    pthread_cond_signal(&chunks_to_generate_cond);
    pthread_mutex_unlock(&chunks_to_generate_mutex);
}

4. 简化其他函数的锁操作 #

• 绘制函数：仅锁定已加载Chunk链表，且只绘制可见Chunk：

void world_draw(world *world) {
    texture_bind(&world->tilemap.texture);

    pthread_mutex_lock(&chunks_mutex);
    for (int i = 0; i < world->chunks_count; i++) {
        chunk *chunk = linked_list_get(&world->chunks, i);
        if (chunk->visible) {
            chunk_draw(chunk);
        }
    }
    pthread_mutex_unlock(&chunks_mutex);
}

• 卸载函数：按固定顺序加锁避免死锁，同时清理待生成队列中的目标Chunk：

void world_unload_chunk(world *world, vector3i position) {
    pthread_mutex_lock(&chunks_mutex);
    int chunk_index = get_chunk_index(world, position);
    if (chunk_index == -1) {
        pthread_mutex_unlock(&chunks_mutex);
        return;
    }

    chunk *target_chunk = linked_list_get(&world->chunks, chunk_index);
    linked_list_remove(&world->chunks, chunk_index);
    world->chunks_count--;
    pthread_mutex_unlock(&chunks_mutex);

    // 从待生成队列移除（需实现queue_remove函数）
    pthread_mutex_lock(&chunks_to_generate_mutex);
    // queue_remove(&world->chunks_to_generate, target_chunk);
    // if (移除成功) world->chunks_to_generate_count--;
    pthread_mutex_unlock(&chunks_to_generate_mutex);

    free(target_chunk);
}

5. 修复world_get_block线程安全问题 #

添加互斥锁保护共享链表访问：

block_type world_get_block(world *world, vector3d position) {
    vector3i chunk_position = {floor(position.x / CHUNK_SIZE_X),
                               floor(position.y / CHUNK_SIZE_Y),
                               floor(position.z / CHUNK_SIZE_Z)};

    pthread_mutex_lock(&chunks_mutex);
    int chunk_index = get_chunk_index(world, chunk_position);
    if (chunk_index == -1) {
        pthread_mutex_unlock(&chunks_mutex);
        return BLOCK_TYPE_EMPTY;
    }

    chunk *chunk = linked_list_get(&world->chunks, chunk_index);
    vector3i block_chunk_position = {mod(floor(position.x), CHUNK_SIZE_X),
                                     mod(floor(position.y), CHUNK_SIZE_Y),
                                     mod(floor(position.z), CHUNK_SIZE_Z)};
    block_type type = chunk->blocks[block_chunk_position.z][block_chunk_position.y]
                        [block_chunk_position.x];
    pthread_mutex_unlock(&chunks_mutex);

    return type;
}

额外优化建议 #

• 多生成线程：创建与CPU核心数一致的生成线程，提升Chunk生成速度，注意队列的线程安全。
• 预加载/卸载策略：根据玩家位置提前加载周边Chunk，卸载超出视野范围的Chunk，控制内存占用。
• 生成步骤拆分：将地形生成、光照计算、Mesh构建拆分为独立阶段，进一步并行化处理。

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