pthread_join和pthread_detach的用法

痛定思痛。 2022-08-21 05:52 184阅读 0赞

//从别处拷贝过来的，只作为自己查看方便，原作者不详，请谅解。  
  
一：关于join  
join  
join是三种同步线程的方式之一。另外两种分别是互斥锁（mutex）和条件变量（condition variable）。  
调用pthread\_join()将阻塞自己，一直到要等待加入的线程运行结束。  
可以用pthread\_join()获取线程的返回值。  
一个线程对应一个pthread\_join()调用，对同一个线程进行多次pthread\_join()调用是逻辑错误。  
join or detach  
线程分两种：一种可以join，另一种不可以。该属性在创建线程的时候指定。  
joinable线程可在创建后，用pthread\_detach()显式地分离。但分离后不可以再合并。该操作不可逆。  
为了确保移植性，在创建线程时，最好显式指定其join或detach属性。似乎不是所有POSIX实现都是用joinable作默认。  
  
  
二： pthread\_detach  
  
创建一个线程默认的状态是joinable, 如果一个线程结束运行但没有被join,则它的状态类似于进程中的Zombie Process,即还有一部分资源没有被回收（退出状态码），所以创建线程者应该调用pthread\_join来等待线程运行结束，并可得到线程的退出代码，回收其资源（类似于wait,waitpid)  
但是调用pthread\_join(pthread\_id)后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此，比如在Web服务器中当主线程为每个新来的链接创建一个子线程进行处理的时候，主线程并不希望因为调用pthread\_join而阻塞（因为还要继续处理之后到来的链接），这时可以在子线程中加入代码  
pthread\_detach(pthread\_self())  
或者父线程调用  
pthread\_detach(thread\_id)（非阻塞，可立即返回）  
这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源。  
  
三：pthread\_join  
调用pthread\_join的线程会阻塞，直到指定的线程返回，调用了pthread\_exit，或者被取消。  
    如果线程简单的返回，那么rval\_ptr被设置成线程的返回值，参见范例1；如果调用了pthread\_exit，则可将一个无类型指针返回，在pthread\_join中对其进行访问，参见范例2；如果线程被取消，rval\_ptr被设置成PTHREAD\_CANCELED。  
    如果我们不关心线程的返回值，那么我们可以把rval\_ptr设置为NULL。  
  
  
范例1：  
\#include <pthread.h>  
\#include <string.h>  
  
  
void \*thr\_fn1(void \*arg)  
\{  
    printf(“thread 1 returning.\\n”);  
    return((void \*)1);  
\}  
  
void \*thr\_fn2(void \*arg)  
\{  
    printf(“thread 2 exiting.\\n”);  
    return((void \*)2);  
\}  
  
int main()  
\{  
    pthread\_t tid1,tid2;  
    void \*tret;  
    pthread\_create(&tid1,NULL,thr\_fn1,NULL);  
    pthread\_create(&tid2,NULL,thr\_fn2,NULL);  
    pthread\_join(tid1,&tret);  
    printf(“thread 1 exit code %d\\n”,(int)tret);  
    pthread\_join(tid2,&tret);  
    printf(“thread 2 exit code %d\\n”,(int)tret);  
    exit(0);  
\}  
  
运行结果：  
thread 1 returning.  
thread 1 exit code 1.  
thread 2 exiting.  
thread 2 exit code 2.  
  
  
范例2：  
\#include <stdio.h>  
\#include <pthread.h>  
  
void thread1(char s\[\])  
\{  
        printf("This is a pthread1.\\n");  
        printf("%s\\n",s);  
        pthread\_exit("Hello first!");  //结束线程，返回一个值。  
\}  
  
void thread2(char s\[\])  
\{  
        printf("This is a pthread2.\\n");  
        printf("%s\\n",s);  
        pthread\_exit("Hello second!");  
\}  
  
int main(void)  
\{  
        pthread\_t id1,id2;  
        void \*a1,\*a2;  
        int i,ret1,ret2;  
        char s1\[\]="This is first thread!";  
        char s2\[\]="This is second thread!";  
        ret1=pthread\_create(&id1,NULL,(void \*) thread1,s1);  
  
        ret2=pthread\_create(&id2,NULL,(void \*) thread2,s2);  
  
        if(ret1!=0)\{  
                printf ("Create pthread1 error!\\n");  
                exit (1);  
        \}  
        pthread\_join(id1,&a1);  
  
        printf("%s\\n",(char\*)a1);  
  
        if(ret2!=0)\{  
                printf ("Create pthread2 error!\\n");  
                exit (1);  
        \}  
        printf("This is the  main process.\\n");  
        pthread\_join(id2,&a2);  
        printf("%s\\n",(char\*)a2);  
        return (0);  
\}  
  
运行结果：  
\[\*\*\*\*@XD\*\*\*\* c\]$ ./example  
This is a pthread1.  
This is first thread!  
Hello first!  
This is the main process.  
This is a pthread2.  
  
  
<参考资料语>  
  
一般情况下，进程中各个线程的运行都是相互独立的，线程的终止并不会通知，也不会影响其他线程，终止的线程所占用的资源也并不会随着线程的终止而得到释 放。正如进程之间可以用wait()系统调用来同步终止并释放资源一样，线程之间也有类似机制，那就是pthread\_join()函数  
  
pthread\_join()的调用者将挂起并等待th线程终止，retval是pthread\_exit()调用者线程（线程ID为th）的返回值，如 果thread\_return不为NULL，则\*thread\_return=retval。需要注意的是一个线程仅允许唯一的一个线程使用 pthread\_join()等待它的终止，并且被等待的线程应该处于可join状态，即非DETACHED状态  
  
如果进程中的某个线程执行了pthread\_detach(th)，则th线程将处于DETACHED状态，这使得th线程在结束运行时自行释放所占用的 内存资源，同时也无法由pthread\_join()同步，pthread\_detach()执行之后，对th请求pthread\_join()将返回错误  
  
一个可join的线程所占用的内存仅当有线程对其执行了pthread\_join()后才会释放，因此为了避免内存泄漏，所有线程的终止，要么已设为DETACHED，要么就需要使用pthread\_join()来回收  
  
3） 主线程用pthread\_exit还是return  
  
用pthread\_exit只会使主线程自身退出，产生的子线程继续执行；用return则所有线程退出。  
  
综合以上要想让子线程总能完整执行（不会中途退出），一种方法是在主线程中调用pthread\_join对其等待，即pthread\_create/pthread\_join/pthread\_exit或return；一种方法是在主线程退出时使用pthread\_exit，这样子线程能继续执行，即pthread\_create/pthread\_detach/pthread\_exit；还有一种是pthread\_create/pthread\_detach/return，这时就要保证主线程不能退出，至少是子线程完成前不能退出。现在的项目中用的就是第三种方法，主线程是一个死循环，子线程有的是死循环有的不是。  
  
<参考资料语>  
  
理论上说，pthread\_exit()和线程宿体函数退出的功能是相同的，函数结束时会在内部自动调用pthread\_exit()来清理线程相关的资源。但实际上二者由于编译器的处理有很大的不同。  
  
在进程主函数（main()）中调用pthread\_exit()，只会使主函数所在的线程（可以说是进程的主线程）退出；而如果是return，编译器将使其调用进程退出的代码（如\_exit()），从而导致进程及其所有线程结束运行。