C ++ 11线程未加入

Question

I have experience with threads in Java but want to learn how to use them in C++11. I tried to make a simple threadpool, where threads are created once and can be asked to execute tasks.

#include <thread>
#include <iostream>

#define NUM_THREADS 2

class Worker
{
public:
    Worker(): m_running(false), m_hasData(false)
    {

    };
    ~Worker() {};

    void execute()
    {
        m_running = true;

        while(m_running)
        {
            if(m_hasData)
            {
                m_system();
            }
            m_hasData = false;
        }
    };

    void stop()
    {
        m_running = false;
    };

    void setSystem(const std::function<void()>& system)
    {
        m_system = system;
        m_hasData = true;
    };

    bool isIdle() const
    {
        return !m_hasData;
    };
private:
    bool m_running;
    std::function<void()> m_system;
    bool m_hasData;
};

class ThreadPool
{
public:
    ThreadPool()
    {
        for(int i = 0; i < NUM_THREADS; ++i)
        {
            m_threads[i] = std::thread(&Worker::execute, &m_workers[i]);
        }
    };
    ~ThreadPool()
    {
        for(int i = 0; i < NUM_THREADS; ++i)
        {
            std::cout << "Stopping " << i << std::endl;
            m_workers[i].stop();
            m_threads[i].join();
        }
    };

    void execute(const std::function<void()>& system)
    {
        // Finds the first non-idle worker - not really great but just for testing
        for(int i = 0; i < NUM_THREADS; ++i)
        {
            if(m_workers[i].isIdle())
            {
                m_workers[i].setSystem(system);
                return;
            }
        }
    };
private:
    Worker m_workers[NUM_THREADS];
    std::thread m_threads[NUM_THREADS];
};

void print(void* in, void* out)
{
    char** in_c = (char**)in;
    printf("%s\n", *in_c);
}

int main(int argc, const char * argv[]) {
    ThreadPool pool;
    const char* test_c = "hello_world";
    pool.execute([&]() { print(&test_c, nullptr); });
}

The output of this is:

hello_world
Stopping 0

After that, the main thread halts, because it's waiting for the first thread to join (in the destructor of the ThreadPool). For some reason, the m_running variable of the workers is not set to false, which keeps the application running indefinitely.

Answer 1

In Worker::stop the member m_running is written in the main thread, while it is read in execute in a different thread. This is undefined behavior. You need to protect read/write access from different threads. In this case I would recommend using std::atomic<bool> for m_running .

Edit: the same holds for m_hasData .