假设您有一些无法修改的外部同步代码,您要求它异步运行,但也要求它是可取消的。如果外部代码阻塞,那么我有两个选择。
A) 欺骗用户并让我的异步方法在取消时立即返回,清楚地知道代码仍在某处运行完成。
B) 取消执行
我想为选项 B 实现一个接口(interface)
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();
}
在上面的代码中,我无法理解外部代码被阻塞的限制,如果有的话,如何才能提前取消执行?
最佳答案
简答:
除非是关键任务,否则不要取消/终止线程执行。请改用方法“A”。
长答案:
正如@Caleth 指出的那样,没有标准的或跨平台的方法可以做到这一点。您所能做的就是获取线程的 native 句柄并使用特定于平台的功能。但也有一些重要的陷阱。
win32
你可以用 TerminateThread
终止一个线程函数,但是:
- 堆栈变量不会被破坏
thread_local
变量不会被破坏- DLLs 不会被通知
MSDN 说:
TerminateThread is a dangerous function that should only be used in the most extreme cases.
线程
这里的情况稍微好一些。当 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
异常。
关于c++ - std::promise 外部代码,异步取消,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/47908271/