终止读取时阻止的线程 c++11

我有以下代码：

class Foo {
private:
    std::thread thread;
    void run();
    std::atomic_flag running;
    std::thread::native_handle_type native;
public:
    Foo(const std::string& filename);
    virtual ~Foo();
    virtual void doOnChange();
    void start();
    void quit();
};
#include "Foo.h"
#include <functional>
#include <iostream>
Foo::Foo(const std::string& filename) :
        thread(), running(ATOMIC_FLAG_INIT) {
    file = filename;
    native = 0;
}
Foo::~Foo() {
    quit();
}
void Foo::start() {
    running.test_and_set();
    try {
        thread = std::thread(&Foo::run, this);
    } catch (...) {
        running.clear();
        throw;
    }
    native = thread.native_handle();
}
void Foo::quit() {
    running.clear();
    pthread_cancel(native);
    pthread_join(native, nullptr);
    //c++11-style not working here
    /*if (thread.joinable()) {
        thread.join();
        thread.detach();
    }*/
}
void Foo::run() {
   while (running.test_and_set()) {
        numRead = read(fd, buf, BUF_LEN);
        .....bla bla bla.......
   }
}

我正在尝试在我的程序清理代码中退出此线程。使用 pthread 有效，但我想知道我是否可以仅使用 c++11(没有本机句柄(做得更好。在我看来，没有使用 c++11 代码处理所有情况的好方法。正如您在此处看到的，线程在读取系统调用中被阻止。因此，即使我清除了该标志，线程仍将被阻止，加入调用将永远阻塞。所以我真正需要的是中断(在这种情况下是pthread_cancel(。但是如果我调用pthread_cancel我不能再调用 c++11 join(( 方法，因为它失败了，我只能调用 pthread_join() .所以似乎标准有一个很大的限制，我错过了什么吗？

编辑：

在下面的讨论之后，我更改了 Foo 类实现，将 std：：atomic_flag 替换为 std：：atomic 并使用信号处理程序。我使用信号处理程序是因为在我看来最好有一个通用的基类，在基类中使用自管道技巧太难了，逻辑应该委托给孩子。最终实现：

#include <thread>
#include <atomic>
class Foo {
private:
    std::thread thread;
    void mainFoo();
    std::atomic<bool> running;
    std::string name;
    std::thread::native_handle_type native;
    static void signalHandler(int signal);
    void run();
public:
    Thread(const std::string& name);
    virtual ~Thread();
    void start();
    void quit();
    void interrupt();
    void join();
    void detach();
    const std::string& getName() const;
    bool isRunning() const;
};

CPP 文件：

#include <functional>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/inotify.h>
#include <Foo.h>
#include <csignal>
#include <iostream>
Foo::Foo(const std::string& name) :
        name(name) {
    running = false;
    native = 0;
    this->name.resize(16, '');
}
Foo::~Foo() {
}
void Foo::start() {
    running = true;
    try {
        thread = std::thread(&Foo::mainFoo, this);
    } catch (...) {
        running = false;
        throw;
    }
    native = thread.native_handle();
    pthread_setname_np(native, name.c_str());
}
void Foo::quit() {
    if (running) {
        running = false;
        pthread_kill(native, SIGINT);
        if (thread.joinable()) {
            thread.join();
        }
    }
}
void Foo::mainFoo() {
 //enforce POSIX semantics
 siginterrupt(SIGINT, true);
 std::signal(SIGINT, signalHandler);
    run();
    running = false;
}
void Foo::join() {
    if (thread.joinable())
        thread.join();
}
void Foo::signalHandler(int signal) {
}
void Foo::interrupt() {
    pthread_kill(native, SIGINT);
}
void Foo::detach() {
    if (thread.joinable())
        thread.detach();
}
const std::string& Foo::getName() const {
    return name;
}
bool Foo::isRunning() const {
    return running;
}
void Foo::run() {
    while(isRunning()) {
         num = read(.....);
         //if read is interrupted loop again, this time
         //isRunning() will return false
    }
}