C++ 多线程堆栈溢出

Question

我正在尝试找出我的 C++ 应用程序中的多线程问题。

下面的处理程序在辅助线程中创建和“处理”。

struct Handler 
{
    void process(const std::vector<size_t> ops)
    {
        std::vector<size_t>::const_iterator iter = ops.cbegin();
        while( iter != ops.cend() ) {
            processOperation( op );
        }
    }

    void processOperation(std::vector<size_t>::const_iterator& iter)
    {
        size_t op = *iter;
        iter++;

        switch( op ) {
            case frame_push : { 
                processOperation( iter );
                break;
            }
            case frame_pop : { 
                return;
            }
            default : { break; }
        }
    }
};

如您在上面所见，如果当前“op”等于 frame_push，processOperation() 会递归调用自身。

我知道此处足够的递归操作会导致调用堆栈溢出。但是，当我在辅助线程而不是主线程上运行此处理程序时，这似乎发生得更快。

看来调用堆栈溢出的可能性并不是我这里唯一的问题。是否也存在重入问题？

如果有任何见解，我将不胜感激。谢谢!

Answer 1

您成功消除的第一件事是“ops”的所有权，因为您按值传递它，所以我们正在处理一个线程本地拷贝:

void process(const std::vector<size_t> ops)

然后你创建一个迭代器

std::vector<size_t>::const_iterator iter = ops.cbegin();

你可以这样写:

auto iter = ops.begin();

但是没关系。现在我们设置循环约束:

while( iter != ops.cend() ) {

然而，这在递归调用之外。所以只有当我们离开递归调用时才会检查它。

void processOperation(std::vector<size_t>::const_iterator& iter)
{
    size_t op = *iter;
    iter++;

    switch( op ) {
        case frame_push : { 
            processOperation( iter );
            break;
        }
        case frame_pop : { 
            return;
        }
        default : { break; }
    }
}

此调用中没有容器结束的代码。我猜 frame_push 和 frame_pop 是为了让您可以为您的默认情况下将被替换的任何内容创建范围，因此您需要递归。

如果这是意图，那么实现您自己的帧堆栈可能会更好。

#include <vector>
#include <iostream>
#include <thread>

enum Operands { frame_push, frame_pop, other };

struct Frame {};

struct Handler
{
    size_t maxDepth, pushCount, popCount;

    Handler() : maxDepth(0), pushCount(0), popCount(0) {}

    void handle(const std::vector<Operands> ops_)
    {
        std::vector<Frame> stack;
        stack.reserve(256);
        stack.emplace_back(); // Create a default Frame
        for (auto iter = ops_.cbegin(); iter != ops_.cend(); ++iter) {
            switch (*iter) {
                case frame_push:
                    // make a copy of the current frame,
                    // remove the 'stack.back()' if new frames should
                    // start empty
                    ++pushCount;
                    stack.emplace_back(stack.back());
                    maxDepth = std::max(maxDepth, stack.size());
                break;
                case frame_pop:
                    stack.pop_back();
                    ++popCount;
                break;
                default: {
                    Frame& frame = stack.back();
                    (void)frame;
                }
                break;
            }
        }
        std::this_thread::yield();
        std::cout << "ops len " << ops_.size()
            << ", pushCount " << pushCount
            << ", popCount " << popCount
            << ", maxDepth " << maxDepth
            << std::endl;
        std::this_thread::yield();
    }
};

int main()
{
    std::vector<Operands> ops = {
        frame_push, other, other,
            frame_push, other, frame_pop,
            other,
            frame_push, frame_pop,
            other,
            frame_push,
                frame_push, other, other, frame_pop,
            frame_pop,
        frame_pop
    };

    Handler h;
    std::thread t1(&Handler::handle, &h, ops);
    t1.join();
}

参见 http://goo.gl/dZMRDC