std::thread vs pthead，我做错了什么？

Question

我正在做一个需要在 docker 容器内执行一些进程的项目。我想处理进程没有按时终止（比如说 10 秒内）的情况。

我正在使用这个DockerClientpp 库来管理容器，这些容器基本上只是向 Docker 套接字发出 HTTP 请求。到目前为止一切都很好。

为了停止一个耗时过长的容器，我使用了一个单独的线程。问题是我能够使用 ptheads 来实现它，但我找不到使用 std::thread 和 lambas

的方法

这是我使用 pthread 的工作实现

void *ContainerManager::spawnKiller(void *ref) {
    ContainerManager *self = (ContainerManager *)ref;
    std::unique_ptr<DockerClientpp::DockerClient> dc(new DockerClientpp::DockerClient());

    std::cout << "[slave]forceStop(): Waiting " << self->timeOut << " before stopping " << self->activeId << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(self->timeOut));
    try {
        dc->stopContainer(self->activeId);
        std::cout << "[slave]forceStop(): Container will be force-stopped" << std::endl;
    } catch(std::exception &e) {
        // container has already been destroyed
        std::cout << "[slave]forceStop(): Error => " << e.what() << std::endl;
    }
    pthread_exit(0);
}

void ContainerManager::execute() {
    pthread_t killerId;
    pthread_create(&killerId, nullptr, &(ContainerManager::spawnKiller), (void *)this);
    pthread_detach(killerId);
}

这是我的 std::thread 和 lambda 实现，一旦我尝试分离线程，SEGFAULT 就会失败。

void ContainerManager::execute() {
    std::thread([this]() {
        std::this_thread::sleep_for(std::chrono::seconds(timeOut));
        try {
            dc->stopContainer(activeId);
            std::cout << "[slave]forceStop(): Container will be force-stopped" << std::endl;
        } catch(std::exception &e) {
            // container has already been destroyed
            std::cout << "[slave]forceStop(): Error => " << e.what() << std::endl;
        }
    }).detach();
}

这就是 gdb 显示的内容

Thread 1 "test" received signal SIGSEGV, Segmentation fault.
0x0000000000000000 in ?? ()
(gdb) bt
#0  0x0000000000000000 in ?? ()
#1  0x00000000007c6801 in std::thread::detach() ()
#2  0x0000000000410785 in ContainerManager::execute (this=0x7fffffffe2a0, processName=...)
    at ../container_manager.cpp:223
#3  0x0000000000412c99 in ContainerManager::executeNew (this=0x7fffffffe2a0, processName=..., 
    replace=false, language=@0x7fffffffe020: ContainerManager::GO) at ../container_manager.cpp:336
#4  0x00000000004094a9 in main () at test.cpp:36

我尝试使用常规函数而不是lamba，我尝试捕获参数，我还尝试将参数作为参数传递，但我被卡住了。

我没有尝试使用new thread(...) 动态分配线程，但据我了解，即使std::thread 变量超出范围，线程仍然存在。

你对我做错了什么有什么建议吗？我觉得我真的错过了关于 std::thread 和 lambda 的一些东西。

execute 方法是 ContainerManager 类的一个方法，它保证在生成的线程终止之前不会超出范围，也是我使用的变量（timeOut 和 activeId 是对象的字段）

---

编辑： 看来detach()确实有问题

如果我运行这个

void ContainerManager::execute() {
    int *t = new int;
    *t = timeOut;
    std::string *s = new std::string;
    *s = activeId;
    std::thread x([&t, &s]() {
        std::cout << "LOL" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(*t));
        std::unique_ptr<DockerClientpp::DockerClient> _dc(new DockerClientpp::DockerClient());
        try {
            _dc->stopContainer(*s);
            std::cout << "[slave]forceStop(): Container will be force-stopped" << std::endl;
        } catch(std::exception &e) {
            // container has already been destroyed
            std::cout << "[slave]forceStop(): Error => " << e.what() << std::endl;
        }
    });
    std::cout << "Detaching" << std::endl;
    if(x.joinable()) {
        std::cout << ".. in a moment" << std::endl;                                                                             
        x.detach();
    }
}

我得到这个输出

Detaching
.. in a moment
Segmentation fault (core dumped)

编辑 2 我尝试在笔记本电脑上运行此代码，一切正常

void ContainerManager::execute() {
    // activeId and timeOut are fields of the ContainerManager object
    std::thread([this]() {
        std::this_thread::sleep_for(std::chrono::seconds(timeOut));
        std::unique_ptr<DockerClientpp::DockerClient> dc(new DockerClientpp::DockerClient());
        try {
            dc->stopContainer(activeId);
            std::cout << "[slave]forceStop(): Container will be force-stopped" << std::endl;
        } catch(std::exception &e) {
            // container has already been destroyed
            std::cout << "[slave]forceStop(): Error => " << e.what() << std::endl;
        }
    }).detach();
}

Answer 1

在线程中，您正在访问对变量 int *t 和 std::string *s 的引用，它们是 ContainerManager::execute() 方法的本地变量。 ContainerManager::execute() 完成后，对这两个变量的访问会导致未定义的行为，在您的情况下会导致 SEGFAULT。而是将每个值的两个指针传递给 lamdba（甚至更好：根本不要使用 new）：

void ContainerManager::execute() {
    int *t = new int;
    *t = timeOut;
    std::string *s = new std::string;
    *s = activeId;
    std::thread x([t, s]() { // <<--- Pass by value
        std::cout << "LOL" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(*t));
        std::unique_ptr<DockerClientpp::DockerClient> _dc(new DockerClientpp::DockerClient());
        try {
            _dc->stopContainer(*s);
            std::cout << "[slave]forceStop(): Container will be force-stopped" << std::endl;
        } catch(std::exception &e) {
            // container has already been destroyed
            std::cout << "[slave]forceStop(): Error => " << e.what() << std::endl;
        }
    });
    std::cout << "Detaching" << std::endl;
    if(x.joinable()) {
        std::cout << ".. in a moment" << std::endl;                                                                             
        x.detach();
    }
}

Answer 2

对我来说，段错误表明该类超出范围，即使您希望它不会。另一种可能性是您正在访问的变量存在竞争条件。

与其在 lambda 中捕获 this，不如尝试通过复制将 all 变量传递给 lambda。这将消除与范围有关的任何竞争条件，并解决任何潜在的生命周期问题，因为 lambda 将与任何其他线程完全分离。当然，这意味着没有指向其他地方的数据的指针或引用，请确保您确实在做 timeOut 和 activeId 的完整副本。

或者，我建议将线程存储为类的数据成员，而不是detach。然后，join 在析构函数中。如果线程提前结束，join 基本上是空操作。如果线程没有完成，这将防止线程正在使用的资源超出范围，直到线程完成。这将解决超出范围的变量，但不会解决任何竞争条件。竞争条件可以通过使用std::atomic 或互斥锁来解决。

由于第二种解决方案（使用join、std::atomic 和/或互斥锁）更加复杂，需要检查生命周期和竞争条件，我建议使用第一种解决方案（使用不捕获任何内容的 lambda，如果可能，所有参数都通过副本传递）。