深入理解thread join

一、thread join简介

thread join是线程同步的一种机制，它能够在一个线程中等待另一个线程执行完毕之后再继续执行。

线程是计算机操作系统中最小的执行单位，如果一个进程需要同时处理多个任务，那么可以创建多个线程来同时处理任务，这减少了进程切换和创建线程的开销，提高了执行效率。

在这种多线程的情况下，为了保证任务完成的正确性，我们要考虑线程之间的同步问题，这就是thread join可以解决的问题。

二、使用thread join实现线程同步

一般情况下，主线程会创建多个子线程，这些子线程会在执行自己的任务的同时，还需要等待其他子线程执行完毕之后才能继续执行。这个时候就需要使用thread join来实现。

下面示例代码创建了三个线程，它们每个都会打印1到5，但是要求线程1必须先打印1到5，然后线程2打印1到5，最后线程3打印1到5。

#include <thread>
#include <iostream>
#include <mutex>

// 每个线程都要输出1到5，但必须保证线程1先输出，线程2其次，线程3最后
std::mutex mtx;
void printNum(int num, int threadNum) {
    for (int i = 1; i <= 5; i++) {
        // 保证每个线程输出时不会被阻塞
        std::unique_lock<std::mutex> lck(mtx);
        if (threadNum == 1) {
            std::cout << "Thread1:" << num++ << std::endl;
        } else if (threadNum == 2) {
            std::cout << "Thread2:" << num++ << std::endl;
        } else if (threadNum == 3) {
            std::cout << "Thread3:" << num++ << std::endl;
        }
    }
}

int main() {
    int num = 1;

    // 创建三个线程，并让它们输出
    std::thread t1(printNum, num, 1);
    std::thread t2(printNum, num, 2);
    std::thread t3(printNum, num, 3);

    // 等待三个线程都执行完毕
    t1.join();
    t2.join();
    t3.join();
   
    return 0;
}

在这个示例代码中，我们使用了mutex来保证多线程的安全性，同时使用了unique_lock来保证每个线程输出时不会被阻塞。最后在主线程中使用了join函数，来保证每个子线程都执行完毕之后，主线程再继续执行。

三、thread join的使用注意事项

1、注意线程的生命周期

在使用thread join的时候，一定要注意线程的生命周期，如果一个线程被join之后，就不能再次使用该线程对象进行join，否则会抛出系统异常。

#include <thread>
#include <iostream>

void hello() {
    std::cout << "Hello World!" << std::endl;
}

int main() {
    std::thread t(hello);

    // 等待线程t执行完毕
    t.join();

    // 再次等待线程t执行完毕，会抛出异常
    t.join();
   
    return 0;
}

2、join的执行顺序

如果有多个线程需要执行join操作，那么它们的执行顺序也是需要注意的。一般情况下，应该按照子线程的创建顺序依次执行join，这样才能保证主线程能够等待所有子线程都执行完毕之后再继续执行。

#include <thread>
#include <iostream>

void printNum(int num) {
    std::cout << num << std::endl;
}

int main() {
    std::thread t1(printNum, 1);
    std::thread t2(printNum, 2);
    std::thread t3(printNum, 3);

    // 等待t2线程执行完毕
    t2.join();
    // 等待t3线程执行完毕
    t3.join();
    // 等待t1线程执行完毕
    t1.join();
   
    return 0;
}

3、对于同一个线程只能调用一次join

如果对于同一个线程多次调用join函数，那么只有第一次会生效，其他的调用会被忽略。

#include <thread>
#include <iostream>

void hello(int num) {
    std::cout << "Hello World " << num << std::endl;
}

int main() {
    std::thread t(hello, 1);

    // 等待t线程执行完毕
    t.join();

    // 再次等待t线程执行完毕，会被忽略
    t.join();
   
    return 0;
}

四、总结

Thread join是线程同步的一种机制，它能够在一个线程中等待另一个线程执行完毕之后再继续执行。在使用thread join的时候，一定要注意线程的生命周期，以及join的执行顺序和对于同一个线程只能调用一次join。

使用thread join能够解决多线程竞争的问题，提高程序的可靠性和可维护性。在实际的开发过程中，我们需要根据具体的场景来决定是否需要使用thread join，以及如何使用thread join。