适用于现代 C++ 的传送带线程包装器

class ConveyorThreadWrapperDemo : public ConveyorThreadWrapper<int> {
    enum class command {
        quit = 'q', // entire thread
        abort = 'a', // current task
        sleep = 's',
        wakeUp = 'w',
    };
    static const char* help() { return "a: task abort, q: quit, s: sleep, w: wake up, key: "; }
    static bool commandIs(char c, command cmd) { return (int)cmd == (int)c; }
public:
    using natural = unsigned long long int;
    static void Run(natural delayMs) {
        natural max = 100;
        IntegerConveyor cv;
        cv.CurrentTaskAborted = [](int) -> void {
            std::cout << ". Enter any character: ";
        }; //cv.CurrentTaskAborted
        using cType = decltype(cv);
        auto sleep = [delayMs] {
            std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
        }; //sleep
        auto Hailstone = [] (natural a) -> natural {
            if (a % 2 == 0)
                return a / 2;
            else
                return 3 * a + 1;
        }; //Hailstone (iteration)
        auto HailstoneStoppingTime = [Hailstone] (natural n) -> natural {
            natural stoppingTime = 0;
            while (n != 1) {
                n = Hailstone(n);
                ++stoppingTime;
            } //loop
            return stoppingTime;
        }; //HailstoneStoppingTime
        auto lambdaHailstone = [HailstoneStoppingTime, sleep, max] (cType::SyncDelegate& sync, int value) {
            for (natural count = 1; count < max; ++count) {
                natural stoppingTime = HailstoneStoppingTime(count + value);
                sync(false);
                std::cout
                    << count << ": " << help()
                    << value << " => Hailstone " << stoppingTime << std::endl;
                sleep();
            } //loop
        }; //lambdaHailstone
        natural mod = 1;
        mod = mod << 32; // NOT 1 < 32 !!!
        natural multiplier = 1664525; // Numerical Recipes
        natural increment = 1013904223; // Numerical Recipes
        auto Lgc = [mod, multiplier, increment](natural n) -> natural {
            return (n * multiplier + increment) % mod;
        }; //Lgc
        auto lambdaLgc = [Lgc, sleep, max](cType::SyncDelegate& sync, int value) {
            natural n = value;
            for (natural count = 0; count < max; count++) {
                n = Lgc(n);
                sync(false);
                std::cout
                    << help()
                    << value << " => LGC " << (n) << std::endl;
                sleep();
            } //loop
        }; //lambdaLgc
        SA::delegate<void(cType::SyncDelegate&, int)> delHailstone = lambdaHailstone;
        SA::delegate<void(cType::SyncDelegate&, int)> delLgc = lambdaLgc;
        cv.Start();
        char cmd;
        while (true) {
            std::cin >> cmd;
            if (commandIs(cmd, command::abort))
                cv.Abort();
            else if (commandIs(cmd, command::quit)) {
                cv.Abort(cType::AbortDepth::entierThread);
                break;
            } else if (commandIs(cmd, command::sleep))
                cv.PutToSleep();
            else if (commandIs(cmd, command::wakeUp))
                cv.WakeUp();
            else {
                int cmdValue = (int)cmd;
                if (cmdValue % 2 == 0)
                    cv.Enqueue(delHailstone, cmdValue);
                else
                    cv.Enqueue(delLgc, cmdValue);
            } //if
        } //loop
        cv.Join();
    } //Run
}; //class ConveyorThreadWrapperDemo

此演示展示了lambda 表达式的使用，在许多情况下它们非常方便。或者，委托机制也允许使用静态函数和常量或非常量实例函数，如关于委托的文章中所述。

顺便说一句，注意一个非常明显但重要的 lambda 表达式技术：通过闭包而不是通过参数列表传递一些对象。例如，lambda 表达式 sleep 使用方法 Run 的参数值 delayMs，如 auto sleep = [delayMs]。

对于此应用程序，这是至关重要的。它可以作为参数列表传递，但让我们看看 sleep 是如何使用的。最终，所有这些 lambda 表达式都由 lambda 表达式 lambdaHailstone 和 lambdaLgc 调用，并且也通过它们的闭包传递。这两个最终的 lambda 表达式在此上下文中从不被调用。相反，它们被赋值给委托实例。它们的参数列表应符合委托的配置文件（在此处显示），并且不能接受其他实际参数。

请注意，在某个任务执行期间可以连续输入多个字符。这演示了在某个任务执行期间新任务被排队的情况。如果例如在另一个任务执行期间排队了 N 个任务，则最多需要 N+1 次当前任务中止才能将线程带入等待状态。当当前正在执行的任务被中止时，将从队列中获取下一个任务进行执行。

如果一段时间内没有执行浅层中止，当前任务最终将完成执行。这将使线程休眠。通过向队列添加另一个任务可以唤醒线程。我故意指定了较少次数的迭代，以演示此条件。用户代码无需添加另一个虚拟函数或委托来挂钩此事件，因为如果需要，可以将适当的操作简单地写在任务委托代码中。

在此代码示例中，我试图在纯数学算法的代价上缩短文本，而保留“系统”方面的内容。同时，有趣的部分在于这些算法。

演示算法

让我们进行一个与本文主题关系不大的简短有趣休息。在演示应用程序中，为了演示将不同的委托传递给队列，我实现了两种选择（选择的算法取决于用户输入的字符的代码点的奇偶性）：计算Hailstone 数列的总停止时间，以及线性同余生成器。

第一件事是一个非常复杂的数学问题，很可能在撰写本文时尚未解决；这个问题被认为是“一个极其困难的问题，远远超出了当今数学的范畴”。这个问题被称为 Collatz 猜想，或 3n+1 猜想。它表明，通过递归过程定义的数字序列，对于偶数 n 是 n->n/2，对于奇数 n 是 n->3n+1，最终将达到 1 对于任何初始 n。到目前为止，我们不知道不符合此行为的数字，但尚未证明不存在这样的数字。在我的演示中，我计算了 Hailstone 数列本身，但仅显示了达到 1 所需的迭代次数，这对于给定的初始数字 n 被称为总停止时间。对于初始 n，我取用户输入的字符的代码点与外部循环迭代次数的总和。这个总停止时间值及其对初始数字的依赖性是真正的数学奇迹之一——请阅读文章；它非常有趣。

第二个算法是一个非常简单的生成确定性伪随机数序列的算法：线性同余生成器。该算法需要三个精心选择的数字参数，我根据 Numerical Recipes 来选取。

这些算法的实现过于简单，在此不再展示；欢迎大家在可下载的源代码中查看。

为包装器分配任务

任务就是这样入队的

template<typename PARAM>
class ConveyorThreadWrapper : public ThreadWrapper {
public:
    
    // ...

    void Enqueue(TaskDelegate& task, PARAM argument) {
        std::lock_guard<std::mutex> lock(queueMutex);
        queue.push(new QueueItem(task, argument));
        queueCondition.notify_one();
    } //Enqueue

    // ...

}; //class ConveyorThreadWrapper

template<typename PARAM>
class ConveyorThreadWrapper : public ThreadWrapper {
// ...
private:

    // ...

    struct QueueItem {
        QueueItem() = default;
        QueueItem(TaskDelegate& del, PARAM param) {
            delegate = &del;
            parameter = param;
        } //QueueItem
        TaskDelegate* delegate;
        PARAM parameter;
    }; //struct QueueItem

    std::queue<QueueItem*> queue; // protected by queueState and queueMutex
    std::mutex queueMutex;
    std::condition_variable queueCondition;

    void getTask(QueueItem& itemCopy) {
        std::unique_lock<std::mutex> ul(queueMutex);
        queueCondition.wait(ul, [=] {
            return queue.size() > 0;
        });
        auto front = queue.front();
        itemCopy.delegate = front->delegate;
        itemCopy.parameter = front->parameter;
        queue.pop();
        delete front;
    } //getTask
}; //class ConveyorThreadWrapper

class ThreadWrapper {
// ...
protected:

    // ...

    static void InitializeSyncPointDelegate(SA::delegate<void(bool)>& del, ThreadWrapper* instance) {
        del = SA::delegate<void(bool)>::create<ThreadWrapper, &ThreadWrapper::SyncPoint>(instance);
    } //InitializeSyncPointDelegate

    // ...

}; //class ThreadWrapper

class ThreadWrapper {
// ...
protected:

    void Body() override final {
        while (true) {
            QueueItem task;
            getTask(task);
            try {
                (*task.delegate)(syncDelegate, task.parameter);
            } catch (ShallowThreadAbortException&) {
                SetAbort(false);
                OnCurrentTaskAborted(task.parameter);
            } //exception
        } //loop
    } //Body

    // ...

}; //class ThreadWrapper

class ThreadWrapper {
public:

    // ...

    enum class AbortDepth { currentTask, entierThread, };
    void Abort(AbortDepth depth = AbortDepth::currentTask) {
        SetAbort(true, depth == AbortDepth::currentTask);
    } //Abort

    // ...

}; //class ThreadWrapper

using SyncDelegate = SA::delegate<void(bool)>;
using TaskDelegate = SA::delegate<void(SyncDelegate&, PARAM)>;