三十六、Linux 线程——线程基本概念及线程的创建和终止

36.1 线程介绍

36.1.1 线程的基本概念

• 进程是资源管理的最小单位，线程是程序执行的最小单位
• 每个进程都有自己的数据段、代码段和堆栈段。
• 线程通常叫做轻型的进程，它包含独立的栈和 CPU 寄存器状态，线程是进程的一条执行路径，每个线程共享其所附属进程的所有资源，包括打开的文件、内存页面、信号标识及动态分配的内存等。
• 因为线程和进程比起来很小，所以相对来说，线程花费更少的 CPU 资源
• 在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持多处理器，并且减少进程上下文切换的开销。

36.1.2 进程和线程的关系

• 线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一用户内存空间，当进程退出时，该进程所产生的线程都会被强制退出并清除。
• 一个进程至少需要一个线程作为它的指令执行，进程管理着资源（比如 CPU、内存、文件等等），并将线程分配到某个 CPU 上执行

　　

36.1.3 线程分类

• 线程按照其调度者可分为用户级线程和内核级线程两种：
  • 用户级线程：主要解决的是上下文切换的问题，其调度过程由用户决定
  • 内核级线程：由内核调度机制实现
• 现在大多数操作系统都采用用户级线程和内核级线程并存的方法
• 用户级线程要绑定内核级线程运行，一个进程中的内核级线程会分配到固定的时间片，用户级线程分配的时间片以内核级线程为准
• 默认情况下，用户级线程和内核级线程是一对一，也可以多对一，这样实时性就会比较差
• 当 CPU 分配给线程的时间片用完后但线程没有执行完毕，此时线程会从运行状态返回到就绪状态，将 CPU 让给其他线程使用

36.1.4 Linux 线程实现

• 以下线程均为用户级线程
  • 在Linux 中，一般采用 pthread 线程库实现线程的访问与控制，由 POSIX 提出，具有良好的可移植性
• Linux 线程程序编译需要在 gcc 上链接库 pthread

36.1.5 线程标识

• 每个进程内部的不同线程都由自己的唯一标识（ID）
• 线程标识只在它所属的进程环境中有效
• 线程标识是 pthread_t 数据类型

 #include <pthread.h>
 int pthread_equal(pthread_t, pthread_t);

• 函数功能：判断两个线程是否相等
• 返回值：相等返回非0；否则返回0

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

• 函数功能：获取当前线程的线程 ID
• 返回值：调用线程的线程 ID

36.2 线程的创建和销毁

36.2.1 线程创建

 #include <pthread.h>
 int pthread_create(pthread_t *restrict tidp,
                    const pthread_attr_t *restrict attr,
                    void *(*start_rtn)(void *), 
5　　　　　　　　　　　　void *restrict arg);                

• 函数功能：创建一个线程
• 函数参数：
  • tidp：线程标识符指针
  • attr：线程属性指针
  • start_rtn：线程运行函数的起始地址
  • arg：传递给线程运行函数的参数
• 返回值：成功，返回0；失败，返回错误编号
• 新创建线程从 start_trn 函数的地址开始运行
• 不能保证新线程和调用线程的执行顺序

36.2.2 线程终止

• 主动终止：
  • 线程的执行函数中调用 return 语句
  • 调用 pthread_exit（）
• 被动终止：
  • 线程可以被同一进程的其他线程取消，其他线程调用 pthread_cancel(pthid)

 #include <pthread.h>
 int pthread_cancel(pthread_t tid);
 void pthread_exit(void *retval);
 int pthread_join(pthread_t th, void **thread_return);

• pthread_cancel：线程可以别同一进程的其他线程取消，tid 为被终止的线程标识符
• pthread_exit：
  • retval：pthread_exit 调用者线程的返回值，可由其他函数和 pthread_join 来检测获取
  • 线程退出时，使用函数 pthread_exit，是线程的主动行为
  • 由于一个进程中的多个线程共享数据段，因此通常在线程退出后，退出线程所占用的资源并不会随线程结束而释放。所以需要 pthread_join 函数来等待线程结束，类似于 wait 系统调用
• pthread_join
  • th：被等待线程的标识符
  • thread_return：用户定义指针，用来存储被等待线程的返回值

36.3 例子

36.3.1 龟兔赛跑

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

 typedef struct {
     char    name[];
     int     time;
     int     start;
     int     end;
 }RaceArg;

 /** 定义线程运行函数 */
 void *th_fn(void *arg)
 {
     RaceArg *r = (RaceArg *)arg;
     int i = r->start;

     for(; i <= r->end; i++){
         printf("%s(%lx) running %d\n", r->name, pthread_self(), i);
         usleep(r->time);
     }

     return (void *);
 }

 int main(void)
 {
     int err;
     pthread_t   rabbit, turtle; ///< 定义线程标识符
     RaceArg     r_a = {"rabbit", (int )(drand48() * 100000000), 20, 50};
     RaceArg     t_a = {"turtle", (int )(drand48() * ), , };

     /** 创建 rabbit 线程 */
     if((err = pthread_create(&rabbit, NULL, th_fn, (void *)&r_a)) != ){
         perror("pthread_create error");
     }

     /** 创建 turtle 线程 */
     if((err = pthread_create(&turtle, NULL, th_fn, (void *)&t_a)) != ){
         perror("pthread_create error");
     }

     //sleep(10);
     /** 主控线程调用 pthread_join(), 自己会阻塞，直到 rabbit 线程结束方可运行 */
     pthread_join(rabbit, NULL);
     pthread_join(turtle, NULL);
     printf("control thread id: %lx\n", pthread_self());
     printf("finisheld!\n");
     return ;
 }

　　运行结果如下：

　　 

　　可以看到每次都只有一个线程在执行。

　　在进程的线程中，每个线程的变量所在地方如下：

　　

36.3.2 获取线程终止返回值

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

 typedef struct {
     int     d1;
     int     d2;
 }Arg;

 void *th_fn(void *arg)
 {
     Arg *r = (Arg *)arg;

     /* 获取普通变量值
     return (void *)(r->d1 + r->d2);
     */

     /** 获取结构体对象 */
     return r;
 }

 int main(void)
 {
     int err;
     pthread_t th;
     Arg r = {, };

     if((err = pthread_create(&th, NULL, th_fn, (void *)&r)) != ){
         perror("pthread_create error");
     }

     /** 获取普通变量值 */
     /* 第一种获取返回值的方法
     int *result;

     pthread_join(th, (void **)&result);
     printf("result is %d\n", (int)result);
     */

     /** 第二种获取返回值的方法 */
     /*
     int result;
     pthread_join(th, (void *)&result);
     printf("result is %d\n", result);
     */

     /** 获取结构体变量 */
     /*
     int *result;
     pthread_join(th, (void **)&result);
     printf("result is %d\n",((Arg *)result)->d1 + ((Arg *)result)->d2);
     */

     int result;
     pthread_join(th, (void *)&result);
     printf("result is %d\n",((Arg *)result)->d1 + ((Arg *)result)->d2);

     return ;
 }

36.3.3 龟兔赛跑获取返回值

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

 typedef struct {
     char    name[];
     int     time;
     int     start;
     int     end;
 }RaceArg;

 /** 定义线程运行函数 */
 void *th_fn(void *arg)
 {
     RaceArg *r = (RaceArg *)arg;
     int i = r->start;

     for(; i <= r->end; i++){
         printf("%s(%lx) running %d\n", r->name, pthread_self(), i);
         usleep(r->time);
     }

     //return (void *)0;
     return (void *)(r->end - r->start);
 }

 int main(void)
 {
     int err;
     pthread_t   rabbit, turtle; ///< 定义线程标识符
     RaceArg     r_a = {"rabbit", (int )(drand48() * 100000000), 20, 50};
     RaceArg     t_a = {"turtle", (int )(drand48() * ), , };

     /** 创建 rabbit 线程 */
     if((err = pthread_create(&rabbit, NULL, th_fn, (void *)&r_a)) != ){
         perror("pthread_create error");
     }

     /** 创建 turtle 线程 */
     if((err = pthread_create(&turtle, NULL, th_fn, (void *)&t_a)) != ){
         perror("pthread_create error");
     }

     sleep();

     int result;
     pthread_join(rabbit, (void *)&result);
     printf("rabbit distance is %d\n", result);
     pthread_join(turtle, (void *)&result);
     printf("turtle distance is %d\n", result);
     printf("reace finished\n");

     /** 主控线程调用 pthread_join(), 自己会阻塞，直到 rabbit 线程结束方可运行 */
     //pthread_join(rabbit, NULL);
     //pthread_join(turtle, NULL);

     printf("control thread id: %lx\n", pthread_self());
     printf("finisheld!\n");
     return ;
 }