如何放弃或取消 std::thread

Question

我正在使用 std::threads 来实现一个生产者，它会进行一些长时间的计算，但使用的代码没有提供中止方法。但是我需要调用线程在请求​​中止后立即继续。 所以我试图通过调用 detach() 来放弃线程。思路是线程完成计算，但结果被丢弃：

#include <thread>
#include <iostream>
#include <queue>
#include <mutex>

class C
{
public:
    void spawn()
    {
        t1.swap(std::thread(&C::producer, this, 1));
    }


    void abort()
    {
        std::lock_guard<std::mutex> lk(mx);
        aborted = true;
        t1.detach();
    }

    bool tryGetResult(int &result)
    {
        std::lock_guard<std::mutex> lk(mx);
        if (!q.empty()) {
            result = q.front();
            q.pop();
            return true;
        }
        else
            return false;
    }

private:
    std::thread t1;
    std::mutex mx;
    std::queue<int> q;
    bool aborted = false;

    void producer(int id)
    {
        int i = 0;
        while (true) {
            std::lock_guard<std::mutex> lk(mx);
            if (aborted) break;
            q.push(id * 10 + i);
            i++;
        }
    }
};

int main()
{
    {
        C c;
        c.spawn();
        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
        c.abort();
    }

    std::cout << "Done...";
    std::cin.get();
}

这种方法似乎有效，但对我来说它闻起来很臭。 我不明白为什么线程不会导致访问冲突，因为它会在对象被销毁后尝试访问它。

有没有办法通知线程它已经被分离并且必须退出而不访问任何类成员。

Answer 1

t1.swap(std::thread(&C::producer, this, 1));

上面的格式不正确，因为声明了std::thread::swap：

void swap( thread& other ) noexcept;

std::thread(&C::producer, this, 1) 是一个临时的，因此是一个右值。它不能绑定到swap 的非常量左值引用。

也许你想改写t1 = std::thread(&C::producer, this, 1);。

---

我不明白为什么线程不会导致访问冲突

在对象的生命周期之外访问对象的行为是未定义的。不保证会导致访问冲突。

这样好吗

没有。

或者有没有更好的方法来实现这样的东西？

理想的解决方案视情况而定。

一个简单的解决方案是使用有状态的可调用对象来创建线程，并存储一个指向共享状态的共享指针。谁活得久，谁就活下去。如果经常访问状态，这可能会对性能产生影响。

更简单的解决方案是使用静态存储来存储共享状态。这没有共享指针可能存在的潜在性能问题，但全局状态存在其他问题。

Answer 2

在您的 C 类被销毁后，您的线程清楚地访问了数据。这是未定义的行为，因此不要依赖于此。

如果我理解正确，您希望能够在退出程序之前终止线程。这本质上是不安全的，因为当您终止线程时您不知道线程正在访问什么内存，并且您的程序很可能会处于错误状态。

终止线程的唯一正确方法是关闭线程本身。您已经在中止功能中执行此操作。这会将aborted 变量设置为true，这反过来会破坏你的线程循环并退出你的线程函数。

但与其分离你正在做的事情，不如加入线程。这将使您的主线程等到您的工作线程在您恢复之前终止。在此之后删除 C 是安全的。

Answer 3

正如接受的答案中所建议的，shared_ptr 可以提供所需的行为。 在中止情况下，shared_ptr 的寿命与最后一个被放弃的线程一样长。

#include <thread>
#include <iostream>
#include <queue>
#include <mutex>
#include <memory>

class C
{
public:
    ~C()
    {
        std::cout << "Dtor\n";
    }


    void abort()
    {
        std::lock_guard<std::mutex> lk(mx);
        aborted = true;
    }

    std::mutex mx;
    std::queue<int> q;
    bool aborted = false;

    static void staticProducer(std::shared_ptr<C> arg, int id)
    {
        arg->producer(id);
    }

    void producer(int id)
    {
        int i = 0;
        while (i<300000) {
            std::lock_guard<std::mutex> lk(mx);
            if (aborted) break;
            q.push(id * 10 + i);
            i++;
            std::cout << "Push\n";
        }
    }
};

int main()
{
    {
        std::shared_ptr<C> c = std::make_shared<C>();
        std::thread t1 = std::thread(&C::staticProducer, c, 1);

        std::this_thread::sleep_for(std::chrono::milliseconds(2000));

        // scenario 1: abort
        c->abort();
        t1.detach();

        // scenario 2: wait for completion and get result
        // t1.join();
        // std::cout << c->q.size() << "\n";
    }

    std::cout << "Done...";
    std::cin.get();
}