Thread Wrapper for Modern 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

The template class InterlockedProperty simply defines two operators for reading and writing of the property value and wraps the access to the value in the same mutex object.

Of course, not all types can be used as a template parameter; the class with deleted default constructor could not be used.

The initialization the InterlockedProperty instance requires some understanding.

Initialization of InterlockedProperty

Look at the set of the public InterlockedProperty constructors. Two of them use the mutex object uniqueMutex constructed in the class, the other two use some external mutex instance supplied by the constructor. The simpler constructors, those without the external mutex parameter, implement the simplest case when the access to the property is interlocked between the thread wrapper’s thread, and other threads. It probably covers most of the most typical applications.

However, for a different sort of applications, also a very typical one, this is not enough. The thread wrapper may have more than one property, and some properties have to be synchronized together. For example, a thread wrapper may operate two properties which values are not random, but they obey some invariant; that is, not all combination of the two property values is valid. In other words, it can be incorrect to modify one property in one thread and another one in another thread, because intermediate state of the thread wrapper may eventually become incorrect. The modification of the whole set of some properties should be mutually exclusive. Actually, this is a general purpose of the mutex.

That said, all such properties should simply share the same instance of the mutex, which is possible to do by using the constructors with the sharedMutex parameters. Another ways to share a mutex are: using the InterlockedProperty& operator=(InterlockedProperty&) (only works for two instances of InterlockedProperty of the same template parameter type) or the UseSharedMutex(std::mutex&) (can be called, for example, from the body of a thread wrapper constructor).

Now, two of the constructors can be used to initialize property value. Not that the modification of the property value in the constructors is not interlocked. First, it is not needed. More importantly, it won’t work in all cases. One such case is shown on the usage sample shown below. In this sample, the shared mutex is the member of the thread wrapper class, and it is passed to the property instances in a constructor’s initializer list, where the InterlockedProperty constructors are called, but the mutex object is not yet fully constructed at that time. It can be easily observed under the debugger; and the class std::mutex is the one which cannot be used for locking in this state. In general, take extra care trying to call the functions of objects passed in a constructor’s initializer list.

Usage, All Put Together

Now when all parts are explained, I can show some more or less comprehensive usage sample, complete with interlocked properties synchronized together:

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