devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux线程（2）——创建、终止和回收（pthread_create()、pthread_exit()、pthread_join()）

作者：不正经 | 2024-03-02 19:21:54

赞

踩

pthread_exit

线程 ID

        就像每个进程都有一个进程 ID 一样，每个线程也有其对应的标识，称为线程 ID。进程 ID 在整个系统中是唯一的，但线程 ID 不同，线程 ID 只有在它所属的进程上下文中才有意义。

        进程 ID 使用 pid_t 数据类型来表示，它是一个非负整数。而线程 ID 使用 pthread_t 数据类型来表示， 一个线程可通过库函数 pthread_self()来获取自己的线程 ID，其函数原型如下所示：

  1. #include <pthread.h>
  2.  
  3. pthread_t pthread_self(void);

        该函数调用总是成功，返回当前线程的线程 ID。

        可以使用 pthread_equal()函数来检查两个线程 ID 是否相等，其函数原型如下所示：

  1. #include <pthread.h>
  2.  
  3. int pthread_equal(pthread_t t1, pthread_t t2);

        如果两个线程 ID t1 和 t2 相等，则 pthread_equal()返回一个非零值；否则返回 0。在 Linux 系统中，使用无符号长整型（unsigned long int）来表示 pthread_t 数据类型，但是在其它系统当中，则不一定是无符号长整型，所以我们必须将 pthread_t 作为一种不透明的数据类型加以对待，所以 pthread_equal()函数用于比较两个线程 ID 是否相等是有用的。

        线程 ID 在应用程序中非常有用，原因如下：

  1. 很多线程相关函数，譬如后面将要学习的 pthread_cancel()、pthread_detach()、pthread_join()等，它们都是利用线程 ID 来标识要操作的目标线程；
  2. 在一些应用程序中，以特定线程的线程 ID 作为动态数据结构的标签，这某些应用场合颇为有用， 既可以用来标识整个数据结构的创建者或属主线程，又可以确定随后对该数据结构执行操作的具体线程。

创建线程

        启动程序时，创建的进程只是一个单线程的进程，称之为初始线程或主线程，下面我们讨论如何创建一个新的线程。

        主线程可以使用库函数 pthread_create()负责创建一个新的线程，创建出来的新线程被称为主线程的子线程，其函数原型如下所示

  1. #include <pthread.h>
  2.  
  3. int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

        函数参数和返回值含义如下：

        thread：pthread_t 类型指针，当 pthread_create()成功返回时，新创建的线程的线程 ID 会保存在参数 thread 所指向的内存中，后续的线程相关函数会使用该标识来引用此线程。

        attr：pthread_attr_t 类型指针，指向 pthread_attr_t 类型的缓冲区，pthread_attr_t 数据类型定义了线程的 各种属性。如果将参数 attr 设置为 NULL，那么表示将线程的所有属 性设置为默认值，以此创建新线程。

        start_routine：参数 start_routine 是一个函数指针，新创建的线程从 start_routine()函数开始运行，该函数返回值类型为void *，并且该函数的参数只有一个void *，其实这个参数就是pthread_create()函数的第四个参数 arg。如果需要向 start_routine()传递的参数有一个以上，那么需要把这些参数放到一个结构体中，然后把这个结构体对象的地址作为 arg 参数传入。

        arg：传递给 start_routine()函数的参数。一般情况下，需要将 arg 指向一个全局或堆变量，意思就是说 在线程的生命周期中，该 arg 指向的对象必须存在，否则如果线程中访问了该对象将会出现错误。当然也可 将参数 arg 设置为 NULL，表示不需要传入参数给 start_routine()函数。

        返回值：成功返回 0；失败时将返回一个错误号，并且参数 thread 指向的内容是不确定的。  

        注意 pthread_create()在调用失败时通常会返回错误码，它并不像其它库函数或系统调用一样设置 errno， 每个线程都提供了全局变量 errno 的副本，这只是为了与使用 errno 到的函数进行兼容，在线程中，从函数中返回错误码更为清晰整洁，不需要依赖那些随着函数执行不断变化的全局变量，这样可以把错误的范围 限制在引起出错的函数中。

        线程创建成功，新线程就会加入到系统调度队列中，获取到 CPU 之后就会立马从 start_routine()函数开始运行该线程的任务；调用 pthread_create()函数后，通常我们无法确定系统接着会调度哪一个线程来使用 CPU 资源，先调度主线程还是新创建的线程呢（而在多核 CPU 或多 CPU 系统中，多核线程可能会在不同 的核心上同时执行）？如果程序对执行顺序有强制要求，那么就必须采用一些同步技术来实现。这与前面学习父、子进程时也出现了这个问题，无法确定父进程、子进程谁先被系统调度。

使用示例

        使用 pthread_create()函数创建一个除主线程之外的新线程，示例代码如下所示：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <unistd.h>
  8.  
  9. static void *new_thread_start(void *arg){
  10.     printf("新线程: 进程 ID<%d> 线程 ID<%lu>\n", getpid(), pthread_self());
  11.     return (void *)0;
  12. }
  13.  
  14. int main(void){
  15.     pthread_t tid;
  16.     int ret;
  17.     ret = pthread_create(&tid, NULL, new_thread_start, NULL);
  18.     if (ret) {
  19.         fprintf(stderr, "Error: %s\n", strerror(ret));
  20.         exit(-1);
  21.     }
  22.     printf("主线程: 进程 ID<%d> 线程 ID<%lu>\n", getpid(), pthread_self());
  23.     sleep(1);
  24.     exit(0);
  25. }

         编译时出现了错误，提示“对‘pthread_create’未定义的引用”，示例代码确实已经包含了头文件，但为什么会出现这样的报错，仔细看，这个报错是出现在程序代码链接时、而并非是编译过程，所以可知这是链接库的文件，如何解决呢？

gcc -o testApp testApp.c -lpthread

        使用-l 选项指定链接库 pthread，原因在于 pthread 不在 gcc 的默认链接库中，所以需要手动指定。再次编译便不会有问题了，如下：

         从打印信息可知，正如前面所介绍那样，两个线程的进程 ID 相同，说明新创建的线程与主线程本来就属于同一个进程，但是它们的线程 ID 不同。从打印结果可知，Linux 系统下线程 ID 数值非常大，看起来像是一个指针。

终止线程

         在示例代码中，我们在新线程的启动函数（线程 start 函数）new_thread_start()通过 return 返回之后，意味着该线程已经终止了，除了在线程 start 函数中执行 return 语句终止线程外，终止线程的方式还有多种，可以通过如下方式终止线程的运行：

  1. 线程的 start 函数执行 return 语句并返回指定值，返回值就是线程的退出码；
  2. 线程调用 pthread_exit()函数；
  3. 调用 pthread_cancel()取消线程；

     如果进程中的任意线程调用 exit()、_exit()或者_Exit()，那么将会导致整个进程终止。

     pthread_exit()函数将终止调用它的线程，其函数原型如下所示：

  1. #include <pthread.h>
  2.  
  3. void pthread_exit(void *retval);

        参数 retval 的数据类型为 void *，指定了线程的返回值、也就是线程的退出码，该返回值可由另一个线程通过调用 pthread_join()来获取；同理，如果线程是在 start 函数中执行 return 语句终止，那么 return 的返回值也是可以通过 pthread_join()来获取的。

        参数 retval 所指向的内容不应分配于线程栈中，因为线程终止后，将无法确定线程栈的内容是否有效； 出于同样的理由，也不应在线程栈中分配线程 start 函数的返回值。

        调用 pthread_exit()相当于在线程的 start 函数中执行 return 语句，不同之处在于，可在线程 start 函数所调用的任意函数中调用 pthread_exit()来终止线程。如果主线程调用了 pthread_exit()，那么主线程也会终止， 但其它线程依然正常运行，直到进程中的所有线程终止进程才会终止。

使用示例

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <unistd.h>
  8.  
  9. static void *new_thread_start(void *arg){
  10.     printf("新线程 start\n");
  11.     sleep(1);
  12.     printf("新线程 end\n");
  13.     pthread_exit(NULL);
  14. }
  15.  
  16. int main(void){
  17.     pthread_t tid;
  18.     int ret;
  19.     ret = pthread_create(&tid, NULL, new_thread_start, NULL);
  20.     if (ret) {
  21.         fprintf(stderr, "Error: %s\n", strerror(ret));
  22.         exit(-1);
  23.     }
  24.     printf("主线程 end\n");
  25.     pthread_exit(NULL);
  26.     exit(0);
  27. }

回收线程

        在父、子进程当中，父进程可通过 wait()函数（或其变体 waitpid()）阻塞等待子进程退出并获取其终止状态，回收子进程资源；而在线程当中，也需要如此，通过调用 pthread_join()函数来阻塞等待线程的终止， 并获取线程的退出码，回收线程资源；pthread_join()函数原型如下所示：

  1. #include <pthread.h>
  2.  
  3. int pthread_join(pthread_t thread, void **retval);

        函数参数和返回值含义如下：

        thread：pthread_join()等待指定线程的终止，通过参数 thread（线程 ID）指定需要等待的线程；

         retval：如果参数 retval 不为 NULL，则 pthread_join()将目标线程的退出状态（即目标线程通过 pthread_exit()退出时指定的返回值或者在线程 start 函数中执行 return 语句对应的返回值）复制到*retval 所指向的内存区域；如果目标线程被 pthread_cancel()取消，则将 PTHREAD_CANCELED 放在*retval 中。如果对 目标线程的终止状态不感兴趣，则可将参数 retval 设置为 NULL。

        返回值：成功返回 0；失败将返回错误码。

        调用 pthread_join()函数将会以阻塞的形式等待指定的线程终止，如果该线程已经终止，则 pthread_join() 立刻返回。如果多个线程同时尝试调用 pthread_join()等待指定线程的终止，那么结果将是不确定的。

        若线程并未分离，则必须使用 pthread_join()来等待线程终止，回收线程资源；如果线程终止后，其它线程没有调用 pthread_join()函数来回收该线程，那么该线程将变成僵尸线程，与僵尸进程的概念相类似；同样，僵尸线程除了浪费系统资源外，若僵尸线程积累过多，那么会导致应用程序无法创建新的线程。

        当然，如果进程中存在着僵尸线程并未得到回收，当进程终止之后，进程会被其父进程回收，所以僵尸线程同样也会被回收。

        所以，通过上面的介绍可知，pthread_join()执行的功能类似于针对进程的 waitpid()调用，不过二者之间存在一些显著差别：

  1. 线程之间关系是对等的。进程中的任意线程均可调用 pthread_join()函数来等待另一个线程的终止。 譬如，如果线程 A 创建了线程 B，线程 B 再创建线程 C，那么线程 A 可以调用 pthread_join()等待线程 C 的终止，线程 C 也可以调用 pthread_join()等待线程 A 的终止；这与进程间层次关系不同， 父进程如果使用 fork()创建了子进程，那么它也是唯一能够对子进程调用 wait()的进程，线程之间不存在这样的关系。
  2. 不能以非阻塞的方式调用 pthread_join()。对于进程，调用 waitpid()既可以实现阻塞方式等待、也可以实现非阻塞方式等待。

使用示例

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <unistd.h>
  8.  
  9. static void *new_thread_start(void *arg){
  10.      printf("新线程 start\n");
  11.      sleep(2);
  12.      printf("新线程 end\n");
  13.      pthread_exit((void *)10);
  14. }
  15.  
  16. int main(void){
  17.     pthread_t tid;
  18.     void *tret;
  19.     int ret;
  20.     ret = pthread_create(&tid, NULL, new_thread_start, NULL);
  21.     if (ret) {
  22.         fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
  23.         exit(-1);
  24.     }
  25.     ret = pthread_join(tid, &tret);
  26.     if (ret) {
  27.         fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
  28.         exit(-1);
  29.     }
  30.     printf("新线程终止, code=%ld\n", (long)tret);
  31.     exit(0);
  32. }

        主线程调用 pthread_create()创建新线程之后，新线程执行 new_thread_start()函数，而在主线程中调用 pthread_join()阻塞等待新线程终止，新线程终止后，pthread_join()返回，将目标线程的退出码保存在*tret 所指向的内存中。测试结果如下：

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号