Question

我有一些std :: thread的类warper。这是构造函数：

template <typename Function, typename... Args>
InterruptibleThread(Function&& fun, Args&&... args)
{
    _thread = std::thread([](std::atomic_bool * f, Function&& function, Args&&... arguments)
    {
        _flag_ref = f;
        (function)(std::forward<Args>(arguments)...);
    },
        &_flag,
        std::forward<Function>(fun)
        , std::forward<Args>(args)...
        );
}

然后我就这样使用它（例子）： InterruptibleThread（＆amp; SourceImageList :: StartFrameProcessingStatic，this，std :: ref（it））

编译器成功构建此代码。但现在我想制作一个这样的对象的载体：

std::vector<InterruptibleThread> grp;

我想在堆栈上分配它，所以我正在做的是：

grp.emplace_back(&SourceImageList::StartFrameProcessingStatic, this, std::ref(it));

我收到了这个错误：

C2064   term does not evaluate to a function taking 0 arguments

以下是编译器验证的选项：

1) grp.push_back(new InterruptibleThread(&SourceImageList::StartFrameProcessingStatic, this, std::ref(it)));
2) grp.push_back(InterruptibleThread(&SourceImageList::StartFrameProcessingStatic, this, std::ref(it)));

但第一个是在堆上分配一个对象，所以我需要手动释放它，第二个是对象的副本。

我可以在这里使用emplace_back（编译器是MSVC 2015更新3）吗？

更新

好的，我根据答案做了一些修正。这是这个类的最终版本：

#pragma once
#include <exception>
#include <atomic>
#include <thread>
#include <future>
#include <windows.h>
// Synopsis
class InterruptThreadException;
class InterruptibleThread;

// Interrupt exception
class InterruptThreadException : public virtual std::exception {
public:
    virtual char const* what() const override { return "interrupt"; }
}; // class InterruptThreadException

   // Interruptible thread
class InterruptibleThread {
public:
static void InterruptionPoint() noexcept(false) {
    if (!InterruptibleThread::_flag_ref) { return; }
    if (!InterruptibleThread::_flag_ref->load()) { return; }

    throw InterruptThreadException();
} // check_for_interrupt

template <typename Function>
InterruptibleThread(Function&& fun) :
    _thread([this, fun = std::move(std::forward<Function>(fun))]
{
    _flag_ref = _flag.get();
    fun();
})
{}

InterruptibleThread(InterruptibleThread&&) = default;
InterruptibleThread(const InterruptibleThread&) = delete;

bool Interrupting() const { return _flag->load(); }

void Interrupt() { _flag->store(true); }

void Join()
{
    _thread.join();
}

bool TimedJoin(int msec)
{
    return (std::async([=]() {Join(); }).wait_for(std::chrono::milliseconds(msec)) != std::future_status::timeout);
}

bool Joinable()
{
    return _thread.joinable();
}

void Terminate()
{
    TerminateThread(_thread.native_handle(), -1);
}

~InterruptibleThread()
{
    if (_flag.get() != nullptr)
    {
        *_flag = false;
        Interrupt();
    }
    if (_thread.joinable())
        _thread.join()
}

private:
    static thread_local std::atomic_bool* _flag_ref;
    std::unique_ptr<std::atomic_bool> _flag = std::make_unique<std::atomic_bool>();
    std::thread _thread;
};

使用示例：

std::vector<InterruptibleThread> grp;
for (auto it : _sourceImages)
    grp.emplace_back([this, it] {
    it->StartFrameProcessing();
    it->SetImageDelay(const_cast<EngineConfig*>(GetConfig())->ImageDelay);
});

Answer 1

您可以使代码现代化并将lambda传递给InterruptibleThread，而不是传递函数及其参数（即bind-style）。

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

struct InterruptibleThread
{
    std::thread _thread;

    template <typename Function>
    InterruptibleThread(Function&& fun)
        : _thread(std::forward<Function>(fun))
    {
    }
};

struct Test
{
    std::vector<InterruptibleThread> grp;
    void test(int x) {
        grp.emplace_back([this, x]{ t1(x); }); // <==== HERE
    }
    void t1(int x) {
        std::cout << x << "\n";
    }
};

int main()
{
    Test t;
    t.test(5);
    t.grp[0]._thread.join();
}

Answer 2

我的猜测是，直接的问题是向量类试图实例化类的移动构造函数，这恰好与模板签名匹配，但却无法使用Function = InterruptibleThread, Args = {}编译正文。您需要通过显式默认移动构造函数来提供覆盖。

除此之外，还有其他几点：

如上所述，构造函数不应该使用指向成员函数和std::reference_wrapper参数的指针。（它没有在gcc下工作，我也不知道它在MSVC中是如何工作的。）
它不在代码示例中，但看起来_flag是atomic_bool类型的成员变量。这样可以防止默认的移动构造函数被实例化。

这是一个修订版，在gcc下为我编译：

#include <thread>
#include <mutex>
#include <atomic>
#include <vector>
#include <utility>

thread_local std::atomic_bool* _flag_ref;

class InterruptibleThread {
private:
  std::thread _thread;

  // Need unique_ptr instead of a directly contained atomic_bool
  // to make the object MoveConstructible.
  std::unique_ptr<std::atomic_bool> _flag;

public:
  template <typename Function, typename... Args>
  explicit InterruptibleThread(Function&& fun, Args&&... args)
  {
    _flag = std::make_unique<std::atomic_bool>();

    // Use std::bind to take care of all the details of
    // calling pointer-to-member-function or pointer-to-member-variable,
    // unwrapping std::reference_wrapper arguments, etc.
    auto bound_fun = std::bind(std::forward<Function>(fun), std::forward<Args>(args)...);

    _thread = std::thread([this, bound_fun = std::move(bound_fun)]
    {
        _flag_ref = _flag.get();
        bound_fun();
    }
        );
  }

  InterruptibleThread(InterruptibleThread&&) = default;
  InterruptibleThread(const InterruptibleThread&) = delete;
};

class Foo {
public:
  void func(int& n);
};

void test_func() {
  std::vector<InterruptibleThread> v;
  Foo f;
  int n = 5;
  v.emplace_back(&Foo::func, &f, std::ref(n));
}

使用std :: vector :: emplace_back

2 个答案: