Linux多線程編程基礎(chǔ)知識解析

前言

線程是輕量級的進程(LWP: Light Weight Process)，在Linux環(huán)境下線程的本質(zhì)仍是進程，進程是資源分配的最小單位，線程是操作系統(tǒng)調(diào)度執(zhí)行的最小單位。

解析： 進程與線程關(guān)系 ：
標(biāo)準(zhǔn)層面 ：線程是一個執(zhí)行分支，執(zhí)行粒度比進程更細，調(diào)度成本更低。線程是進程內(nèi)部的一個執(zhí)行流。
內(nèi)核層面 ：線程是CPU調(diào)度的基本單位，進程是承擔(dān)分配系統(tǒng)資源的基本實體。

拓展：
內(nèi)核角度來理解進程：承擔(dān)分配系統(tǒng)資源的基本實體，叫做進程；
在一個程序里的一個執(zhí)行路線就叫做線程（thread）。更準(zhǔn)確的定義是：線程是“一個進程內(nèi)部的控制序列”；
一切進程至少都有一個執(zhí)行線程；
線程在進程內(nèi)部運行，本質(zhì)是在進程地址空間內(nèi)運行；
在Linux系統(tǒng)中，在CPU眼中，看到的PCB都要比傳統(tǒng)的進程更加輕量化；
透過進程虛擬地址空間，可以看到進程的大部分資源，將進程資源合理分配給每個執(zhí)行流，就形成了線程執(zhí)行流。

需要明確的是，一個進程的創(chuàng)建實際上伴隨著其進程控制塊（task_struct）、進程地址空間（mm_struct）以及頁表的創(chuàng)建，虛擬地址和物理地址就是通過頁表建立映射的，如下圖：

每個進程都有自己獨立的進程地址空間和獨立的頁表，也就意味著所有進程在運行時本身就具有獨立性，但如果我們在創(chuàng)建“進程”時，只創(chuàng)建task_struct，并要求創(chuàng)建出來的task_struct和父task_struct共享進程地址空間和頁表，那么創(chuàng)建的結(jié)果就是下面這樣的：

此時創(chuàng)建的實際上就是四個線程：

其中每一個線程都是當(dāng)前進程里面的一個執(zhí)行流，也就是我們常說的“線程是進程內(nèi)部的一個執(zhí)行分支”。
線程在進程內(nèi)部運行，本質(zhì)就是線程在進程地址空間內(nèi)運行，也就是說曾經(jīng)這個進程申請的所有資源，幾乎都是被所有線程共享的。

解析：
1、進程內(nèi)的多個線程共享部分
(1) 因為多個線程在同一個地址空間，因此所謂的代碼段（Text Segment）、數(shù)據(jù)段（Data Segment）都是共享的：
如果定義一個函數(shù)，在各線程中都可以調(diào)用。
如果定義一個全局變量，在各線程中都可以訪問到。
(2) 除此之外，各線程還共享以下進程資源和環(huán)境：
文件描述符表。（進程打開一個文件后，其他線程也能夠看到）
每種信號的處理方式。（SIG_IGN、SIG_QUIT或者自定義的信號處理函數(shù)）
當(dāng)前工作目錄。（cwd）
用戶ID和組ID。
2、多個線程共享進程數(shù)據(jù)，但也擁有自己的私有數(shù)據(jù)
線程ID。
一組寄存器。（存儲每個線程的上下文信息）
棧。（每個線程都有臨時的數(shù)據(jù)，需要壓棧出棧， 各線程間的棧不共享 ）
errno。（C語言提供的全局變量，每個線程都有自己的）
信號屏蔽字。
調(diào)度優(yōu)先級。

讓我們通過一張圖概括線程與進程的包含問題：

因此，所謂的進程并不是通過task_struct來衡量的，除了task_struct之外，一個進程還必須要有進程地址空間、文件、信號等等，合起來才能稱之為一個進程。

線程是進程的一個執(zhí)行分支，是在進程內(nèi)部運行的一個執(zhí)行流，是操作系統(tǒng)進行運算調(diào)度的最小單位。線程的執(zhí)行流分為兩種：單執(zhí)行流與多執(zhí)行流，如下圖所示：

這里我們講了很多進程與線程之間的關(guān)系，接下來讓我們一起來了解一些基本概念。

一、基本概念

線程就是程序的執(zhí)行路線，它是進程內(nèi)部的控制序列，是資源的調(diào)度單位的基本單位，或者說它是進程的一部分。
線程是輕量級的，沒有自己獨立的內(nèi)存資源、代碼段、數(shù)據(jù)區(qū)、堆區(qū)、環(huán)境變量、命令行參數(shù)、文件描述符、信號處理函數(shù)、當(dāng)前目錄等資源。
線程擁有自己獨立的棧內(nèi)存，也就是有自己獨立的局部變量，還有獨立的線各ID、錯誤碼、信號掩碼。
一個進程可以同時擁有多個線程，也就是擁有多個執(zhí)行路線，其中一個叫主線程。
線程是進程的一部分，而且是負責(zé)執(zhí)行的那部分。

二、POSIX線程

POSIX線程（英語：POSIX Threads，常被縮寫為Pthreads）是POSIX的線程標(biāo)準(zhǔn)，定義了創(chuàng)建和操縱線程的一套API。

UNIX和Linux系統(tǒng)早期是沒有線程概念的，線程首先使用在windows系統(tǒng)中，后面發(fā)現(xiàn)線程有它獨特的優(yōu)勢，然后各個廠商各自提供私有的線程庫，而且接口、實現(xiàn)的差異比較大，不易移植。
在1995年制定的POSIX標(biāo)準(zhǔn)中，規(guī)定了統(tǒng)一的線程編程接口，遵循POSIX標(biāo)準(zhǔn)的線程實現(xiàn)被統(tǒng)稱為POSIX線程，也叫pthread。
pthread包含一個頭文件 pthread.h 和一個共享庫 libpthread.so。因此在編譯線程代碼時需要-lpthread參數(shù)。

三、多線程API函數(shù)

1、線程創(chuàng)建

當(dāng)一個程序啟動時，就有一個進程被操作系統(tǒng)創(chuàng)建，與此同時一個線程也立刻運行，這個線程就叫做主線程。

主線程是產(chǎn)生其他子線程的線程。
通常主線程必須最后完成某些執(zhí)行操作，比如各種關(guān)閉動作。

注意：每個線程都有唯一的線程ID，ID類型為pthread_t,可理解為：typedef unsigned long int pthread_t；本質(zhì)：在Linux下為無符號整數(shù)(%lu)，其他系統(tǒng)中可能是結(jié)構(gòu)體實現(xiàn)。多線程庫封裝現(xiàn)成的函數(shù)pthread_t pthread_self(void);供我們調(diào)用，返回當(dāng)前線程的線程ID，其作用對應(yīng)進程中 getpid() 函數(shù)。

函數(shù)pthread_create用于創(chuàng)建一個線程，詳情如下：

int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

參數(shù)說明：

pthread_t tid：線程id的類型為pthread_t，通常為無符號整型，當(dāng)調(diào)用pthread_create成功時，通過tid指針返回。
const pthread_attr_t *attr：指定創(chuàng)建線程的屬性，如線程優(yōu)先級、初始棧大小、是否為守護進程等?？梢允褂肗ULL來使用默認值，通常情況下我們都是使用默認值。
void *(*start_routine) (void *)：函數(shù)指針start_routine，指定當(dāng)新的線程創(chuàng)建之后，將執(zhí)行的函數(shù)。
void *arg：線程將執(zhí)行的函數(shù)的參數(shù)。如果想傳遞多個參數(shù)，請將它們封裝在一個結(jié)構(gòu)體中。

返回值說明：

線程創(chuàng)建成功返回0，失敗返回錯誤碼。

引用頭文件 ：#include
編譯方法 ：gcc -o <文件名> <文件名.c> -lpthread

問題：為什么連接線程庫要指明庫名？標(biāo)準(zhǔn)庫不用指明庫名？
因為標(biāo)準(zhǔn)庫是語言自帶的，第三方庫不是語言自帶的，可能是系統(tǒng)或者是用戶自己安裝的，線程庫是Linux系統(tǒng)安裝的，不是語言提供的，對于gcc編譯器來說是第三方庫。gcc默認連接庫是標(biāo)準(zhǔn)庫(語言提供的)。編譯器命令行參數(shù)中沒有第三方庫的名字。所以給編譯器指明庫名。
強調(diào) ：找到庫所在路徑和使用該路徑下的庫文件，是兩碼事。找到路徑找不到庫，還需要指明庫名。標(biāo)準(zhǔn)庫中因為編譯器命令行中有該庫名。

1）無參數(shù)線程函數(shù)創(chuàng)建線程

創(chuàng)建一個線程，線程執(zhí)行的函數(shù)的參數(shù)為NULL，源代碼如下：

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


void* thfunc(void *arg)
{
    printf("in thfuncn");
    return (void*)0;
}


int main(int argc, char* argv[])
{
    pthread_t pid;
    int ret;


    ret = pthread_create(&pid,NULL,thfunc,NULL);
    if(ret)
    {
        printf("pthread_create fail:%dn",ret);
        return -1;
    }
    sleep(1);
    printf("in main:thread is created.n");
    return 0;
}

編譯源文件，生成可執(zhí)行文件，運行如下：

[root@localhost home]# gcc -o phtread_test phtread_test.c -pthread
[root@localhost home]# 
[root@localhost home]# ls
master  phtread_test  phtread_test.c
[root@localhost home]# ./phtread_test 
in thfunc
in main:thread is created.

2）帶參數(shù)線程函數(shù)創(chuàng)建線程

創(chuàng)建一個線程，并傳遞結(jié)構(gòu)體作為參數(shù)，源代碼如下：

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


typedef struct student{
    int score;
    char *name;
}Student;


void *thfunc(void *arg){        //線程函數(shù)
    Student *p = (Student*)arg;
    printf("in thfunc:name=%s,core=%dn",p- >name,p- >score);//輸出結(jié)構(gòu)體內(nèi)容
    return (void *)0;
}


int main()
{
    pthread_t tid;
    int ret;
    Student stu;
    stu.score = 90;
    stu.name = "Qin";
    ret = pthread_create(&tid, NULL, thfunc, (void *)&stu); //創(chuàng)建線程
    if(ret){
        printf("pthread_creat failed:%dn", ret);
        return -1;
    }
    //用于等待某個線程退出，成功返回0，否則返回Exxx（為正數(shù)）
    pthread_join(tid, NULL);
    printf("in main:thread is createdn");


    return 0;
}

編譯源文件，生成可執(zhí)行文件，運行如下：

[root@localhost 0629]# gcc -o  pthread_test_arg pthread_test_arg.c -lpthread
[root@localhost 0629]# ls
pthread_test_arg  pthread_test_arg.c
[root@localhost 0629]# ./pthread_test_arg 
in thfunc:name=Qin,core=90
in main:thread is created

3）創(chuàng)建一個線程，共享進程數(shù)據(jù)

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


int global=100;


void *thfunc(void *arg){        //線程函數(shù)
    global++;
    printf("in thfunc:global=%d,n",global);
    return (void*)0;
}


int main()
{
    pthread_t tid;
    int ret;


    ret = pthread_create(&tid, NULL, thfunc, NULL); //創(chuàng)建線程
    if(ret){
        printf("pthread_creat failed:%dn", ret);
        return -1;
    }
    pthread_join(tid, NULL);        //等待子線程結(jié)束
    global++;
    printf("in main:global is:%dn",global);


    return 0;
}

編譯源文件，生成可執(zhí)行文件，運行如下：

[root@localhost share]# gcc -o pthread_test_share pthread_test_share.c -lpthread
[root@localhost share]# ./pthread_test_share 
in thfunc:global=101,
in main:global is:102

2、線程等待

Linux平臺的pthread有兩種狀態(tài)：joinable狀態(tài)和unjoinable狀態(tài)：
joinable狀態(tài)的線程，當(dāng)線程函數(shù)自己返回退出時或調(diào)用pthread_exit時都不會釋放線程所占用堆棧和線程描述符。只有當(dāng)你調(diào)用了pthread_join之后這些資源才會被釋放，因此，需要main函數(shù)或者其他線程去調(diào)用pthread_join函數(shù)。
unjoinable狀態(tài)的線程，這些資源在線程函數(shù)退出時或調(diào)用pthread_exit時會自動被釋放。設(shè)置unjoinable狀態(tài)設(shè)置有兩種辦法：一是在調(diào)用pthread_create時指定；二是子線程創(chuàng)建后在子線程中調(diào)用pthread_detach(pthread_self())分離線程自身，狀態(tài)改為unjoinable狀態(tài)，確保資源自動的釋放。

一個線程被創(chuàng)建出來默認的狀態(tài)是joinable，如果一個線程結(jié)束運行但沒有被join，則它的狀態(tài)類似于進程中的僵尸進程，即還有一部分資源沒有被回收（退出狀態(tài)碼）。所以創(chuàng)建線程者應(yīng)該調(diào)用pthread_join來等待線程運行結(jié)束，并可得到線程的退出代碼，回收其資源（類似于wait,waitpid) 。如果創(chuàng)建線程者不對新線程進行等待，那么這個新線程的資源也是不會被回收的，就會產(chǎn)生類似于“僵尸進程”的問題，也就是內(nèi)存泄漏。

函數(shù)pthread_join 用來等待子線程結(jié)束，函數(shù)會讓主線程掛起(即休眠，讓出CPU)，直到子線程退出，pthread_join能讓子線程所占資源釋放。如果子線程已經(jīng)結(jié)束，那么該函數(shù)會立即返回。

int pthread_join(pthread_t tid,void **retval);

參數(shù)說明：

tid：被等待線程的ID。
retval：retval通常設(shè)為NULL，如果不為NULL，返回被等待線程的返回值。

返回值說明：

線程等待成功返回0，失敗返回錯誤碼。

引用頭文件 ：#include

注意：pthread_join函數(shù)默認是以阻塞的方式進行線程等待的，并且指定的線程必須是joinable的。。

如下兩個Demo演示了線程創(chuàng)建出來后，沒有被join和被join的場景，即沒有調(diào)用pthread_join等待子線程運行結(jié)束和調(diào)用pthread_join等待子線程運行結(jié)束，讓我們對比看一下會發(fā)生什么。

Demo1 : 使用默認狀態(tài)，注釋掉pthread_join函數(shù)

pthread_join_default源文件如下：

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


void *thread_function(void *arg)
{
    int i;
    for (i = 0; i < 8; i++)
    {
        printf("%s:Thread working...! %d n", __FUNCTION__, i);
        sleep(1);
    }
    return NULL;
}


int main(void)
{
    pthread_t mythread;


    if (pthread_create(&mythread, NULL, thread_function, NULL))
    {
        printf("error creating thread.");
        abort();
    }
    /*
    if ( pthread_join ( mythread, NULL ) )
    {
        printf("error join thread.");
        abort();
    }
    */
    printf("%s:Thread done! n", __FUNCTION__);
    exit(0);
}

使用gcc編譯源文件，注意編譯多線程的程序，要在gcc命令尾部加上-lpthread，鏈接pthread庫。運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_join_default pthread_join_default.c -lpthread
[root@localhost 77]# ./pthread_join_default 
main:Thread done!

根據(jù)結(jié)果可知，子線程的內(nèi)容未被打印出來，因為主線程main 跑的比子線程快，子線程中 thread_function 的打印是不會打印出來的，其所占用的資源也未被回收，也就不能被復(fù)用，這就造成了資源的泄漏。

Demo2: 使用pthread_join 阻塞主線程

pthread_join()使得子線程合入主線程，主線程阻塞等待子線程結(jié)束，然后回收子線程資源。

將上述Demo 1 中的注釋放開，修改后的pthread_join_default源文件如下：

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


void *thread_function(void *arg)
{
    int i;
    for (i = 0; i < 8; i++)
    {
        printf("%s:Thread working...! %d n", __FUNCTION__, i);
        sleep(1);
    }
    return NULL;
}


int main(void)
{
    pthread_t mythread;


    if (pthread_create(&mythread, NULL, thread_function, NULL))
    {
        printf("error creating thread.");
        abort();
    }


    if ( pthread_join ( mythread, NULL ) )
    {
        printf("error join thread.");
        abort();
    }


    printf("%s:Thread done! n", __FUNCTION__);
    exit(0);
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_join_default pthread_join_default.c -lpthread
[root@localhost 77]# ./pthread_join_default 
thread_function:Thread working...! 0 
thread_function:Thread working...! 1 
thread_function:Thread working...! 2 
thread_function:Thread working...! 3 
thread_function:Thread working...! 4 
thread_function:Thread working...! 5 
thread_function:Thread working...! 6 
thread_function:Thread working...! 7 
main:Thread done!

可以看到輸出結(jié)果中子線程 thread_function 的打印。因此，使用pthread_join函數(shù)不僅可以使子線程的資源被回收，也可以使子線程的邏輯流被執(zhí)行到，從而發(fā)揮想要實現(xiàn)的作用。

通過pthread_join得到的終止?fàn)顟B(tài)是不同的。線程退出和進程退出一樣，有三種狀態(tài)：

代碼正常運行，結(jié)果正確，正常退出
代碼正常運行，結(jié)果不正確，不正常退出
代碼出現(xiàn)異常，異常退出

提示：前兩種情況以退出碼來表述退出情況，后面一種以退出信號來表示
問題：但是線程等待函數(shù)的第2個參數(shù)返回的是被等待線程執(zhí)行函數(shù)的返回值，也就是退出碼，沒有表示線程異常退出的情況，這是為什么？
答：因為某個線程如果運行異常終止，整個進程都會終止。進程異常終止，就屬于進程的等待處理的范疇了，不屬于線程范疇。比如：一個線程函數(shù)有除0操作，硬件MMU發(fā)現(xiàn)異常，操作系統(tǒng)收到異常，向該進程發(fā)出信號，終止進程。信號處理的單位是進程。

總的來說就是，被等待線程只關(guān)心正常運行的退出情況，獲取退出碼。不關(guān)心異常退出情況，異常退出情況上升至進程處理范疇。

問題：這里我們怎么獲取退出碼呢？
答：調(diào)用pthread_join函數(shù)的線程默認以阻塞方式等待線程id為tid參數(shù)的線程終止，線程以不同的方式終止，得到的終止?fàn)顟B(tài)不同：
如果線程通過return終止，pthread_join函數(shù)的第二個參數(shù)retval直接指向return后面的返回值；
如果線程通過pthread_exit終止，pthread_join函數(shù)的第二個參數(shù)retval直接指向pthread_exit參數(shù)‘；
如果線程通過被其它線程調(diào)用pthread_cancel終止，pthread_join函數(shù)的第二個參數(shù)retval直接存放的是一個常數(shù)宏P(guān)THREAD_CANCELED，值是-1。#define PTHREAD_CANCELED (void *)-1；
如果不關(guān)心返回值，可以將ret_val設(shè)為NULL。

接下來讓我們一起用實例分別說明正常退出和異常退出狀態(tài)，其中正常退出分為return、pthread_exit、pthread_cancel三種方式，異常退出則會直接終止進程。pthread_exit、pthread_cancel的詳細介紹見下文。

1）正常退出

（1）return

pthread_test.c源文件如下：

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


void  *thread1(void *arg)
{
   int num=0;
   while(1){
    sleep(1);
    num++;
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);
    if(num==5) break;
   } 
   //退出該線程
   return (void*)1;
}


int main()
{
    pthread_t tid;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    pthread_join(tid,&ret);
    printf("thread1 is quit,quit code is %dn",(unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_test pthread_test.c -lpthread
[root@localhost 77]# ./pthread_test 
main pid:5934, tid:139685158942464
thread1 pid:5934, tid:139685158942464
thread1 pid:5934, tid:139685158942464
thread1 pid:5934, tid:139685158942464
thread1 pid:5934, tid:139685158942464
thread1 pid:5934, tid:139685158942464
thread1 is quit,quit code is 1

根據(jù)程序運行結(jié)果可知，被等待線程返回退出碼1且其第二個參數(shù)ret收到返回值1。證明pthread_join函數(shù)的第二個參數(shù)ret直接指向return后面的返回值。

注意：在線程中使用return代表當(dāng)前線程退出，但是在main函數(shù)中使用return代表整個進程退出，也就是說只要主線程退出了那么整個進程就退出了，此時該進程曾經(jīng)申請的資源就會被釋放，而其他線程會因為沒有了資源，自然而然的也退出了。

問題1 ：為什么printf中直接使用ret？
答：因為返回值是void*, ret也是void*, 用ret接受的返回值。
問題2 ：為什么強轉(zhuǎn)為unsigned long?
答：因為void*是指針，指針在32位CPU下是32位尋址空間，即4字節(jié)；在64位CPU是64位尋址空間，即8字節(jié)。如果強轉(zhuǎn)成int類型可能會截斷，從而導(dǎo)致數(shù)據(jù)錯誤。而unsigned long一般跟CPU的可尋址范圍的字節(jié)長度是相等的，所以Linux內(nèi)核中有很多代碼都是用unsigned long來替代指針，用unsigned long表示的地址一般不允許引用該地址所在的內(nèi)存，如果要強制引用或者訪問這片內(nèi)存，則需要在unsigned long前面加上強制指針轉(zhuǎn)換 (char *)unsigned long。

看到這里，可能有的朋友比較疑惑，指針大小自己記得好像是和操作系統(tǒng)位數(shù)有關(guān)系的，怎么這里卻說是和CPU位數(shù)有關(guān)系呢，這里不得不拓展一點小知識。

拓展：指針的大小究竟和什么有關(guān)系？
解析：指針的大小和下面這3種均有關(guān)系，當(dāng)下述3種位數(shù)不同時，取最小的位數(shù)。
cpu位數(shù)（32位數(shù)4字節(jié)，64位數(shù)8字節(jié)）
操作系統(tǒng)位數(shù)（32位數(shù)4字節(jié)，64位數(shù)8字節(jié)）
編譯器的位數(shù)（32位數(shù)4字節(jié)，64位數(shù)8字節(jié)）
比如，如果CPU、系統(tǒng)都是64位的，但編譯器是32位的，那么很顯然指針只能是32位，即4字節(jié)大小。

（2）pthread_exit

在原pthread_test.c源文件基礎(chǔ)上，修改如下：

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


void  *thread1(void *arg)
{
   int num=0;
   while(1){
    sleep(1);
    num++;
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);
    if(num==5) break;
   } 
   //退出該線程
   //return (void*)1;
   pthread_exit((void*)1);
}


int main()
{
    pthread_t tid;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    pthread_join(tid,&ret);
    printf("thread1 is quit,quit code is %dn",(unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_test pthread_test.c -lpthread
[root@localhost 77]# ./pthread_test 
main pid:7392, tid:140455491106560
thread1 pid:7392, tid:140455491106560
thread1 pid:7392, tid:140455491106560
thread1 pid:7392, tid:140455491106560
thread1 pid:7392, tid:140455491106560
thread1 pid:7392, tid:140455491106560
thread1 is quit,quit code is 1

根據(jù)程序運行結(jié)果可知，被等待線程返回退出碼同上。證明pthread_join函數(shù)的第二個參數(shù)ret直接指向pthread_exit后面的返回值。

注意： exit函數(shù)的作用是終止進程，任何一個線程調(diào)用exit函數(shù)也代表的是整個進程終止。

（3）pthread_cancel

在（2）的pthread_test.c源文件基礎(chǔ)上，修改如下：

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


void  *thread1(void *arg)
{
   int num=0;
   while(1){
    sleep(1);
    num++;
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);
    if(num==5) break;
   } 
   //退出該線程
   //return (void*)1;
   //pthread_exit((void*)1);
}


int main()
{
    pthread_t tid;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  
    sleep(5);


    //退出線程ID為tid的線程
    pthread_cancel(tid); 


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    pthread_join(tid,&ret);
    printf("thread1 is quit,quit code is %dn",(unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_test pthread_test.c -lpthread
[root@localhost 77]# ./pthread_test 
main pid:8221, tid:139941163689728
thread1 pid:8221, tid:139941163689728
thread1 pid:8221, tid:139941163689728
thread1 pid:8221, tid:139941163689728
thread1 pid:8221, tid:139941163689728
thread1 is quit,quit code is -1

根據(jù)程序運行結(jié)果可知，被等待線程返回值是-1，證明pthread_join函數(shù)的第二個參數(shù)ret直接存放的是常數(shù)宏P(guān)THREAD_CANCELED的值。

2）異常退出

修改pthread_test.c源文件，如下：

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


void  *thread1(void *arg)
{
   int num=0;
   int b;
   b/=0;
   while(1){
    sleep(1);
    num++;
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);
    if(num==5) break;
   } 
   //退出該線程
   return (void*)1;
   //pthread_exit((void*)1);
}


int main()
{
    pthread_t tid;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  
    sleep(5);


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    pthread_join(tid,&ret);
    printf("thread1 is quit,quit code is %dn",(unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_test pthread_test.c -lpthread
pthread_test.c: 在函數(shù)‘thread1’中:
pthread_test.c:9:5: 警告：被零除 [-Wdiv-by-zero]
    b/=0;
     ^
[root@localhost 77]# ls
pthread_test  pthread_test.c
[root@localhost 77]# ./pthread_test 
main pid:8594, tid:140524144858880
浮點數(shù)異常(吐核)

根據(jù)程序運行結(jié)果可知，并沒有收集到退出碼，進程意外終止了。

3、線程退出

調(diào)用線程退出函數(shù)，當(dāng)前線程會馬上退出，不會影響其他線程的正常運行，不管是在子線程和主線程都可以使用。pthread_exit()函數(shù)一般用于線程主動終止自身的情景下。

void pthread_exit(void* retval);

參數(shù)說明：

retval: 線程退出時攜帶的數(shù)據(jù)（函數(shù)返回值），當(dāng)前子線程會得到該數(shù)據(jù)，相當(dāng)于return (void*) retval，若不需要，指定為NULL。

引用頭文件 ：#include

線程退出函數(shù)，重點需要關(guān)注的就是回收子線程數(shù)據(jù)，常用的做法是在子線程退出的時候使用pthread_exit()的參數(shù)將數(shù)據(jù)傳出，在回收這個子線程的時候通過pthread_join()的第二個參數(shù)來接受子線程傳遞出的數(shù)據(jù)。

注意：使用return和pthread_exit返回的指針?biāo)赶虻膬?nèi)存單元必須是全局或者是malloc分配的，不能是在線程函數(shù)棧上分配的，因為線程退出時，函數(shù)棧幀被釋放了。

如下讓我們通過示例來說明回收子線程數(shù)據(jù)時，錯誤的使用方法和正確的使用方法。

1）返回指向線程函數(shù)棧上分配的變量的指針

pthread_join_test.c源文件：

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


// 定義結(jié)構(gòu)體
struct Persion
{
    int id;
    char name[36];
    int age;
};


// 子線程的處理代碼
void* working(void* arg)
{
    printf("我是子線程, 線程ID: %ldn", pthread_self());
    int i;
    for(i=0; i< 9; ++i)
    {
        printf("child == i: = %dn", i);
        if(i == 6)
        {
            struct Persion p;
            p.age  = 12;
            strcpy(p.name, "Alex");
            p.id = 100;
            // 該函數(shù)的參數(shù)將這個地址傳遞給了主線程的pthread_join()
            pthread_exit(&p);
        }
    }
    return NULL;    // 代碼執(zhí)行不到這個位置就退出了
}


int main()
{
    // 1. 創(chuàng)建一個子線程
    pthread_t tid;
    pthread_create(&tid, NULL, working, NULL);


    printf("子線程創(chuàng)建成功, 線程ID: %ldn", tid);
    // 2. 子線程不會執(zhí)行下邊的代碼, 主線程執(zhí)行
    printf("我是主線程, 線程ID: %ldn", pthread_self());
    int i;
    for(i=0; i< 3; ++i)
    {
        printf("i = %dn", i);
    }


    // 阻塞等待子線程退出
    void* ptr = NULL;
    // ptr是一個傳出參數(shù), 在函數(shù)內(nèi)部讓這個指針指向一塊有效內(nèi)存
    // 這個內(nèi)存地址就是pthread_exit() 參數(shù)指向的內(nèi)存
    pthread_join(tid, &ptr);
    // 打印信息
    struct Persion* pp = (struct Persion*)ptr;
    printf("子線程返回數(shù)據(jù): name: %s, age: %d, id: %dn", pp- >name, pp- >age, pp- >id);
    printf("子線程資源被成功回收...n");


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 78]# gcc -o pthread_join_test pthread_join_test.c -lpthread
[root@localhost 78]# 
[root@localhost 78]# ./pthread_join_test 
子線程創(chuàng)建成功, 線程ID: 139867083597568
我是主線程, 線程ID: 139867091879744
i = 0
i = 1
i = 2
我是子線程, 線程ID: 139867083597568
child == i: = 0
child == i: = 1
child == i: = 2
child == i: = 3
child == i: = 4
child == i: = 5
child == i: = 6
子線程返回數(shù)據(jù): name: , age: 1481975384, id: 4
子線程資源被成功回收...

根據(jù)上述結(jié)果可知，回收子線程數(shù)據(jù)錯誤，因為子線程退出時，函數(shù)棧幀被釋放了，因此在函數(shù)中定義的局部結(jié)構(gòu)體變量中的值就變成了隨機值，所以在回收子線程數(shù)據(jù)時，絕對不能使用局部變量，必須使用全局變量或者malloc分配的變量。

2）返回指向全局變量的指針

基于pthread_join_test.c修改后的源文件如下：

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


// 定義結(jié)構(gòu)體
struct Persion
{
    int id;
    char name[36];
    int age;
};
//定義全局結(jié)構(gòu)體
struct Persion p;


// 子線程的處理代碼
void* working(void* arg)
{
    printf("我是子線程, 線程ID: %ldn", pthread_self());
    int i;
    for(i=0; i< 9; ++i)
    {
        printf("child == i: = %dn", i);
        if(i == 6)
        {
            p.age = 12;
            strcpy(p.name, "Alex");
            p.id = 100;
            // 該函數(shù)的參數(shù)將這個地址傳遞給了主線程的pthread_join()
            pthread_exit(&p);
        }
    }
    return NULL;    // 代碼執(zhí)行不到這個位置就退出了
}


int main()
{
    // 1. 創(chuàng)建一個子線程
    pthread_t tid;
    pthread_create(&tid, NULL, working, NULL);


    printf("子線程創(chuàng)建成功, 線程ID: %ldn", tid);
    // 2. 子線程不會執(zhí)行下邊的代碼, 主線程執(zhí)行
    printf("我是主線程, 線程ID: %ldn", pthread_self());
    int i=0;
    for(; i< 3; ++i)
    {
        printf("i = %dn", i);
    }


    // 阻塞等待子線程退出
    void* ptr = NULL;
    // ptr是一個傳出參數(shù), 在函數(shù)內(nèi)部讓這個指針指向一塊有效內(nèi)存
    // 這個內(nèi)存地址就是pthread_exit() 參數(shù)指向的內(nèi)存
    pthread_join(tid, &ptr);
    // 打印信息
    struct Persion* pp = (struct Persion*)ptr;
    printf("子線程返回數(shù)據(jù): name: %s, age: %d, id: %dn", pp- >name, pp- >age, pp- >id);
    printf("子線程資源被成功回收...n");


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 78]# gcc -o pthread_join_test pthread_join_test.c -lpthread
[root@localhost 78]# ./pthread_join_test 
子線程創(chuàng)建成功, 線程ID: 140373544281856
我是主線程, 線程ID: 140373552564032
i = 0
i = 1
i = 2
我是子線程, 線程ID: 140373544281856
child == i: = 0
child == i: = 1
child == i: = 2
child == i: = 3
child == i: = 4
child == i: = 5
child == i: = 6
子線程返回數(shù)據(jù): name: Alex, age: 12, id: 100
子線程資源被成功回收...

根據(jù)上述結(jié)果可知，回收子線程數(shù)據(jù)正確，因為子線程函數(shù)中使用了指向全局變量的指針傳遞返回值，因此在線程退出時，該塊內(nèi)存地址未被釋放，因此主線程中可以成功訪問該返回值。

4、線程取消

線程是可以被取消的，我們可以使用pthread_cancel函數(shù)取消某一個線程，pthread_cancel函數(shù)的函數(shù)原型如下：

int pthread_cancel(pthread_t tid);

參數(shù)說明：

tid：被取消線程的ID。

返回值說明：

線程取消成功返回0，失敗返回錯誤碼。

引用頭文件 ：#include

線程是可以取消自己的，取消成功的線程的退出碼一般是-1。雖然線程可以自己取消自己，但一般不這樣做，我們往往是用于一個線程取消另一個線程，比如主線程取消新線程。

這里我們通過一個demo來演示，pthread_cancel_test.c源文件如下：

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


void* Routine(void* arg)
{
    char* msg = (char*)arg;
    int count = 0;
    while (count < 5){
        printf("I am %s...pid: %d, ppid: %d, tid: %lun", msg, getpid(), getppid(), pthread_self());
        sleep(1);
        count++;
    }
    pthread_exit((void*)6666);
}
int main()
{
    pthread_t tid[5];
        int i;
    for (i = 0; i < 5; i++){
        char* buffer = (char*)malloc(64);
        sprintf(buffer, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine, buffer);
        printf("%s tid is %lun", buffer, tid[i]);
    }
    pthread_cancel(tid[0]);
    pthread_cancel(tid[1]);
    pthread_cancel(tid[2]);
    pthread_cancel(tid[3]);
    printf("I am main thread...pid: %d, ppid: %d, tid: %lun", getpid(), getppid(), pthread_self());
    for (i = 0; i < 5; i++){
        void* ret = NULL;
        pthread_join(tid[i], &ret);
        printf("thread %d[%lu]...quit, exitcode: %dn", i, tid[i], ret);
    }
    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 78]# gcc -o pthread_cancel_test pthread_cancel_test.c -lpthread
[root@localhost 78]# ./pthread_cancel_test 
thread 0 tid is 139921746663168
thread 1 tid is 139921738270464
thread 2 tid is 139921729877760
thread 3 tid is 139921721485056
thread 4 tid is 139921713092352
I am main thread...pid: 17667, ppid: 3835, tid: 139921754945344
I am thread 0...pid: 17667, ppid: 3835, tid: 139921746663168
thread 0[139921746663168]...quit, exitcode: -1
I am thread 4...pid: 17667, ppid: 3835, tid: 139921713092352
I am thread 3...pid: 17667, ppid: 3835, tid: 139921721485056
I am thread 2...pid: 17667, ppid: 3835, tid: 139921729877760
I am thread 1...pid: 17667, ppid: 3835, tid: 139921738270464
thread 1[139921738270464]...quit, exitcode: -1
thread 2[139921729877760]...quit, exitcode: -1
thread 3[139921721485056]...quit, exitcode: -1
I am thread 4...pid: 17667, ppid: 3835, tid: 139921713092352
I am thread 4...pid: 17667, ppid: 3835, tid: 139921713092352
I am thread 4...pid: 17667, ppid: 3835, tid: 139921713092352
I am thread 4...pid: 17667, ppid: 3835, tid: 139921713092352
thread 4[139921713092352]...quit, exitcode: 6666

此時可以發(fā)現(xiàn)，0、1、2、3號線程退出時的退出碼不是我們設(shè)置的6666，而是-1，只有未被取消的4號線程的退出碼是6666，因為只有4號進程未被取消。此外， 新線程也是可以取消主線程的 。

5、線程分離

我們知道Linux下線程默認的狀態(tài)是joinable，如果一個線程結(jié)束運行但沒有被join，則它的狀態(tài)類似于進程中的Zombie Process，即還有一部分資源沒有被回收（退出狀態(tài)碼）。因此，創(chuàng)建線程者會調(diào)用pthread_join來等待線程運行結(jié)束，并得到線程的退出代碼，回收其資源。但是調(diào)用pthread_join(pthread_id)后，如果該線程沒有運行結(jié)束，調(diào)用者會被阻塞，在有些情況下我們并不希望如此。

比如，在Web服務(wù)器中當(dāng)主線程為每個新來的鏈接創(chuàng)建一個子線程進行處理的時候，主線程并不希望因為調(diào)用pthread_join而阻塞（因為還要繼續(xù)處理之后到來的鏈接），這時可以在子線程中加入代碼pthread_detach(pthread_self())或者在父線程中調(diào)用pthread_detach(thread_id)（非阻塞，可立即返回），這會將該子線程的狀態(tài)設(shè)置為detached，則該子線程運行結(jié)束后會自動釋放所有資源。

int pthread_detach(pthread_t tid);

參數(shù)說明：

tid：被分離線程的ID。

返回值說明：

成功返回0，失敗返回錯誤碼。

引用頭文件 ：#include

注意：可以是線程組內(nèi)其它線程對目標(biāo)線程分離，也可以是線程分離自己

如果不關(guān)心返回值，我們可以告訴系統(tǒng)，將線程分離，當(dāng)線程退出后，將自動釋放線程資源 ，如下演示創(chuàng)建新線程的線程，不關(guān)心新線程的返回值，使用線程分離。

pthread_test.c源文件如下：

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


void  *thread1(void *arg)
{
    //分離該線程
    pthread_detach(pthread_self());
    sleep(1);
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);


   //退出該線程
   return (void*)1;
   //pthread_exit((void*)1);
}


int main()
{
    pthread_t tid;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  
    sleep(5);


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    pthread_join(tid,&ret);
    printf("thread1 is quit,quit code is %dn",(unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_test pthread_test.c -lpthread
[root@localhost 77]# ./pthread_test 
main pid:25180, tid:139943567070976
thread1 pid:25180, tid:139943567070976
thread1 is quit,quit code is 0

新線程返回值是1，但是實際返回的是0，說明沒有收到返回值，因為ret本來就是NULL。

雖然線程分離了，但是當(dāng)分離的線程因為異常終止，依然會導(dǎo)致進程終止，接下來讓我們通過示例來說明。

pthread_test.c源文件修改如下：

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


void  *thread1(void *arg)
{
    //分離該線程
    pthread_detach(pthread_self());
    sleep(1);
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);
    int b;
    b/=0;


   //退出該線程
   return (void*)1;
   //pthread_exit((void*)1);
}


int main()
{
    pthread_t tid;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  
    sleep(5);


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    pthread_join(tid,&ret);
    printf("thread1 is quit,quit code is %dn",(unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_test pthread_test.c -lpthread
pthread_test.c: 在函數(shù)‘thread1’中:
pthread_test.c:12:6: 警告：被零除 [-Wdiv-by-zero]
     b/=0;
      ^
[root@localhost 77]# ./pthread_test 
main pid:27154, tid:139621331527424
thread1 pid:27154, tid:139621331527424
浮點數(shù)異常(吐核)

根據(jù)上述結(jié)果可知，因為線程異常從而導(dǎo)致進程被終止。

線程設(shè)置為分離狀態(tài)時，線程主動與主控線程斷開關(guān)系。線程結(jié)束后（不會產(chǎn)生僵尸線程），其退出狀態(tài)不由其他線程獲取，而直接自己自動釋放（自己清理掉PCB的殘留資源）。網(wǎng)絡(luò)、多線程服務(wù)器常用。

進程若有該機制，將不會產(chǎn)生僵尸進程。僵尸進程的產(chǎn)生主要由于進程死后，大部分資源被釋放，一點殘留資源仍存于系統(tǒng)中，導(dǎo)致內(nèi)核認為該進程仍存在。（ 注意進程沒有這一機制 ）一般情況下，線程終止后，其終止?fàn)顟B(tài)一直保留到其它線程調(diào)用pthread_join獲取它的狀態(tài)為止（或者進程終止被回收了）。但是線程也可以被置為detach狀態(tài)，這樣的線程一旦終止就立刻回收它占用的所有資源，而不保留終止?fàn)顟B(tài)。將上述pthread_test.c源文件稍作修改如下：

#include < stdio.h >
#include < string.h >
#include < unistd.h >
#include < pthread.h >


void  *thread1(void *arg)
{
    //分離該線程
    pthread_detach(pthread_self());
    sleep(1);
    printf("thread1 pid:%d, tid:%lun",getpid(),*(pthread_t*)arg);


   //退出該線程
   //return (void*)1;
   pthread_exit((void*)1);
}


int main()
{
    pthread_t tid;
    int err;
    //創(chuàng)建線程
    pthread_create(&tid,NULL,thread1,(void*)&tid);
    printf("main pid:%d, tid:%lun",getpid(),tid);  
    sleep(5);


    //保存退出碼
    void* ret=NULL;
    //等待線程退出
    err = pthread_join(tid, &ret);
    printf("-------------err= %dn", err);
    if (err != 0)
        fprintf(stderr, "thread_join error: %sn", strerror(err));
    else
        fprintf(stderr, "thread exit code %dn", (unsigned long)ret);


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# ./pthread_test 
main pid:28886, tid:140684657252096
thread1 pid:28886, tid:140684657252096
-------------err= 22
thread_join error: Invalid argument

上述結(jié)果表明不能對一個已經(jīng)處于detach狀態(tài)的線程調(diào)用pthread_join，這樣的調(diào)用將返回EINVAL錯誤（22號錯誤）。也就是說，如果已經(jīng)對一個線程調(diào)用了pthread_detach就不能再調(diào)用pthread_join了。

6、線程信號

別被名字嚇到，pthread_kill可不是kill，而是向線程發(fā)送一個signal。還記得signal嗎，大部分signal的默認動作是終止進程的運行，所以，我們才要用signal()去抓信號并加上處理函數(shù)。

int pthread_kill(thread_t tid, int sig);

參數(shù)說明：

tid: 要發(fā)送信號的線程。
sig: 要發(fā)送的信號，0是保留信號，用來判斷線程是否還存在。

返回值說明：

成功: 返回0。
線程不存在：返回ESRCH。
信號不合法：返回EINVAL。

引用頭文件 ：#include

向指定tid的線程發(fā)送sig信號，如果線程代碼內(nèi)不做處理，則按照信號默認的行為影響整個進程，也就是說，如果你給一個線程發(fā)送了SIGQUIT，但線程卻沒有實現(xiàn)signal處理函數(shù)，則整個進程退出。

由于pthread_t類型的線程ID只在線程組內(nèi)是唯一的，其他進程完全可能存在線程ID相同的線程，所以pthread_kill只能向同一個進程的線程發(fā)送信號。

接下來通過示例演示pthread_kill的用法，pthread_kill_test.c源文件如下：

#include < stdio.h >
#include < pthread.h >
#include < signal.h >
#include < unistd.h >
#include < errno.h >


void *thrfunc(void *arg){
	int count = 50;
	while(1){
                printf("thread work:threadID=%d, count=%dn",pthread_self(),count);
		sleep(1);
		count--;
	}


	return (void*)0;
}


int main(){
	pthread_t tid;
	int ret;


	ret = pthread_create(&tid, NULL, thrfunc, NULL);
	sleep(5);
        printf("main thread:threadID=%dn",pthread_self());


	int kill_rc = pthread_kill(tid,0);
	if(kill_rc ==  ESRCH)
		printf("the specified thread did not exists or already quitn");
	else if(kill_rc == EINVAL)
		printf("signal is invalidn");
	else
		printf("the specified thread is aliven");

        pthread_join(tid, NULL);


	return 0;
}
read is aliven");


	return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_kill_test pthread_kill_test.c -lpthread
[root@localhost 77]# ./pthread_kill_test 
thread work:threadID=1648453376, count=50
thread work:threadID=1648453376, count=49
thread work:threadID=1648453376, count=48
thread work:threadID=1648453376, count=47
thread work:threadID=1648453376, count=46
main thread:threadID=1656735552
the specified thread is alive
thread work:threadID=1648453376, count=45
thread work:threadID=1648453376, count=44
thread work:threadID=1648453376, count=43
^C

根據(jù)上述運行結(jié)果可知，通過函數(shù)pthread_kill實現(xiàn)了子線程是否存活的檢測，即當(dāng)發(fā)送sig信號為0且子線程存活時，函數(shù)確實返回0。讓我們看一下當(dāng)子線程運行結(jié)束時，該函數(shù)會返回什么？修改上面pthread_kill_test.c源文件如下：

#include < stdio.h >
#include < pthread.h >
#include < signal.h >
#include < unistd.h >
#include < errno.h >


void *thrfunc(void *arg){
	int count = 5;
	while(count >0){
                printf("thread work:threadID=%d, count=%dn",pthread_self(),count);
		sleep(1);
		count--;
	}


	return (void*)0;
}


int main(){
	pthread_t tid;
	int ret;


	ret = pthread_create(&tid, NULL, thrfunc, NULL);
	sleep(10);
        printf("main thread:threadID=%dn",pthread_self());


	int kill_rc = pthread_kill(tid,0);
	if(kill_rc ==  ESRCH)
		printf("the specified thread did not exists or already quitn");
	else if(kill_rc == EINVAL)
		printf("signal is invalidn");
	else
		printf("the specified thread is aliven");

        pthread_join(tid, NULL);


	return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# vi pthread_kill_test.c
[root@localhost 77]# gcc -o pthread_kill_test pthread_kill_test.c -lpthread
[root@localhost 77]# ./pthread_kill_test 
thread work:threadID=700397312, count=5
thread work:threadID=700397312, count=4
thread work:threadID=700397312, count=3
thread work:threadID=700397312, count=2
thread work:threadID=700397312, count=1
main thread:threadID=708679488
the specified thread did not exists or already quit

根據(jù)運行結(jié)果可知，當(dāng)子線程運行結(jié)束，函數(shù)確實返回了ESRCH。由此可見，根據(jù)pthread_kill函數(shù)的返回值，我們就可以判斷線程是否存活。

接下來讓我們再通過實例演示一下pthread_kill發(fā)送其他信號給線程，源碼如下：

#include < stdio.h >
#include < unistd.h >
#include < signal.h >
#include < errno.h >
#include < pthread.h >
#include < stdlib.h >     // sleep() 函數(shù)


//signal處理函數(shù)
static void signal_handler(int sig_num)
{
    if (sig_num == SIGUSR1) {
        printf("thread quit by myown Custom Signal!n");
        (void)pthread_exit((void *)1);
    }


    return;
}


//線程執(zhí)行的函數(shù)
void * thread_Fun(void * arg) {
    if (signal(SIGUSR1, signal_handler) == SIG_ERR) {
        printf("Fail to register signaln");
    }


    printf("子線程開始執(zhí)行n");
    printf("子線程ID：%dn",pthread_self());


    while(1);
}


int main()
{
    pthread_t tid;
    int value;
    int res;
    //創(chuàng)建tid 線程
    res = pthread_create(&tid, NULL, thread_Fun, NULL);
    if (res != 0) {
        printf("線程創(chuàng)建失敗n");
        return 0;
    }
    sleep(2);


    //檢測tid線程是否存在
    int kill_rc = pthread_kill(tid, 0);
    if (kill_rc == 0) {
        printf("Child thread exists and then kill it.n");
        pthread_kill(tid, SIGUSR1);
    }


    printf("sleep.n");
    pthread_join(tid, NULL);
    sleep(3);
    printf("main exit.n");
    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_kill_quit_test pthread_kill_quit_test.c  -lpthread
[root@localhost 77]# ./pthread_kill_quit_test 
子線程開始執(zhí)行
子線程ID：607971072
Child thread exists and then kill it.
sleep.
thread quit by myown Custom Signal!
main exit.

這里通過pthread_kill發(fā)送用戶自定義信號SIGUSR1，如果不設(shè)置signal函數(shù)，默認會使進程終止，這里通過設(shè)置signal處理函數(shù)，自定義對線程的處理，即直接退出子線程。

7、線程 ID 比較

在 Linux 中線程 ID 本質(zhì)就是一個無符號長整形，因此可以直接使用比較操作符比較兩個線程的 ID，但是線程庫是可以跨平臺使用的，在某些平臺上 pthread_t 可能不是一個單純的整形，這種情況下比較兩個線程的 ID 必須要使用比較函數(shù)，該函數(shù)主要用于檢查兩個線程是否相等，函數(shù)原型如下：

int pthread_equal(pthread_t t1, pthread_t t2);

參數(shù)說明：

t1：要比較的線程的線程 ID
t2：要比較的線程的線程 ID

返回值說明：

如果兩個線程 ID 相等返回非 0 值，如果不相等返回 0

引用頭文件 ：#include

接下來讓我們通過實例演示一下pthread_equal比較兩個線程的ID是否相等，源碼如下：

#include < stdio.h > 
#include < stdlib.h > 
#include < unistd.h > 
#include < sys/types.h > 
#include < pthread.h > 

void* func_one(void* ptr) 
{ 
    int cnt=3;
    while(cnt--)
    {
       printf("thread 1ID:%dn",pthread_self());
    }
    return (void*)1;
} 

void* func_two(void* ptr) 
{ 
    printf("thread 2 ID:%dn", pthread_self());
    sleep(5); 
    return 0;
} 

int main() 
{ 
    pthread_t thread_one, thread_two; 
    // 創(chuàng)建線程一
    pthread_create(&thread_one, NULL, func_one, NULL); 
    // 創(chuàng)建線程二
    pthread_create(&thread_two, NULL, func_two, NULL); 

    // 等待線程一運行結(jié)束 
    pthread_join(thread_one, NULL); 
    // 等待線程二運行結(jié)束
    pthread_join(thread_two, NULL); 

    if(pthread_equal(thread_one,thread_two))
    {
        printf("thread 1 and thread 2 equaln");
    }
    else
    {
        printf("thread 1 and thread 2 not equaln");
    }


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# gcc -o pthread_equal_test pthread_equal_test.c -lpthread
[root@localhost 77]# ./pthread_equal_test 
thread 1ID:1515988736
thread 1ID:1515988736
thread 1ID:1515988736
thread 2 ID:1507596032
thread 1 and thread 2 not equal

根據(jù)上述輸出結(jié)果可知，這兩個線程不相等。

四、顯示進程中的線程信息

在Linux中，程序中創(chuàng)建的線程（也稱為輕量級進程，LWP）會具有和程序的PID相同的“線程組ID”，該線程即為主線程。然后，各個線程會獲得其自身的線程ID（TID）。對于Linux內(nèi)核調(diào)度器而言，線程不過是恰好共享特定資源的標(biāo)準(zhǔn)的進程而已。經(jīng)典的命令行工具，如ps或top，都可以用來顯示線程級別的信息，只是默認情況下它們顯示進程級別的信息。這里提供了在Linux上顯示某個進程的線程的幾種方式。

1、ps命令

在ps命令中，“-T”或"-L"選項可以開啟線程查看。下面的命令列出了由進程號為的進程創(chuàng)建的所有線程。

方法一：

ps -T -p < pid >

選項說明：

-T ：顯示線程，帶有SPID列。

SPID：system process id，Linux下面表示線程。

方法二：

ps -L -p < pid >

選項說明：

-L ：顯示線程，可能有LWP和NLWP列。

LWP：線程ID
NLWP：線程組內(nèi)線程的個數(shù)。

自定義進程pthread_multithread_test，其中起2個線程，源碼如下：

#include < stdio.h > 
#include < stdlib.h > 
#include < unistd.h > 
#include < sys/types.h > 
#include < pthread.h > 

void* func_one(void* ptr) 
{ 
    while(1)
    {}
    return (void*)1;
} 

void* func_two(void* ptr) 
{ 
    while(1);
    return 0;
} 

int main() 
{ 
    pthread_t thread_one, thread_two; 

    // 創(chuàng)建線程一
    pthread_create(&thread_one, NULL, func_one, NULL); 

    // 創(chuàng)建線程二
    pthread_create(&thread_two, NULL, func_two, NULL); 


    // 等待線程一運行結(jié)束 
    pthread_join(thread_one, NULL); 

    // 等待線程二運行結(jié)束
    pthread_join(thread_two, NULL); 


    return 0;
}

使用gcc編譯源文件，運行可執(zhí)行程序，如下：

[root@localhost 77]# ./pthread_multithread_test 


[master@localhost 77]$ ps -ef | grep pthread_multithread_test
root      47359   3835 99 03:12 pts/0    00:00:38 ./pthread_multithread_test
master    47422  47370  0 03:12 pts/1    00:00:00 grep --color=auto pthread_multithread_test


[master@localhost 77]$ ps -T -p 47359
   PID   SPID TTY          TIME CMD
 47359  47359 pts/0    00:00:00 pthread_multith
 47359  47360 pts/0    00:00:45 pthread_multith
 47359  47361 pts/0    00:00:46 pthread_multith

“SPID”欄表示線程ID，其中SPID為47359的線程為主線程，而“CMD”欄則顯示了線程名稱。

我們再重新運行一下pthread_multithread_test進程，使用方法二查看如下：

[master@localhost 77]$ ps -ef | grep pthread_multithread_test
root      47777   3835 99 03:18 pts/0    00:00:22 ./pthread_multithread_test
master    47789  47370  0 03:19 pts/1    00:00:00 grep --color=auto pthread_multithread_test
[master@localhost 77]$ ps -L -p 47777
   PID    LWP TTY          TIME CMD
 47777  47777 pts/0    00:00:00 pthread_multith
 47777  47778 pts/0    00:00:37 pthread_multith
 47777  47779 pts/0    00:00:37 pthread_multith

"LWP"欄表示線程ID，LWP即Light Weight Process(輕量級進程)，其中LWP為47777的線程為主線程，同樣“CMD”欄則顯示了線程名稱。

2、Top命令

top命令可以實時顯示各個線程情況。要在top輸出中開啟線程查看，請調(diào)用top命令的“-H”選項，該選項會列出所有Linux線程。在top運行時，你也可以通過按“H”鍵將線程查看模式切換為開或關(guān)。

要讓top輸出某個特定進程并檢查該進程內(nèi)運行的線程狀況，命令如下:

top -H -p < pid >

top -Hp $pid 可以查看進程pid下所有的線程列表，Shift+H （進程和線程切換顯示）

Shift+H切換至只顯示進程

Shift+H切換至顯示所有線程

3、Htop

一個對用戶更加友好的方式是，通過htop查看單個進程的線程，它是一個基于ncurses的交互進程查看器。該程序允許你在樹狀視圖中監(jiān)控單個獨立線程。

要在htop中啟用線程查看，請開啟htop，然后按來進入htop的設(shè)置菜單。選擇“設(shè)置”欄下面的“顯示選項”，然后開啟“樹狀視圖”和“顯示自定義線程名”選項。按退出設(shè)置。

現(xiàn)在，你就會看到下面這樣單個進程的線程視圖。

可以看到pthread_multithread_test進程以及其創(chuàng)建的2個線程。

4、/proc/pid/task/tid/status

Linux下面procfs文件系統(tǒng)下面的/proc/pid/status文件內(nèi)記錄進程的詳細信息，在使用時，其中pid替換成相應(yīng)進程的進程號。

[root@localhost 77]# cat /proc/51174/status
Name:	pthread_multith
State:	S (sleeping)
Tgid:	51174
Ngid:	0
Pid:	51174
PPid:	3835
TracerPid:	0
Uid:	0	0	0	0
Gid:	0	0	0	0
FDSize:	256
Groups:	0 
VmPeak:	   22840 kB
VmSize:	   22840 kB
VmLck:	       0 kB
VmPin:	       0 kB
VmHWM:	     376 kB
VmRSS:	     376 kB
RssAnon:	      80 kB
RssFile:	     296 kB
RssShmem:	       0 kB
VmData:	   16588 kB
VmStk:	     136 kB
VmExe:	       4 kB
VmLib:	    1972 kB
VmPTE:	      36 kB
VmSwap:	       0 kB
Threads:	3
SigQ:	0/7179
SigPnd:	0000000000000000
ShdPnd:	0000000000000000
SigBlk:	0000000000000000
SigIgn:	0000000000000000
SigCgt:	0000000180000000
CapInh:	0000000000000000
CapPrm:	0000001fffffffff
CapEff:	0000001fffffffff
CapBnd:	0000001fffffffff
CapAmb:	0000000000000000
Seccomp:	0
Cpus_allowed:	ffffffff,ffffffff,ffffffff,ffffffff
Cpus_allowed_list:	0-127
Mems_allowed:	00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000001
Mems_allowed_list:	0
voluntary_ctxt_switches:	2
nonvoluntary_ctxt_switches:	1

而/proc/pid/task/tid/status文件內(nèi)記錄進程中的線程的詳細信息，其中pid為進程號，tid為線程號，需要查看哪一個線程，該tid的值就切換成其相應(yīng)的值。/proc/pid/task/目錄下則保存著進程內(nèi)的線程，每個線程對應(yīng)task下的一個目錄。具體如下：

[root@localhost 77]# ps -ef | grep pthread
root      51174   3835 99 05:31 pts/0    00:00:26 ./pthread_multithread_test
root      51226  48895  0 05:31 pts/2    00:00:00 grep --color=auto pthread


//查看進程pthread_multithread_tes內(nèi)有幾個線程，task下的每個目錄表示一個線程
[root@localhost 77]# ls -l  /proc/51174/task/
總用量 0
dr-xr-xr-x 6 root root 0 7月   9 05:31 51174
dr-xr-xr-x 6 root root 0 7月   9 05:31 51175
dr-xr-xr-x 6 root root 0 7月   9 05:31 51176


//查看線程51175的詳細信息
[root@localhost 77]# cat /proc/51174/task/51175/status
Name:	pthread_multith
State:	R (running)
Tgid:	51174
Ngid:	0
Pid:	51175
PPid:	3835
TracerPid:	0
Uid:	0	0	0	0
Gid:	0	0	0	0
FDSize:	256
Groups:	0 
VmPeak:	   22840 kB
VmSize:	   22840 kB
VmLck:	       0 kB
VmPin:	       0 kB
VmHWM:	     376 kB
VmRSS:	     376 kB
RssAnon:	      80 kB
RssFile:	     296 kB
RssShmem:	       0 kB
VmData:	   16588 kB
VmStk:	     136 kB
VmExe:	       4 kB
VmLib:	    1972 kB
VmPTE:	      36 kB
VmSwap:	       0 kB
Threads:	3
SigQ:	0/7179
SigPnd:	0000000000000000
ShdPnd:	0000000000000000
SigBlk:	0000000000000000
SigIgn:	0000000000000000
SigCgt:	0000000180000000
CapInh:	0000000000000000
CapPrm:	0000001fffffffff
CapEff:	0000001fffffffff
CapBnd:	0000001fffffffff
CapAmb:	0000000000000000
Seccomp:	0
Cpus_allowed:	ffffffff,ffffffff,ffffffff,ffffffff
Cpus_allowed_list:	0-127
Mems_allowed:	00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000001
Mems_allowed_list:	0
voluntary_ctxt_switches:	0
nonvoluntary_ctxt_switches:	36154

閱讀全文

pcb(383722) pcb(383722)
Linux(206514) Linux(206514)
Linux系統(tǒng)(26842) Linux系統(tǒng)(26842)
編程(92184) 編程(92184)
多線程(19702) 多線程(19702)

Linux下線程編程

Linux下線程編程

2022-08-24 15:42:45

1682

C語言線程池的實現(xiàn)方案

這是一個簡單小巧的C語言線程池實現(xiàn)，在 Github 上有 1.1K 的 star，很適合用來學(xué)習(xí) Linux 的多線程編程。

2023-01-29 16:43:31

1110

Rust的多線程編程概念和使用方法

和字段、常見用法以及多線程的一些實踐經(jīng)驗。由淺入深帶你零基礎(chǔ)玩轉(zhuǎn)Rust的多線程編程。線程的基本概念和使用方法 Thread是Rust中并發(fā)編程的一種基本方式。Rust中的Thread使用標(biāo)準(zhǔn)

2023-09-20 11:15:51

407

Java多線程的用法

本文將介紹一下Java多線程的用法。基礎(chǔ)介紹什么是多線程 指的是在一個進程中同時運行多個線程，每個線程都可以獨立執(zhí)行不同的任務(wù)或操作。與單線程相比，多線程可以提高程序的并發(fā)性和響應(yīng)

2023-09-30 17:07:00

561

LabVIEW多線程編程解析 LabVIEW的VI優(yōu)先級和并行循環(huán)等相關(guān)知識

軟件開發(fā)過程中總會遇到需要多線程同步運行的情況，尤其是一些復(fù)雜的測試系統(tǒng)和大型項目，僅靠單線程運行的程序是遠遠無法滿足用戶需求的，甚至可以說在復(fù)雜測試系統(tǒng)的軟件開發(fā)中，多線程運行是最基本的。

2023-11-10 10:20:44

3206

Linux c多線程編程的4個實例

Linux中最流行的線程機制為LinuxThreads，下面以一個多線程編程實例來介紹該線程庫的編程接口：　　示例1:線程的創(chuàng)建和退出，等待線程結(jié)束和獲取線程的返回值　　#include

2018-10-17 09:32:16

Linux c多線程編程的4個實例分享

Linux c多線程編程的4個實例　　在主流的操作系統(tǒng)中，多任務(wù)一般都提供了進程和線程兩種實現(xiàn)方式，進程享有獨立的進程空間，而線程相對于進程來說是一種更加輕量級的多任務(wù)并行，多線程之間一般都是共享

2020-06-09 04:35:40

Linux多線程編程手冊

Linux多線程編程手冊

2016-11-07 10:17:40

Linux多線程及線程間同步

這兩個函數(shù)的參數(shù)。/* 是否熟悉POSIX多線程編程技術(shù)？如熟悉，編寫程序完成如下功能： 1）有一int型全局變量g_Flag初始值為0； 2）在主線稱中起動線程1，打印

2017-12-08 14:14:06

Linux下多線程編程總結(jié)

最近研究MySQL源碼，各種鎖，各種互斥，好在我去年認真學(xué)了《unix環(huán)境高級編程》，雖然已經(jīng)忘得差不多了，但是學(xué)過始終是學(xué)過，拿起來也快。寫這篇文章的目的就是總結(jié)Linux 下多線程編程，作為日后的參考資料。

2019-07-23 08:17:14

Linux下C語言編程基礎(chǔ)知識

Linux下C語言編程基礎(chǔ)知識

2012-08-20 17:21:36

Linux操作系統(tǒng)-C語言編程入門介紹在LINUX 下進行C 語言編程所需要的基礎(chǔ)知識.在這篇

Linux操作系統(tǒng)-C語言編程入門介紹在LINUX 下進行C 語言編程所需要的基礎(chǔ)知識.在這篇文章當(dāng)中,我們將會學(xué)到以下內(nèi)容：?? 源程序編譯?? Makefile 的編寫?? 程序庫的鏈接

2008-12-08 09:56:41

Linux的基礎(chǔ)知識和命令

Linux基礎(chǔ)知識和命令

2020-06-14 06:39:13

Linux系統(tǒng)編程重點學(xué)習(xí)標(biāo)準(zhǔn)I/O庫

Makefile腳本編寫等知識，嵌入式開發(fā)環(huán)境的搭建。3Linux系統(tǒng)編程重點學(xué)習(xí)標(biāo)準(zhǔn)I/O庫，Linux多任務(wù)編程中的多進程和多線程，以及進程間通信(pipe、FIFO、消息隊列、共享內(nèi)存、signal、信號量等)，同步與互斥對共享資源訪問控制等重要知識，主要提升對L

2021-12-15 06:45:15

linux 下如何獲取線程ID

)，Linux在早期內(nèi)核不支持線程的時候glibc就在庫中（用戶態(tài)）以纖程（就是用戶態(tài)線程）的方式支持多線程了，POSIX thread只要求了用戶編程的調(diào)用接口對內(nèi)核接口沒有要求。linux上的線程實現(xiàn)就是在內(nèi)核支持的基礎(chǔ)上以POSIX thread的方式對外封裝了接口，所以才會有兩個ID的問題。

2019-07-09 08:36:48

linux線程同步方法

最近研究mysql源碼，各種鎖，各種互斥，好在我去年認真學(xué)了《unix環(huán)境高級編程》，雖然已經(jīng)忘得差不多了，但是學(xué)過始終是學(xué)過，拿起來也快。寫這篇文章的目的就是總結(jié)linux 下多線程編程，作為日后的參考資料。

2019-08-06 06:15:28

linux下多線程編程中，一次等待多個信號量怎么解決

linux下多線程（非進程）編程中，一次等待多個信號量怎么解決？并且等到信號量來了后，能判斷是那一個?功能如同window下waitformultipleobjects()函數(shù)，一次就可以等待多個信號量。在linux下多線程編程，linux 下sem_wait()一次只能等待一個信號量。

2020-06-17 05:55:57

多線程編程之一：問題提出

多線程編程之一問題提出編寫一個耗時的單線程程序：　　新建一個基于對話框的應(yīng)用程序SingleThread，在主對話框IDD_SINGLETHREAD_DIALOG添加一個按鈕，ID為

2008-10-22 11:41:12

多線程編程之三線程間通訊

多線程編程之三線程間通訊七、線程間通訊　　一般而言,應(yīng)用程序中的一個次要線程總是為主線程執(zhí)行特定的任務(wù),這樣,主線程和次要線程間必定有一個信息傳遞的渠道,也就是主線程和次要線程間要進行通信。這種

2008-10-22 11:43:09

多線程編程之四線程的同步

多線程編程之四線程的同步八、線程的同步　　雖然多線程能給我們帶來好處，但是也有不少問題需要解決。例如，對于像磁盤驅(qū)動器這樣獨占性系統(tǒng)資源，由于線程可以執(zhí)行進程的任何代碼段，且線程的運行是由系統(tǒng)調(diào)度

2008-10-22 11:43:42

LabView的多線程語言

Thread），用于處理界面刷新，用戶的操作等；還有一個執(zhí)行線程，后臺工作。2。LabVIEW 是自動多線程的編程語言，只要 VI 的代碼可以并行執(zhí)行，LabVIEW 就會將它們分配在多個執(zhí)行線程內(nèi)同時運行。3

2009-06-08 10:13:49

Multi-Threaded多線程編程

C++ 多線程（一）Multi-Threaded多線程編程術(shù)語線程更確切地說，是執(zhí)行線程，它是最小的處理單元。由操作系統(tǒng)調(diào)度。通常它包含在進程中。因此，同一個進程中可以存在多個線程。它與進程共享資源

2021-08-24 08:31:05

OpenHarmony代碼編程-多線程

材料準(zhǔn)備: 需要準(zhǔn)備一塊搭載hi3861芯片的開發(fā)板, 并事先燒錄好linkboy for OpenHarmony的引擎固件.案例說明: 本案例展示如何在OpenHarmony開發(fā)板上編寫多線程

2021-12-03 16:36:29

Python多線程編程原理

Python多線程類似于同時執(zhí)行多個不同程序，但其執(zhí)行過程中和進程還是有區(qū)別的，每個獨立的線程有一個程序運行的入口、順序執(zhí)行序列和程序的出口，但是線程不能夠獨立執(zhí)行，必須依存在應(yīng)用程序中，由應(yīng)用程序

2018-11-22 14:01:58

WiFi基礎(chǔ)知識解析

一、wifi基礎(chǔ)1、詳細見如下鏈接（1）WiFi基礎(chǔ)知識解析（2）WiFi基本知識（3）11種物聯(lián)網(wǎng)協(xié)議簡介，如WiFi、藍牙、ZigBee、蜂窩等二、wifi模塊淺析1、WiFi模塊淺析三

2021-08-05 08:10:22

labview2011自動多線程實例

提供一個簡單的實例，讓大家體驗到labview多線程編程的優(yōu)點和labview實現(xiàn)自動多線程的強大功能。

2014-10-06 10:06:08

labview多線程編程

子曰：何為labview多線程編程？

2015-03-11 15:46:07

　如何學(xué)習(xí)嵌入式系統(tǒng)之基礎(chǔ)知識？多年項目經(jīng)驗分享

、嵌入式系統(tǒng)中多線程程序設(shè)計　　線程的基礎(chǔ)知識：多線程編程方法，線程應(yīng)用中的同步問題了解線程的概念，能夠編寫簡單的多線程程序編寫一個多線程程序。　　9、嵌入式 Linux 網(wǎng)絡(luò)編程　　網(wǎng)絡(luò)基礎(chǔ)知識

2015-03-11 14:15:55

【分享】4412開發(fā)板-嵌入式Linux開發(fā)需要掌握的基礎(chǔ)知識和技能

系統(tǒng)中多線程程序設(shè)計線程的基礎(chǔ)知識 多線程編程方法線程應(yīng)用中的同步問題了解線程的概念能夠編寫簡單的多線程程序編寫一個多線程程序9、嵌入式 Linux 網(wǎng)絡(luò)編程網(wǎng)絡(luò)基礎(chǔ)知識 嵌入式Linux中TCP

2015-07-16 14:08:08

初學(xué)者嵌入式linux系統(tǒng)的學(xué)習(xí)步驟

方式熟悉嵌入式Linux中的任務(wù)間同步與通信編寫一個簡單的管道程序?qū)崿F(xiàn)文件傳輸編寫一個使用共享內(nèi)存的程序8、嵌入式系統(tǒng)中多線程程序設(shè)計線程的基礎(chǔ)知識 多線程編程方法線程應(yīng)用中的同步問題了解線程

2019-01-18 10:34:44

利用線程的互斥實現(xiàn)串口多線程收發(fā)數(shù)據(jù)

利用線程的互斥實現(xiàn)串口多線程收發(fā)數(shù)據(jù)從而達到流水燈的效果。多線程串口編程主要分為三步，第一部分，連接串口及開發(fā)板，確定設(shè)備號；第二部分為串口參數(shù)的設(shè)置；第三部分為多線程數(shù)據(jù)的收發(fā)。下方有完整代碼實現(xiàn)

2022-01-07 08:08:26

多核CPU下的多線程編程

多線程編程是現(xiàn)代軟件技術(shù)中很重要的一個環(huán)節(jié)。要弄懂多線程，這就要牽涉到多進程？當(dāng)然，要了解到多進程，就要涉及到操作系統(tǒng)。不過大家也不要緊張，聽我慢慢道來。這其中的環(huán)節(jié)其實并不復(fù)雜。（1）單

2016-12-26 15:17:24

如何去設(shè)計一個linux嵌入式UI框架呢

，linux 基礎(chǔ)知識、如消息隊列、framebuffer、多線程、多線程同步、等，數(shù)據(jù)結(jié)構(gòu)、算法（如鏈表、隊列等），window .netframework 框架設(shè)計思想，設(shè)計模式如 mvc、觀...

2021-11-08 07:22:46

如何學(xué)習(xí)嵌入式系統(tǒng)基礎(chǔ)知識

個多線程程序。9、 Linux 網(wǎng)絡(luò)編程網(wǎng)絡(luò)基礎(chǔ)知識：Linux中TCP/IP網(wǎng)絡(luò)結(jié)構(gòu)，socket編程 ,常用API函數(shù)，分析Ping命令的實現(xiàn)，基本UDP套接口編程，許可證管理 PPP協(xié)議GPRS

2017-09-13 10:53:41

如何學(xué)習(xí)嵌入式系統(tǒng)基礎(chǔ)知識

解線程的概念，能夠編寫簡單的多線程程序編寫一個多線程程序。9、 Linux 網(wǎng)絡(luò)編程網(wǎng)絡(luò)基礎(chǔ)知識：Linux中TCP/IP網(wǎng)絡(luò)結(jié)構(gòu)，socket編程 ,常用API函數(shù)，分析Ping命令的實現(xiàn)，基本UDP

2017-09-13 11:04:17

如何學(xué)習(xí)嵌入式系統(tǒng)之基礎(chǔ)知識

實現(xiàn)文件傳輸，編寫一個使用共享內(nèi)存的程序。8、系統(tǒng)中多線程程序設(shè)計線程的基礎(chǔ)知識：多線程編程方法，線程應(yīng)用中的同步問題了解線程的概念，能夠編寫簡單的多線程程序編寫一個多線程程序。9、 Linux 網(wǎng)絡(luò)

2017-04-26 14:22:09

如何對Linux系統(tǒng)多線程進行編程呢

Linux系統(tǒng)編程第07期：多線程編程入門 6年嵌入式開發(fā)經(jīng)驗，在多家半導(dǎo)體...

2021-12-23 08:08:42

如何弄懂多核CPU下的多線程？

多核CPU下的多線程編程原來是這么回事...

2021-04-02 07:09:07

嵌入式Linux多線程編程

嵌入式Linux多線程編程-學(xué)習(xí)資源-華清遠見清遠見嵌入式學(xué)院：清遠見嵌入式學(xué)院：《嵌入式應(yīng)用程序設(shè)計》——第5 章嵌入式Linux 多線程編程第5 章嵌入式Linux 多線程編程本章

2021-11-05 06:54:35

嵌入式linux的main中多線程怎么實現(xiàn)周期性執(zhí)行？

求助：我有三個問題1、嵌入式linux的main中多線程怎么實現(xiàn)周期性執(zhí)行？2、嵌入式linux的main中進程怎么實現(xiàn)周期性執(zhí)行？3、嵌入式linux的main中有沒有觸發(fā)性的線程或者進程？希望那個大神給解答一下！謝謝

2014-03-03 11:27:12

淺談多進程多線程的選擇

問題，那就沒有這么簡單了，選的不好，會讓你深受其害。經(jīng)常在網(wǎng)絡(luò)上看到有的XDJM問“多進程好還是多線程好？”、“Linux下用多進程還是多線程？”等等期望一勞永逸的問題，我只能說：沒有最好，只有更好。根據(jù)實際...

2021-08-24 07:38:57

請問如何使用多線程？

如何使用多線程

2020-11-10 08:08:25

C++ 面向?qū)ο?b class="flag-6" style="color: red">多線程編程下載

2006-04-08 02:14:12

C++面向?qū)ο?b class="flag-6" style="color: red">多線程編程 (pdf電子版)

C++面向?qū)ο?b class="flag-6" style="color: red">多線程編程共分13章，全面講解構(gòu)建多線程架構(gòu)與增量多線程編程技術(shù)。第1章介紹了

2008-09-25 09:39:36

java多線程編程實例 (源程序）

java多線程編程實例 import java.awt.*;import javax.swing.*; public class CompMover extends Object {

2008-10-22 11:48:13

linux下c語言編程pdf

linux下c語言編程內(nèi)容為：:基礎(chǔ)知識,進程介紹,文件操作,時間概念,信號處理,消息管理,線程操作,網(wǎng)絡(luò)編程,Linux 下C 開發(fā)工具介紹。

2008-12-08 10:00:24

利用多線程思想實現(xiàn)單片機系統(tǒng)的偽并行處理

介紹和分析了一種原用于計算機高級語言的編程思想---多線程編程，向單片機控制系統(tǒng)的移植。利用多線程的編程思想進行單片機的復(fù)雜控制，可以應(yīng)用到一些對系統(tǒng)控制有苛刻

2009-08-07 09:09:48

QNX環(huán)境下多線程編程

介紹了QNX 實時操作系統(tǒng)和多線程編程技術(shù)，包括線程間同步的方法、多線程程序的分析步驟、線程基本程序結(jié)構(gòu)以及實用編譯方法。QNX 是由加拿大QNX 軟件有限系統(tǒng)公司開發(fā)的

2009-08-12 17:37:19

LINUX系統(tǒng)下多線程與多進程性能分析

采用多進程處理多個任務(wù)，會占用很多系統(tǒng)資源（主要是CPU 和內(nèi)存的使用）。在LINUX 中，則對這種弊端進行了改進，在用戶態(tài)實現(xiàn)了多線程處理多任務(wù)。本文系統(tǒng)論述了多線程間

2009-08-13 08:31:15

多線程在VC++串口通信程序中的應(yīng)用

本文通過一機房監(jiān)控系統(tǒng)程序中串口通信對多線程的應(yīng)用來介紹Windows 9X/NT操作系統(tǒng)中多線程的應(yīng)用和VC++對多線程的支持。關(guān)健詞： 多線程，串口通信在現(xiàn)代的各種實時監(jiān)控系

2009-09-03 11:45:29

數(shù)控測井軟件中的多線程編程技術(shù)

為滿足實時測井需求，提高系統(tǒng)資源的利用率和系統(tǒng)性能，在數(shù)控測井軟件開發(fā)中將多線程編程技術(shù)應(yīng)用其中，并對多線程編程技術(shù)應(yīng)用的可行性和必要性進行了分析。給出了軟件的模塊框圖及多線程間關(guān)系，利用MFC的自定義類封裝和實現(xiàn)各個線程，在線程中分別實現(xiàn)串

2011-01-14 17:17:15

linux多線程編程課件

電子發(fā)燒友為您提供了linux多線程編程課件，希望對您學(xué)習(xí) linux 有所幫助。部分內(nèi)容如下： *1、多線程模型在單處理器模型和多處理器系統(tǒng)上，都能改善響應(yīng)時間和吞吐量。 *2、線程包

2011-07-10 11:58:43

Java知識：多線程編程示例#Java

JAVA多線程

學(xué)習(xí)電子發(fā)布于 2022-11-16 01:45:07

內(nèi)存模型-多線程內(nèi)存模型

為什么在C里面要想順暢地進行多線程編程需要對標(biāo)準(zhǔn)進行修訂(而不僅僅是通過現(xiàn)有多線程庫如POSIX、boost.Thread即可)呢？對此Hans Boehm在他著名超級晦澀難懂paperThreads Cannot beImplemented as

2011-07-25 15:24:12

linux多線程編程開發(fā)

本文中我們針對 Linux 上多線程編程的主要特性總結(jié)出 5 條經(jīng)驗，用以改善 Linux 多線程編程的習(xí)慣和避免其中的開發(fā)陷阱。在本文中，我們穿插一些 Windows 的編程用例用以對比 Linux 特性

2011-12-26 14:24:44

MFC下的多線程編程

計算機上的上位機制作工具語言之MFC下的多線程編程

2016-09-01 14:55:49

VC-MFC多線程編程詳解

VC編程中關(guān)于 MFC多線程編程的詳解文檔

2016-09-01 15:01:52

Windows多線程編程入門講解

計算機上的上位機制作工具語言之Windows多線程編程入門講解，感興趣的可以看看。

2016-09-01 15:27:27

Windows多線程編程

計算機上的上位機制作工具語言之Windows多線程編程，感興趣的可以看看。

2016-09-01 15:27:27

linux+Android基礎(chǔ)知識總結(jié)

linux+Android基礎(chǔ)知識總結(jié)

2017-03-19 11:23:20

Linux下多線程的視頻圖像平滑度評價算法_饒鴻

Linux下多線程的視頻圖像平滑度評價算法_饒鴻

2017-03-19 11:27:34

多線程與聊天室程序的創(chuàng)建

多線程程序的編寫，多線程應(yīng)用中容易出現(xiàn)的問題?；コ鈱ο蟮闹v解，如何采用互斥對象來實現(xiàn)多線程的同步。如何利用命名互斥對象保證應(yīng)用程序只有一個實例運行。應(yīng)用多線程編寫網(wǎng)絡(luò)聊天室程序。

2017-05-16 15:22:53

多核架構(gòu)及多線程編程

線程（thread）是進程上下文（context）中執(zhí)行的代碼序列，又被稱為輕量級進程（light weight process）? 在支持多線程的系統(tǒng)中，進程成為資源分配和保護的實體，而線程是被調(diào)度執(zhí)行的基本單元。

2017-09-11 16:12:24

關(guān)于多線程編程教程及經(jīng)典應(yīng)用案例的匯總分析

多處理機、多核心處理器以及芯片級多處理或同時多線程處理器。本文為大家介紹多線程在Linux環(huán)境下的編程及在實際環(huán)境中的應(yīng)用。 多線程技術(shù)在數(shù)據(jù)實時采集分析中的應(yīng)用本文介紹的多線程、內(nèi)存映射文件和兩級緩沖的方法在高速

2017-10-16 16:46:55

多線程編程之Linux線程編程

9.2 Linux線程編程 9.2.1 線程基本編程這里要講的線程相關(guān)操作都是用戶空間中的線程的操作。在Linux中，一般pthread線程庫是一套通用的線程庫，是由POSIX提出的，因此具有很好

2017-10-18 15:55:26

linux Android基礎(chǔ)知識總結(jié)

linux Android基礎(chǔ)知識總結(jié)

2017-10-24 09:00:46

linux多線程編程技術(shù)

（process）中只允許有一個線程，這樣多線程就意味著多進程?，F(xiàn)在，多線程技術(shù)已經(jīng)被許多操作系統(tǒng)所支持，包括Windows/NT，當(dāng)然，也包括Linux。為什么有了進程的概念后，還要再引入線程呢？使用多線程到底有哪些好處？什么的系統(tǒng)應(yīng)該選用多線程？我們首先必須回答這些問題。使

2017-10-24 16:01:39

WinCE多線程編程技術(shù)在無紙記錄儀中的應(yīng)用

2017-10-25 09:50:24

多線程好還是單線程好?單線程和多線程的區(qū)別優(yōu)缺點分析

摘要：如今單線程與多線程已經(jīng)得到普遍運用，那么到底多線程好還是單線程好呢？單線程和多線程的區(qū)別又是什么呢？下面我們來看看它們的區(qū)別以及優(yōu)缺點分析。

2017-12-08 09:33:15

79710

mfc多線程編程實例及代碼,mfc多線程間通信介紹

摘要：本文主要以MFC多線程為中心，分別對MFC多線程的實例、MFC多線程之間的通信展開的一系列研究，下面我們來看看原文。

2017-12-08 15:23:43

17054

什么是多線程編程?多線程編程基礎(chǔ)知識

摘要：多線程編程是現(xiàn)代軟件技術(shù)中很重要的一個環(huán)節(jié)。要弄懂多線程，這就要牽涉到多進程。本文主要以多線程編程以及多線程編程相關(guān)知識而做出的一些結(jié)論。

2017-12-08 16:30:08

11929

多線程服務(wù)器編程模型：如何正確使用mutex 和condition variable

本文對多線程服務(wù)器的常用編程模型進行了一個詳細的解讀，本文中的多線程服務(wù)器是運行在 Linux 操作系統(tǒng)上網(wǎng)絡(luò)應(yīng)用程序。介紹了典型的單線程服務(wù)器編程模型和典型的多線程服務(wù)器的線程模型以及進程間通信與線程間通信等相關(guān)內(nèi)容。

2018-02-19 08:29:00

6891

關(guān)于Linux下多線程編程技術(shù)學(xué)習(xí)總結(jié)

Linux下多線程編程技術(shù) 作為一個IT人員，不斷的學(xué)習(xí)和總結(jié)是我們這個職業(yè)習(xí)慣，所以我會將每個階段的學(xué)習(xí)都會通過一點的總結(jié)來記錄和檢測自己的學(xué)習(xí)效果，今天為大家總結(jié)了關(guān)于Linux下多線程編程技術(shù)。

2018-04-22 03:12:02

2051

Linux 多線程可重入函數(shù)

在單線程程序中，整個程序都是順序執(zhí)行的，一個函數(shù)在同一時刻只能被一個函數(shù)調(diào)用，但在多線程中，由于并發(fā)性，一個函數(shù)可能同時被多個函數(shù)調(diào)用，此時這個函數(shù)就成了臨界資源，很容易造成調(diào)用函數(shù)處理結(jié)果

2019-05-16 17:41:58

813

linux多線程機制-線程同步

：因為共享所有數(shù)據(jù)，從而非常容易導(dǎo)致線程之間互相破壞數(shù)據(jù)，這一點在編程時必須注意?！　?.結(jié)束語　　Linux中基于POSIX標(biāo)準(zhǔn)的很好的支持了多線程技術(shù)，它減少了程序并發(fā)執(zhí)行時的系統(tǒng)開銷,提高了計算機

2019-04-02 14:42:43

329

Linux下的多線程編程

的進程可以考慮分為多個線程，成為幾個獨立或半獨立的運行部分，這樣的程序會利于理解和修改?！　∠旅嫖覀兿葋韲L試編寫一個簡單的多線程程序。2 簡單的多線程編程　　Linux系統(tǒng)下的多線程遵循POSIX線程

2019-04-02 14:43:07

465

Linux多線程編程的高效開發(fā)

，互斥鎖，條件在 Linux 平臺上對應(yīng)的 API 可以用表 1 歸納。為了方便熟悉 Windows 線程編程的讀者熟悉 Linux 多線程開發(fā)的 API，我們在表中同時也列出 Windows SDK

2019-04-02 14:45:11

227

Linux環(huán)境多線程編程基礎(chǔ)設(shè)施

?本文介紹多線程環(huán)境下并行編程的基礎(chǔ)設(shè)施。主要包括：?Volatile__threadMemory Barrier__sync_synchronizevolatile編譯器有時候

2019-04-02 14:47:29

132

Linux多線程與同步

的UNIX系統(tǒng)，但Linux的多線程在邏輯和使用上與真正的多線程并沒有差別。?多線程我們先來看一下什么是多線程。在Linux從程序到進程中，我們看到了一個程序在內(nèi)存中的表示。這個程序的整個運行過程中，只有

2019-04-02 14:47:58

316

Linux 多線程編程

概念原來指向main()的線程叫做主線程(main thread)使用pthread_create()創(chuàng)建出來的線程，叫做子線程(child thread)主/子線程只有在創(chuàng)建時才有

2019-04-02 14:49:32

519

三種Linux中的常用多線程同步方式淺析

嵌入式linux中文站給大家介紹三種Linux中的常用多線程同步方式：互斥量，條件變量，信號量。

2019-05-02 14:49:00

2873

Linux驅(qū)動編程基礎(chǔ)知識講解

由于Linux驅(qū)動編程的本質(zhì)屬于Linux內(nèi)核編程，因此我們非常有必要熟悉Linux內(nèi)核以及Linux內(nèi)核的特點。這篇文章將會幫助讀者打下Linux驅(qū)動編程的基礎(chǔ)知識。

2020-03-01 08:27:00

3576

多線程編程指南的PDF電子書免費下載

《多線程編程指南》介紹了 SolarisTM 操作系統(tǒng) （Solaris Operating System， Solaris OS）中 POSIX?線程和 Solaris 線程的多線程編程接口

2020-06-11 08:00:00

Linux用戶態(tài)開發(fā)驅(qū)動教程及基礎(chǔ)知識

Linux用戶態(tài)開發(fā)驅(qū)動教程及基礎(chǔ)知識

2021-07-14 10:06:56

嵌入式linux多線程編程實驗,嵌入式Linux多線程編程-學(xué)習(xí)資源-華清遠見.PDF

2021-11-02 13:36:16

Linux應(yīng)用開發(fā)【第五章】線程編程應(yīng)用開發(fā)

文章目錄 5 線程編程應(yīng)用開發(fā) 5.1 線程的使用 5.1.1 為什么要使用多線程 5.1.2 線程概念 5.1.3 線程的標(biāo)識pthread_t 5.1.4 線程的創(chuàng)建 5.1.5 向線程傳入?yún)?shù)

2021-12-10 19:15:33

323

使用MicroPython在Raspberry Pi上通過雙核編程的多線程控制LED

在本教程中，我們將使用 MicroPython在 Raspberry Pi Pico 上通過雙核編程的多線程控制兩個 LED 。

2022-07-25 17:41:05

5985

Java多線程永動任務(wù) 多線程異步任務(wù)項目解讀

，這個示例的原型是公司自研的多線程異步任務(wù)項目，我把里面涉及到多線程的代碼抽離出來，然后進行一定的改造。里面涉及的知識點非常多，特別適合有一定工作經(jīng)驗的同學(xué)學(xué)習(xí)，或者可以直接拿到項目中使用。文章結(jié)構(gòu)非常簡單： 1. 功能說明做這個多線程異步任務(wù)，主要是因為我們有很多

2022-10-19 11:46:28

753

變頻器基礎(chǔ)知識解析

變頻器基礎(chǔ)知識解析

2022-11-11 11:11:58

704

SpringBoot實現(xiàn)多線程

SpringBoot實現(xiàn)多線程

2023-01-12 16:59:22

1241

多線程編程可以應(yīng)用在哪里？C++多線程詳解

多線程并發(fā)指的是在同一個進程中執(zhí)行多個線程。優(yōu)點：有操作系統(tǒng)相關(guān)知識的應(yīng)該知道，線程是輕量級的進程，每個線程可以獨立的運行不同的指令序列，但是線程不獨立的擁有資源，依賴于創(chuàng)建它的進程而存在。

2023-04-13 10:10:25

383

Linux中多線程編程的知識點

Hello、Hello大家好，我是木榮，今天我們繼續(xù)來聊一聊Linux中多線程編程中的重要知識點，詳細談?wù)?b class="flag-6" style="color: red">多線程中同步和互斥機制。

2023-04-26 17:27:44

466

淺談Linux網(wǎng)絡(luò)編程中的多進程和多線程

在Linux網(wǎng)絡(luò)編程中，我們應(yīng)該見過很多網(wǎng)絡(luò)框架或者server，有多進程的處理方式，也有多線程處理方式，孰好孰壞并沒有可比性，首先選擇多進程還是多線程我們需要考慮業(yè)務(wù)場景，其次結(jié)合當(dāng)前部署環(huán)境，是云原生還是傳統(tǒng)的IDC等，最后考慮可維護性，其具體的對比在第三部分具體會展開說。

2023-08-08 16:56:16

371

labview AMC多線程

labview_AMC多線程

2023-08-21 10:31:44

多線程如何保證數(shù)據(jù)的同步

多線程編程是一種并發(fā)編程的方法，意味著程序中同時運行多個線程，每個線程可獨立執(zhí)行不同的任務(wù)，共享同一份數(shù)據(jù)。由于多線程并發(fā)執(zhí)行的特點，會引發(fā)數(shù)據(jù)同步的問題，即保證多個線程對共享數(shù)據(jù)的訪問順序和正確性

2023-11-17 14:22:09

240

mfc多線程編程實例

（圖形用戶界面）應(yīng)用程序的開發(fā)。在這篇文章中，我們將重點介紹MFC中的多線程編程。 多線程編程在軟件開發(fā)中非常重要，它可以實現(xiàn)程序的并發(fā)執(zhí)行，提高程序的效率和響應(yīng)速度。MFC提供了豐富的多線程支持，可以輕松地實現(xiàn)多線程編程，并解決線程間的同步和通信問題。首先，讓我們看一個簡單的MFC多線程

2023-12-01 14:29:20

400

linux多線程編程實例

linux線程

2024-02-15 21:16:35

已全部加載完成

搜索歷史

Linux多線程編程基礎(chǔ)知識解析

前言

一、基本概念

二、POSIX線程

三、多線程API函數(shù)

1、線程創(chuàng)建

1）無參數(shù)線程函數(shù)創(chuàng)建線程

2）帶參數(shù)線程函數(shù)創(chuàng)建線程

3）創(chuàng)建一個線程，共享進程數(shù)據(jù)

2、線程等待

Demo1 : 使用默認狀態(tài)，注釋掉pthread_join函數(shù)

Demo2: 使用pthread_join 阻塞主線程

1）正常退出

（1）return

（2）pthread_exit

（3）pthread_cancel

2）異常退出

3、線程退出

1）返回指向線程函數(shù)棧上分配的變量的指針

2）返回指向全局變量的指針

4、線程取消

5、線程分離

6、線程信號

7、線程 ID 比較

四、顯示進程中的線程信息

1、ps命令

2、Top命令

3、Htop

4、/proc/pid/task/tid/status

評論

一、基本概念

三、多線程API函數(shù)

1、線程創(chuàng)建

3）創(chuàng)建一個線程，共享進程數(shù)據(jù)

2、線程等待

Demo1 : 使用默認狀態(tài)，注釋掉pthread_join函數(shù)

4、線程取消

5、線程分離

6、線程信號

7、線程 ID 比較

四、顯示進程中的線程信息

1、ps命令

2、Top命令

3、Htop