Release模式下C++多线程功能失效问题求助

你的代码在Debug模式正常但Release模式失效，核心原因是普通变量的内存可见性问题：

• Debug模式下编译器禁用激进优化，变量读写直接操作内存，线程间能互相感知变量修改；
• Release模式下编译器会将idle、stop、threads_complete这类频繁访问的变量缓存到CPU寄存器，线程无法感知其他线程对内存中变量的修改，导致逻辑异常：
  1. 工作线程会一直读取寄存器中缓存的idle=true，永远跳过任务执行逻辑；
  2. 主线程读取threads_complete时，因无同步机制，编译器会认为它的值永远是初始的0，甚至可能优化掉忙等循环。

方案1：使用原子类型（推荐） #

将共享变量替换为C++标准库的原子类型，原子类型自动保证内存可见性和操作原子性，无需手动加锁（复杂复合操作除外）：

#include <vector>
#include <thread>
#include <mutex>
#include <atomic>
#include <chrono>

struct Test
{
    int threads = 4;
    std::atomic<int> threads_complete = 0;

    std::atomic<bool> idle = true;
    std::atomic<bool> stop = false;

    std::mutex mtx;

    // A single task
    void task(int n)
    {
        bool done = false;

        while (!stop.load())
        {
            if (idle.load() || done) continue;

            for (int i = 0; i <= 3 * (n + 1); i++)
            {
                printf("Task %d, iteration %d of %d\n", n, i, 3 * (n + 1));
                std::this_thread::sleep_for(std::chrono::milliseconds(300));
            }

            done = true;
            threads_complete++; // 原子操作，无需手动锁
        }
    }

    // Launch multiple tasks
    void do_tasks()
    {
        std::vector<std::thread> v;

        // Start multiple threads
        for (int i = 0; i < threads; i++)
        {
            v.emplace_back(&Test::task, this, i);
        }

        // Launch subtasks in threads
        idle.store(false);

        // Wait for all tasks to finish
        while (threads_complete.load() != threads);

        // Stop all the cycles inside tasks
        stop.store(true);

        // Await for threads to quit
        for (auto& t : v)
        {
            t.join();
        }
    }
};

int main()
{
    Test test;
    test.do_tasks();
    printf("\nDone\n");
    getchar();
}

方案2：使用volatile关键字（快速修复，不推荐） #

volatile会告诉编译器不要优化该变量的读写，强制每次操作都访问内存，保证线程间可见性，但它不保证操作的原子性（比如threads_complete++这类复合操作仍需要锁）：

struct Test
{
    int threads = 4;
    volatile int threads_complete = 0;

    volatile bool idle = true;
    volatile bool stop = false;

    std::mutex mtx;

    // ... 其余代码不变，threads_complete的修改仍需保留锁逻辑
};

优化建议：用条件变量替代忙等 #

主线程的while (threads_complete != threads);是忙等，会占用大量CPU资源，建议用std::condition_variable实现线程同步，更高效：

#include <vector>
#include <thread>
#include <mutex>
#include <atomic>
#include <chrono>
#include <condition_variable>

struct Test
{
    int threads = 4;
    std::atomic<int> threads_complete = 0;
    std::atomic<bool> idle = true;
    std::atomic<bool> stop = false;

    std::mutex mtx;
    std::condition_variable cv;

    void task(int n)
    {
        bool done = false;
        while (!stop.load())
        {
            if (idle.load() || done) continue;

            for (int i = 0; i <= 3 * (n + 1); i++)
            {
                printf("Task %d, iteration %d of %d\n", n, i, 3 * (n + 1));
                std::this_thread::sleep_for(std::chrono::milliseconds(300));
            }

            done = true;
            threads_complete++;
            cv.notify_one(); // 通知主线程任务完成
        }
    }

    void do_tasks()
    {
        std::vector<std::thread> v;
        for (int i = 0; i < threads; i++)
        {
            v.emplace_back(&Test::task, this, i);
        }

        idle.store(false);

        // 用条件变量等待，避免忙等
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this](){ return threads_complete == threads; });

        stop.store(true);
        for (auto& t : v)
        {
            t.join();
        }
    }
};

int main()
{
    Test test;
    test.do_tasks();
    printf("\nDone\n");
    getchar();
}

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