现代 C++ 的线程包装器

#include <mutex>

template<typename T>
class InterlockedProperty {
public:

    InterlockedProperty() : InterlockedProperty(nullptr, nullptr) { }
    InterlockedProperty(const T &value) : InterlockedProperty(nullptr, &value) { }
    InterlockedProperty(std::mutex& sharedMutex) : InterlockedProperty(&sharedMutex, nullptr) { }
    InterlockedProperty(std::mutex& sharedMutex, const T &value) : InterlockedProperty(&sharedMutex, &value) { }

    InterlockedProperty& operator=(InterlockedProperty& other) {
        this->mutex = other.mutex;
        this->value = other.value;
        return *this;
    } //operator=

    void UseSharedMutex(std::mutex& mutext) {
        this->mutex = mutex;
    } //UseSharedMutex

    operator T() const {
        std::lock_guard<std::mutex> lock(*mutex);
        return value;
    } //operator T

    T operator=(const T &value) {
        std::lock_guard<std::mutex> lock(*mutex);
        return this->value = value;
    } //operator=

private:

    InterlockedProperty(std::mutex * sharedMutex, const T * value) {
        if (sharedMutex == nullptr)
            mutex = &uniqueMutex;
        else
            mutex = sharedMutex;
        if (value != nullptr) // don't use mutex to interlock value here: it could be not yet fully constructed
            this->value = *value;
    } //InterlockedProperty

    std::mutex uniqueMutex;
    std::mutex * mutex;
    T value;

}; // class InterockedProperty

using natural = unsigned long long int;

class MyThread : public ThreadWrapper {
public:
    MyThread() : id(mutex, 2), name(mutex) {}
    InterlockedProperty<int> id;
    InterlockedProperty<const char*> name, help;
    InterlockedProperty<natural> delayMs;
protected:
    void Body() override {
        auto sleep = [=] {
            std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
        }; //sleep
        int count = 0;
        name = oldName;
        while (true) {
            this->SyncPoint();
            std::cout << count++ << help;
            std::cout << "id: " << id << ", name: " << name << std::endl;
            sleep();
        } //loop
    } //Body
private:
    const char* oldName = "none";
    std::mutex mutex;
}; //class MyThread

class ThreadWrapperDemo {
    enum class command {
        abort = 'a', // abort thread
        quit = 'q', // also abort thread
        sleep = 's',
        wakeUp = 'w',
    };
    static const char* help() { return " a, q: quit, s: sleep, w: wake up, else: change property; "; }
    static bool commandIs(char c, command cmd) { return (int)cmd == (int)c; }
public:
    static void Run(natural delayMs) {
        const char* newName = "new";
        MyThread thread;
        thread.help = help();
        thread.delayMs = delayMs;
        //thread.Suspend(); // can be suspended before start, waken up after
        thread.Start(); // thread.Start(true) for the detached (background)
        char cmd;
        while (true) {
            std::cin >> cmd;
            if (commandIs(cmd, command::abort) || commandIs(cmd, command::quit)) {
                thread.Abort();
                break;
            } else if (commandIs(cmd, command::sleep))
                thread.PutToSleep();
            else if (commandIs(cmd, command::wakeUp))
                thread.WakeUp();
            else {
                thread.id = thread.id + 1; // no ++ defined
                thread.name = newName;
            } //if
        } //loop
        thread.Join();
    } //Run
}; // class ThreadWrapperDemo

此代码片段还显示了线程终止以及从两个线程访问线程成员。两个注释显示了在等待（休眠）状态下启动线程的选项，以及在后台（分离）模式下使用线程的选项，但仍然能够连接它。

兼容性和构建

所有线程包装器解决方案都包含在两个文件中。

• “ThreadWrapper.h”，
• “InterlockedProperty.h”，

它们可以添加到任何项目中。

编译器应支持 C++11 或更高版本。对于 GCC，这应该设置为 -std=c++11 或 -std=c++14 等选项。

演示项目有两种形式：1) 使用 Microsoft C++ 编译器和 Clang 的 Visual Studio 2015 解决方案和项目——参见“ThreadWrapper.sln”；2) 使用 GCC 的 Code::Blocks 项目——“ThreadWrapper.cbp”。对于所有其他选项，可以通过将解决方案文件目录的子目录“Cpp”中的所有“*.h”和“*.cpp”文件添加到项目中来组装一个项目或 Makefile。

我已在 Visual Studio 2015、Clang 4.0.0、GCC 5.1.0 上测试了代码。

C++ 选项包括“禁用语言扩展”（Microsoft 和 Clang 为 /Za），这对于 Microsoft 似乎是必需的。

版本

初始版本

2017 年 3 月 20 日

1.0

2017 年 3 月 21 日

添加了派生自 ThreadWrapper 的 ConveyorThreadWrapper。此类在单独的文章 现代 C++ 的传送带线程包装器 中有详细描述。重新设计了演示应用程序。

2.0

2017 年 3 月 24 日

更改了 ConveyorThreadWrapper 的设计。在 ThreadWrapper 中，扩展了受保护成员的集合，以支持 ConveyorThreadWrapper。线程状态同步与 ConveyorThreadWrapper 阻塞队列同步分开。

2.1

2017 年 10 月 29 日

修复了 ThreadWrapper::ExceptionCaught 函数签名的错误。应为：virtual void ExceptionCaught(std::exception& exception) {}

最终注释

添加了带有 Threading.ThreadWrapper 类的 C# 项目以供参考。我可能会决定撰写更多关于相关主题的文章。在这种情况下，我可能会升级并共享从当前文章页面下载的源代码。

我希望收到关于本文的富有信息性的反馈、批评和建议。感谢您的时间和耐心。