Worker threads are forcibly terminated prior to the destruction of static objects in a DLL (but not .exe)?

Question

Consider the following code. All of the following was compiled and executed in Visual Studio 2015 using the v140 C++ runtime:

#include <thread>
#include <atomic>
#include <sstream>

#include <Windows.h>

struct StaticThreadTest
{
    ~StaticThreadTest()
    {
        _terminationRequested = true;
        if (_thread.joinable())
            _thread.join();

        std::ostringstream ss;
        ss << "Thread finished gracefully: " << _threadFinishedGracefully << "\n";
        OutputDebugStringA(ss.str().c_str());
    }

    void startThread()
    {
        _thread = std::thread([&]() {
            while (!_terminationRequested);

            _threadFinishedGracefully = true;
        });
    }

    std::thread _thread;
    std::atomic<bool> _terminationRequested {false};
    std::atomic<bool> _threadFinishedGracefully {false};
};

static StaticThreadTest thread;

int main()
{
    thread.startThread();

    return 0;
} 

It works just as expected - "Thread finished gracefully: 1" is printed and the application exits.

However, if I move this code to a DLL (create an empty DLL, export one function from it, place the StaticThreadTest object in the dll's .cpp, call thread.startThread() from the exported function and call this exported function from main.cpp), the code sometimes prints "Thread finished gracefully: 0", but more often than not it just hangs in thread.join().

Is this behavior documented? Is it a bug in the runtime or is this intended?

Of note: the same code but compiled with the v120 toolset hangs 100% of the time even in main.cpp (in the exe). Seems as if there was a bug in the v120 toolset, and in v140 it is fixed for .exe but not for .dll.

Answer 1

It seems that using a different synchronisation mechanism instead of a busy loop (std::mutex + std::condition_variable) eliminates this.

The following example demonstrates both mechanisms:

#include "thread-test-dll.h"

#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>
//#define _BUSY_WAIT
#ifdef _BUSY_WAIT
#include <atomic>
#endif

class foo
{
public:
    foo() 
#ifdef _BUSY_WAIT
        : termination_requested_(false),
        terminated_gracefully_(false)
#endif
    {
        std::cout << "foo::foo()...\n";
    }

    void run()
    {
#define _USE_LAMBDA
#ifdef _USE_LAMBDA
        thread_ = std::thread([&]() {
            work();
        });
#else
        thread_ = std::thread(&foo::work, this);
#endif
    }

    ~foo()
    {
        std::cout << "foo::~foo()...\n";
        if (thread_.joinable())
        {
#ifdef _BUSY_WAIT
            termination_requested_ = true;
#else
            condition_variable_.notify_all();
#endif
            thread_.join();
            std::cout << "thread joined...\n";
        }
        else
        {
            std::cout << "thread was not joinable...\n";
        }
#ifdef _BUSY_WAIT
        std::cout << "terminated_gracefully_ = " << terminated_gracefully_ << "\n";
#endif
    }

    void work()
    {
#ifdef _BUSY_WAIT
        while (!termination_requested_);
        terminated_gracefully_ = true;
#else
        std::unique_lock<std::mutex> mutex_lock(mutex_);
        condition_variable_.wait(mutex_lock);
#endif
        std::cout << "foo:work() terminating...\n";
    }

private:
#ifdef _BUSY_WAIT
    std::atomic<bool> termination_requested_;
    std::atomic<bool> terminated_gracefully_;
#endif
    std::thread thread_;
    std::mutex mutex_;
    std::condition_variable condition_variable_;
};

static foo instance;

void runThread()
{
    instance.run();
}

But I'll still look into if I can make it hang with std::atomic since if that is the cause it is still a different issue than the one on calling std::thread::join() after main has exited.