VS 14的线程析构函数崩溃

Question

我正在使用Visual 14实现一个具有可中断线程(如boost和Java中的线程)的并发库，基于C++11中的标准库。

在进行了一些重构之后，我在std：：线程的析构函数中遇到了一个崩溃(有时试图取消引用一个空指针，有时是"Debug Error！R6010“，有时根本没有崩溃)。经过大量的代码剥离来发现这个问题，我无法更好地理解这个问题是与我的代码有关，还是可能是编译器错误。

即使在去掉代码之后，仍然需要大量的代码来重现这个问题，所以请原谅我:)

线程包装器实现的部分：

class InterruptException : public std::exception
{
public:
    const char* what() const override {return "InterruptException";}
};

class Thread
{
public:
    Thread(const Thread&) = delete;
    Thread& operator=(const Thread&) = delete;

    Thread();

    template <typename Callable>
    Thread(Callable&& action);

    Thread(Thread&& other);

    ~Thread();

    Thread& operator=(Thread&& other);

    // Sets interruption flag and call notifyAll for current condition if any.
    void interrupt();

    // Throws interrupted exception if current thread interruption flag is set.
    // This also resets the interruption flag.
    static void interruptionPoint();

    static void interruptCurrent();


    static void setCondition(std::condition_variable* cond);
    static Thread* currentThread(Thread* setter = nullptr);

private:
    std::atomic<bool>                       _interruptionFlag;
    std::atomic<std::condition_variable*>   _currentCondition;
    std::thread _stdThread;
};

template <typename Callable>
Thread::Thread(Callable&& action)
: _stdThread(),
  _interruptionFlag(false),
  _currentCondition(nullptr)
{
    _stdThread = std::thread(
        [this, runner = std::move(action)]
        {
            currentThread(this);

            try
            {
                runner();
            }
            catch (InterruptException&)
            {
                // Normal exit.
            }
            catch (...)
            {
                // Removed logging calls.
            }
        }
    );
}

Thread::~Thread()
{
    // Block at thread destruction, no detached thread support.
    if (_stdThread.joinable())
    {
        interrupt();
        _stdThread.join();
    }
}

// (More code if requested.)

(请注意，为了清晰起见，上面的代码缺少部分)

我为Thread类编写了几个测试，它似乎如人们所期望的那样工作。下一部分是任务运行器的简化版本。

template <typename Runner>
class StrippedSystem
{
public:
    template <typename... CtorArgs>
    StrippedSystem(CtorArgs&&... args);

    StrippedSystem(const StrippedSystem&) = delete;
    StrippedSystem(StrippedSystem&&) = delete;

    // ...

private:
    template <typename... CtorArgs>
    Thread createRunnerThread(CtorArgs&&... args);

    std::mutex _mutex;
    std::condition_variable _cond;

    Thread _runner;
};

template <typename Runner>
template <typename... CtorArgs>
StrippedSystem<Runner>::StrippedSystem(CtorArgs&&... args)
{
    _runner = createRunnerThread(std::forward<CtorArgs>(args)...);
}

template <typename Runner>
template <typename... CtorArgs>
Thread StrippedSystem<Runner>::createRunnerThread(CtorArgs&&... args)
{
    auto runnerProc =
    [&]
    {
        Thread::setCondition(&_cond);

        try
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(
                lock,
                [&]
                {
                    Thread::interruptionPoint();
                    return false;
                }
            );
        }
        catch (...)
        {
            Thread::setCondition(nullptr);
            std::rethrow_exception(std::current_exception());
        }
    };

    return Thread(runnerProc);
}

简化后的StrippedSystem的代码非常简单。它创建一个等待直到中断的线程。当调用Thread的析构函数时，将设置中断标志，并通知条件。然后，线程运行到一个中断点(在_cond.wait lambda内)，该中断点抛出一个InterruptionException，该InterruptionException在线程包装器中捕获，线程正常退出。

现在是崩溃所有内容的代码：

struct ConstructedRunner
{
    ConstructedRunner(int a, std::string b)
    : i(a), j(b)
    {
    }

    int i;
    std::string j;
};

int main(int argc, char* argv[])
{
    {
        StrippedSystem<ConstructedRunner> testSys2(1, "foobar");
    }

    return 0;
}

如前所述，崩溃可以是"Debug Error！abort已被调用“、访问冲突(试图取消引用空指针)，或者在某些情况下根本没有崩溃。

经过一些故障排除后，我发现以下内容不会崩溃

struct DummyRunner
{
};

int main(int argc, char* argv[])
{
    {
        StrippedSystem<DummyRunner> testSys1;
    }

    return 0;
}

经过更多的故障排除后，我发现在系统构造函数中替换了

_runner = createRunnerThread(std::forward<CtorArgs>(args)...);

使用

_runner = Thread(
        [&]
        {
            Thread::setCondition(&_cond);

            try
            {
                std::unique_lock<std::mutex> lock(_mutex);
                _cond.wait(
                    lock,
                    [&]
                    {
                        Thread::interruptionPoint();
                        return false;
                    }
                );
            }
            catch (...)
            {
                Thread::setCondition(nullptr);
                std::rethrow_exception(std::current_exception());
            }
        }
    );

也修复了坠机。即使未使用转发的参数。

这对我来说毫无意义，因为运行的代码应该是相同的。这是编译器问题，还是我做错了什么，导致了一些奇怪的并发问题？

在调试模式下使用14构建Windows 7。

Answer 1

经过一些帮助，我把错误整理好了。

问题是存在于currentThread(this)模板构造函数中的Thread。该函数将线程指针设置为线程本地静态变量，然后读取该变量以获得中断标志和当前条件(如果有的话)。问题是this指针指的是一个临时对象。这可以在_runner = Thread(...)中看到，其中临时Thread对象位于右侧，并且被设置为线程本地数据。线程移动后没有更新数据。

在Thread的析构函数中，interrupt检查了线程本地标志，这就是析构函数崩溃的原因。