c++多线程 join

在C++中，join()函数用于等待一个线程完成其执行。如果一个线程被join()函数阻塞，那么它将一直等待，直到被阻塞的线程完成其执行为止。以下是一个使用join()函数的示例：

#include <iostream>
#include <thread>
using namespace std;

void test() {
    printf("test start\n");
    for (int i = 0; i < 10; i++) {
        printf("test running\n");
    }
    printf("test end\n");
}

int main(void) {
    cout << "The main start" << endl;
    thread t1(test);
    t1.join(); // 等待t1线程执行完毕
    cout << "The main end" << endl;
    return 0;
}

在上面的示例中，我们创建了一个名为t1的线程，并使用join()函数等待它完成执行。在t1线程执行完毕之前，主线程将一直被阻塞。当t1线程执行完毕后，主线程才会继续执行。

相关问题

c++ 多线程套多线程

在C++中，可以使用std::thread来创建多线程，使用std::async来异步执行任务。因此可以利用这两个工具来实现多线程套多线程的功能。

具体来说，可以在一个线程中创建多个std::thread对象，每个std::thread对象都可以执行一个任务。每个任务本身也可以是一个多线程的程序，这样就完成了多线程套多线程的功能。

例如，可以使用如下代码来创建多线程：

#include <iostream>
#include <thread>
#include <future>
#include <vector>

void task(int tid) {
    std::cout << "Thread " << tid << " started." << std::endl;
    // 这里可以编写多线程程序的代码
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; i++) {
        std::thread t(task, i);
        threads.push_back(std::move(t));
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

上述代码中创建了10个线程，每个线程执行一个任务。每个任务都是一个函数，可以在其中编写多线程程序的代码。

同时，也可以使用std::async来异步执行任务，示例代码如下：

#include <iostream>
#include <future>
#include <vector>

void task(int tid) {
    std::cout << "Thread " << tid << " started." << std::endl;
    // 这里可以编写多线程程序的代码
}

int main() {
    std::vector<std::future<void>> futures;
    for (int i = 0; i < 10; i++) {
        std::future<void> f = std::async(std::launch::async, task, i);
        futures.push_back(std::move(f));
    }
    for (auto& f : futures) {
        f.get();
    }
    return 0;
}

上述代码中使用了std::async来异步执行任务，返回的std::future对象可以用来获取任务执行的结果。

C++多线程

C++多线程可以使用标准库中的`<thread>`头文件来实现，具体操作步骤如下：

1. 定义一个线程函数：该函数将在新线程中执行。
2. 创建一个线程对象：使用该线程对象来控制和管理线程。
3. 启动线程：使用线程对象的`std::thread::start()`方法来启动线程。
4. 等待线程结束：使用线程对象的`std::thread::join()`方法来等待线程执行完毕。

以下是一个简单的示例代码：

#include <iostream>
#include <thread>

void thread_func() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(thread_func); // 创建线程对象，并指定线程函数
    t.join(); // 等待线程执行完毕
    std::cout << "Main thread finished." << std::endl;
    return 0;
}

在上面的代码中，`std::thread t(thread_func)`创建了一个线程对象，并将线程函数`thread_func`作为参数传递给它，然后调用`t.join()`等待线程执行完毕。最后输出`Main thread finished.`表示主线程结束。