#include <iostream>
#include <string>
#include <functional>
#include <vector>
#include <time.h>
#include <unistd.h>
#include <pthread.h>


const int threadnum = 5;
// 新线程
void *ThreadRountine(void *args)
{
    size_t num=(size_t)args;
    while (true)
    {
        std::cout<<"i am thread"<<num<<"thread ID"<<pthread_self()<<std::endl;
        sleep(2);
    }
}
int main()
{
    std::vector<pthread_t> pthreads;
    for (size_t i = 0; i < threadnum; i++)
    {
        char threadname[64];
        snprintf(threadname, sizeof(threadname), "%s-%lu", "thread", i);

        pthread_t tid;
        pthread_create(&tid, nullptr, ThreadRountine, (void*)i);
        pthreads.push_back(tid);
        sleep(1);
    }
    std::cout << "thread id: ";
    for(const auto &tid: pthreads)
    {
        std::cout << tid << std::endl;
    }
    std::cout << std::endl;
    while (true)
    {
        std::cout << "main thread" << std::endl;
        sleep(3);
    }
}

功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数
thread:线程ID
value_ptr:它指向一个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码

我们使用这段代码来测试：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// 线程执行的函数
void* thread_function(void* arg) {
    printf("Thread start working...\n");
    sleep(5); // 模拟工作一段时间
    // 使用pthread_exit退出线程并传递一个整数作为退出状态
    pthread_exit((void*)100); // 传递100作为退出状态
}

int main() {
    pthread_t thread_id; // 线程ID
    int* exit_status=NULL; // 用于存储线程退出状态的指针

    // 创建线程
    if(pthread_create(&thread_id, NULL, thread_function, NULL) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }

    printf("Main thread continues doing other tasks...\n");

    // 等待线程结束并获取退出状态
    if(pthread_join(thread_id, (void**)&exit_status) != 0) {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }
    printf("Thread exited with status: %p\n", exit_status);
    return 0;
}

最后等待到进程：

当然，退出的返回值可以定义成任何东西，我们得到的应该是void*

要注意void不能定义变量，但是void*可以，因为void*本质是地址。

4、线程分离 

int pthread_detach(pthread_t thread);
//可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离:
pthread_detach(pthread_self());

代码示例：
我们在线程调用函数中分离这个线程：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// 线程执行的函数
void* thread_function(void* arg) {
    printf("Thread start working...\n");
    sleep(1); // 模拟工作一段时间
    // 使用pthread_exit退出线程并传递一个整数作为退出状态
    pthread_detach(pthread_self());
    pthread_exit((void*)100); // 传递100作为退出状态
    return NULL;
}

int main() {
    pthread_t thread_id; // 线程ID
    int* exit_status=NULL; // 用于存储线程退出状态的指针

    // 创建线程
    if(pthread_create(&thread_id, NULL, thread_function, NULL) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }

    printf("Main thread continues doing other tasks...\n");
    sleep(1);  //一定要先分离，在等待
    // 等待线程结束并获取退出状态
    if ( pthread_join(thread_id, NULL ) == 0 ) {
    printf("pthread wait success\n");
    } else {
    printf("pthread wait failed\n");
    }
    return 0;
}

测试的时候一定要注意先分离，再等待。

joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

Joinable线程：默认情况下，新创建的线程是joinable的。这意味着它可以在完成执行后被其他线程通过pthread_join函数等待并获取其退出状态。如果一个joinable线程结束了但没有其他线程调用pthread_join来等待它，那么它的资源（如栈空间）将不会被完全回收，直到某个线程成功调用了pthread_join。

分离（Detached）线程：分离线程在结束时会自动释放所有资源，不需要也不应该被其他线程调用pthread_join。线程可以通过调用pthread_detach(pthread_self())函数自我分离，或者在创建时通过线程属性设置为分离状态，从而成为一个分离线程。

简而言之，一旦一个线程被标记为分离（通过调用pthread_detach或创建时设置属性），它就不再是joinable的，其他线程就不能再通过pthread_join来等待它。反之，如果一个线程保持joinable状态，那么它就应该在某个时刻被其他线程通过pthread_join等待，否则可能会造成资源泄露。