Question

假设您有一些无法修改的外部同步代码，并且您需要它来运行异步，但也要求它可以取消。如果外部代码阻塞，那么我有两个选择。

A）欺骗用户并让我的异步方法在取消时立即返回，并且知道代码仍然在某处运行完毕。

B）取消执行

我想为选项B

实现一个接口

namespace externallib {
std::uint64_t timeconsuming_operation()
{
    std::uint64_t count = 0;
    for (auto i = 0; i < 1E+10; ++i)
    {
        count++;
    }
    return count;
}
}




template <typename R>
struct async_operation
{

    struct CancelledOperationException
    {
        std::string what() const
        {
            return what_;
        }
    private:
        std::string what_{ "Operation was cancelled." };
    };

    template<typename Callable>
    async_operation(Callable&& c)
    {
        t_ = std::thread([this, c]()
        {
            promise_.set_value(c());  // <-- Does not care about cancel(), mostly because c() hasn't finished..
        });
    }


    std::future<R> get()
    {
        return promise_.get_future();
    }


    void cancel()
    {
        promise_.set_exception(std::make_exception_ptr(CancelledOperationException()));
    }

    ~async_operation()
    {
        if (t_.joinable())
            t_.join();
    }

private:
    std::thread t_;
    std::promise<R> promise_;
};

void foo()
{
    async_operation<std::uint64_t> op([]()
    {
        return externallib::timeconsuming_operation();
    });

    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);

    op.cancel(); 
    op.get();
}

在上面的代码中，我无法理解外部代码被阻塞的限制，如果可以的话，是否有可能提前取消执行？

Answer 1

简答：

除非关键任务，否则不要取消/终止线程执行。改为使用方法“A”。

答案很长：

正如@Caleth指出的那样，没有标准的或跨平台的方式来做到这一点。您所能做的就是获取线程的本机句柄并使用特定于平台的功能。但是有一些重要的陷阱。

的win32

您可以使用TerminateThread函数终止某个帖子，但是：

堆栈变量不会被破坏
thread_local变量不会被破坏
DLL 不会收到通知

MSDN说：

TerminateThread是一个危险的函数，只能用于最极端的情况。

并行线程

这里情况略好一些。调用pthread_cancel时，您有机会释放资源，但是：

默认情况下，目标线程终止于cancellation points。这意味着您无法取消没有任何取消点的代码。基本上，for(;;);将不会被取消。
一旦达到取消点，就会抛出特定于实现的异常，因此可以正常释放资源。
请注意，try / catch可以捕获此异常，但需要重新抛出此异常。
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, nullptr);可以禁用此行为。但是如果不满足取消点，则不会释放资源（对于 win32 ）

实施例

#include <iostream>
#include <thread>
#include <chrono>

#if defined(_WIN32)
#include <Windows.h>
void kill_thread(HANDLE thread) {
    TerminateThread(thread, 0);
}
#else 
#include <pthread.h>
void kill_thread(pthread_t thread) {
    pthread_cancel(thread);
}
#endif

class my_class {
public:
    my_class()  { std::cout << "my_class::my_class()"  << std::endl; }
    ~my_class() { std::cout << "my_class::~my_class()" << std::endl; }
};

void cpu_intensive_func() {
#if !defined(_WIN32)
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, nullptr);
#endif
    my_class cls;
    for(;;) {}
}

void io_func() {
    my_class cls;
    int a;
    std::cin >> a;
}

void io_func_with_try_catch() {
    my_class cls;
    try {
        int a;
        std::cin >> a;  
    } catch(...) {
        std::cout << "exception caught!" << std::endl;
        throw;
    }
}

void test_cancel(void (*thread_fn) (void)) {
    std::thread t(thread_fn);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    kill_thread(t.native_handle());    
    t.join();
    std::cout << "thread exited" << std::endl;
    std::cout << "--------------------" << std::endl;
}

int main() {
    test_cancel(cpu_intensive_func);
    test_cancel(io_func);
    test_cancel(io_func_with_try_catch);
    return 0;
}

你可能会看到：

从不在Windows上调用析构函数。
删除pthread_setcanceltype会导致挂起。
可以捕获内部pthread例外。

Answer 2

在它想要之前没有可移植的方式来结束线程。

根据您的平台，可能是结束线程的方法，您可能需要使用std::thread::native_handle。这极有可能导致未定义的行为，所以我不推荐它。

Answer 3

您可以在另一个进程中运行该外部同步代码并终止整个进程。这样，中断不会影响您的过程并导致未定义的行为。

std :: promise外部代码，异步取消

3 个答案:

简答：

答案很长：

的win32

并行线程

实施例