應用場景：

伺服器，建立了多個服務子執行緒，而後主執行緒“無所事事”，程序會被關閉，導致子執行緒sleepA和sleepB無法正常執行完成。(假設sleepA()和sleepB()都是沉睡若干秒的函式，這個肯定要比程式執行到main結束那幾步所花費時間要長)

int main()
{
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        iRet = pthread_create(&thread_b_id,NULL,sleepB,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

}
 

想讓sleepA和sleepB能夠正常持續執行下去，程序必須賴下去——讓主執行緒不停止。低劣的做法如下：

int main()
{
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        iRet = pthread_create(&thread_b_id,NULL,sleepB,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }
while(1)
{
sleep(60);
}

}
 

提倡的做法如下：

int main()
{
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        iRet = pthread_create(&thread_b_id,NULL,sleepB,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }
        pthread_join(thread_a_id,NULL);
        pthread_join(thread_b_id,NULL);

}
 

這個方法用了pthread_join()等待指定的服務執行緒結束並釋放資源，注意，是阻塞的等待！因為不會向下執行，所以主服務得以存活。因為是阻塞的，在join a的時候就絕對不會join b了，所以如上程式碼如果b先結束，程式也不會前進，等待a結束才會向下執行。

這裡注意，預設情況新建執行緒是joinable的，可以用join，如果設定成別的，也會join不成。

============================================================================

另外，這個join之後不一定就主程序結束，這樣用就太單純了。

應用一：

比如本來要持續執行服務的子執行緒，可以pthread_join()之後再pthread_create()，這樣就能起到內部容錯和保活的作用。

int main()
{
        int iRet = 0;
        iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        printf("before join a\n");
        pthread_join(thread_a_id,NULL);
        printf("after join a\n");
        iRet = pthread_create(&thread_a1_id,NULL,sleepA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

}

但這只是想象，實際上並不能成功，問題在哪呢？

# ./a.out
before join a
sleepA called!
now sleepA over!
after join a

可以看到，程式不可能在join之後直接終結，後續流程還是要走，但是卻並沒有第二次執行sleepA()，如果只是第二次pthread_create失敗，也並沒有列印失敗。

關於id值，使用和之前相同的thread_a_id或者單獨的一個thread_a1_id結果都是一樣的不成功！

關於函式，使用sleepA或者sleepB都一樣的不成功，所以也和函式沒關係！

所以，pthread_join()之後到底算個什麼狀態？為什麼ptread_create不行了？

其實，上邊是我故意做的錯誤示範，第二次pthread_create()之後主執行緒結束了啊，缺少第二個join來阻塞住程序啊！！！！！！後根一個該id對應的join操作，解決！

# ./a.out
before join a
sleepA called!
now sleepA over!
after join a
now sleepB over!

============================================================

應用二：

但是如果再次create的程式碼在後邊新增，不能實現持續的容錯重啟，所以可以改成一個大迴圈，內部先pthread_create()，再pthread_join()阻塞，迴圈結束，再pthread_create()，再pthread_join()。。。。。。如此往復。

int main()
{
        int iRet = 0;
        while(1)
{
        iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        printf("before join a\n");
        pthread_join(thread_a_id,NULL);
        printf("after join a\n");
}

}

執行結果如下，不強制關閉不會停。

# ./a.out
before join a
sleepA called!
now sleepA over!
after join a
before join a
sleepA called!
now sleepA over!
after join a
before join a
sleepA called!
now sleepA over!
after join a
before join a
sleepA called!
now sleepA over!
after join a
before join a
sleepA called!
^C

應用三：

這個執行緒的處理還可以這樣用，在一個大迴圈內，等待訊號，有一個請求到來就新建一個執行緒單獨去處理這個請求，然後結束再回來。（這裡假設a是訊號量，是一個全域性變數，有一個單獨的執行緒傳訊號——改a的值，通過訊號量a來觸發服務sleepA）

#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_a1_id;
static pthread_t thread_b_id;
static int i = 0;
static int a = 0;
void* sleepA(void *p)
{
        printf("sleepA called!\n");
        sleep(1);
        printf("now sleepA over!\n");
        return NULL;
}
void* setA(void *p)
{
        while(1)
        {
                sleep(2);
                a = 1;
        }
        return NULL;
}
int main()
{
        int iRet = 0;
        iRet = pthread_create(&thread_b_id,NULL,setA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        while(1)
        {
        if(a == 1)
        {

                iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
                if(iRet != 0)
                {
                        printf("create failed!\n");
                }
                printf("before join a\n");
                pthread_join(thread_a_id,NULL);
                printf("after join a\n");
                a = 0;

        }
        }

}

如上，兩秒一置1，sleepA只睡1秒，還忙得過來，假如1秒一置1，sleepA睡2秒呢？睡5秒呢？程式碼變動如下

void* sleepA(void *p)
{
        printf("sleepA called!\n");
        sleep(5);
        printf("now sleepA over!\n");
        return NULL;
}
void* setA(void *p)
{
        while(1)
        {
                sleep(1);
                a = 1;
        }
        return NULL;
}

明顯會慢得多！！！因為pthread_join()是阻塞的，這樣一次只可能有一個執行緒去處理請求，不能達到想要的效果。

應用四：

這時候就不能用pthread_join()了，要用pthread_detach()，這個非阻塞，等於生完孩子就不管了，放養，最後也能回收執行緒資源（這些join和detach什麼的，主要就是等著回收資源）。

#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_a1_id;
static pthread_t thread_b_id;
static int i = 0;
static int a = 0;
void* sleepA(void *p)
{
        printf("sleepA called!\n");
        sleep(5);
        printf("now sleepA over!\n");
        return NULL;
}
void* setA(void *p)
{
        while(1)
        {
                sleep(1);
                a = 1;
        }
        return NULL;
}
int main()
{
        int iRet = 0;
        iRet = pthread_create(&thread_b_id,NULL,setA,NULL);
        if(iRet != 0)
        {
                printf("create failed!\n");
        }

        while(1)
        {
        if(a == 1)
        {

                iRet = pthread_create(&thread_a_id,NULL,sleepA,NULL);
                if(iRet != 0)
                {
                        printf("create failed!\n");
                }
                printf("before detach a\n");
                pthread_detach(thread_a_id);
                printf("after detach a\n");

                a = 0;
        }
        }

}

pthread_detach()，這個在子執行緒（pthread_self()）中和父執行緒（child_thread_id）中用法略有不同，但本質一樣，引數都是要detach的那個執行緒的id。