c++ - 阻塞主线程等待它的子线程

Question

所以我有这个类:

class foo {
public:
        foo() { };
        void me1() const {
            while(1) {
                std::lock_guard<std::mutex> ldock(m);
                std::cout << 0;
            }
        }
        void me2() const {
            while(1) {
                std::lock_guard<std::mutex> ldock(m);
                std::cout << 1;
            }
        }
private:
    std::mutex m;
};

现在我想在两个不同的线程中运行这两个方法，我这样做:

int main() {

    foo myfoo;

    std::thread firstThread(&foo::me1, &myfoo);
    std::thread secondThread(&foo::me2, &myfoo);

    firstThread.detach();
    secondThread.detach();

    //while(1) { }

    return 0;
}

我不想等待这两个方法中的任何一个完成，它们将同时运行直到主线程被杀死。

在主线程末尾有某种无限循环可以吗？ (如注释的 while(1) {})。

或者我应该调用一些 sleep 函数吗？

Answer 1

您需要在 foo::me1() 和 foo::me2() 中定义一个退出条件。如果你不知道该怎么做，那

sleep(/*number of seconds you want your program to run*/ );

会做的很好。

如果您定义终止子句，那么暴力破解将是暴露类似原子的东西:

class foo {
public:

std::atomic<int> me1done = false;
std::atomic<int> me2done = false;

        foo() { };
        void me1() {
            while(/* need exit condition here*/) {
                std::lock_guard<std::mutex> ldock(m);
                std::cout << 0;
            }
            me1done = true;
        }
        void me2() {
            while(/*need exit condition here*/) {
                std::lock_guard<std::mutex> ldock(m);
                std::cout << 1;
            }
            me2done = true;
        }


private:
    std::mutex m;

};

然后您可以通过每 x 秒轮询一次来检查 main。

int main(void)
{
// start your threads and detach

foo myfoo;

std::thread firstThread(&foo::me1, &myfoo);
std::thread secondThread(&foo::me2, &myfoo);

firstThread.detach();
secondThread.detach();

while( not (myfoo.me1done and myfoo.me2done ) )
{
sleep( /* some time */);
}

return 0;
}

如果你想更详细，你将不得不使用 condition variables .