Linux之线程的创建方式

线程的概念与实现方式

线程是进程内部的一条执行序列或执行路径，一个进程可以包含多条线程。

• 从资源分配的角度来看，进程是操作系统进行资源分配的基本单位。
• 从资源调度的角度来看，线程是资源调度的最小单位，是程序执行的最小单位

执行序列就是一组有序指令的集合——函数。

线程是进程内部的一条执行序列，一个进程至少有一条线程，称之为主线程（main方法代表的执行序列），可以通过线程库创建其他线程（给线程制定一个它要执行的函数），将创建的线程称之为函数线程。

线程的实现方式

• 内核级线程（由内核直接创建和管理线程，虽然创建开销较大，但是可以利用多处理器的资源）
• 用户级线程（由线程库创建和管理多个线程，线程的实现都是在用户态，内核无法感知，创建开销较小，无法使用多处理器的资源）
• 混合级线程（结合以上两种方式实现，可以利用多处理器的资源，从而在用户空间中创建更多的线程，从而映射到内核空间的线程中，多对多，N：M（N>>M））

Linux系统实现多线程的方式

Linux 实现线程的机制非常独特。从内核的角度来说，它并没有线程这个概念。

Linux 把所有的线程都当做进程来实现。内核并没有准备特别的调度算法或是定义特别的数据结构来表征线程。

相反，线程仅仅被视为一个与其他进程共享某些资源的进程。

每个线程都拥有唯 一隶属于自己的task_struct，所以在内核中，它看起来就像是一个普通的进程（只是线程和 其他一些进程共享某些资源，如地址空间）

线程和进程的区别

• 进程是资源分配最小单位，线程是程序执行的最小单位；
• 线程间的切换效率相比进程间的切换要高
• 进程有自己独立的地址空间，每启动一个进程，系统都会为其分配地址空间，建立数据表来维护代码段、堆栈段和数据段，线程没有独立的地址空间，它使用相同的地址空间共享数据；
• 创建一个线程比进程开销小；
• 线程占用的资源要⽐进程少很多。
• 线程之间通信更方便，同一个进程下，线程共享全局变量，静态变量等数据，进程之间的通信需要以通信的方式（IPC）进行；（但多线程程序处理好同步与互斥是个难点）
• 多进程程序更安全，生命力更强，一个进程死掉不会对另一个进程造成影响（源于有独立的地址空间），多线程程序更不易维护，一个线程死掉，整个进程就死掉了（因为共享地址空间）；
• 进程对资源保护要求高，开销大，效率相对较低，线程资源保护要求不高，但开销小，效率高，可频繁切换；

多线程开发的三个基本概念

• 线程 【创建、退出、等待】
• 互斥锁【创建、销毁、加锁】、解锁】
• 条件【创建、销毁、触发、广播、等待】

线程库的使用

1.创建线程

?

1 2 3

#include<phread.h>   int pthread_create(pthread_t *id , pthread_attr_t *attr, void (*fun)( void *), void *arg);

• id ：传递一个pthread_t类型的变量的地址，创建成功后，用来获取新创建的线程的TID
• attr：指定线程的属性 默认使用NULL
• fun：线程函数的地址
• arg：传递给线程函数的参数
• 返回值，成功返回0，失败返回错误码

多线程代码示例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #include<unistd.h>   #include<pthread.h>   //声明一个线程函数 void *fun( void *);   int main() {      printf ( "main start\n" );        pthread_t id;      //创建函数线程，并且指定函数线程要执行的函数      int res = pthread_create(&id,NULL,fun,NULL);      assert (res == 0);        //之后并发运行      int i = 0;       for (; i < 5; i++)      {          printf ( "main running\n" );          sleep(1);      }        printf ( "main over\n" );      exit (0); }   //定义线程函数 void * fun( void *arg) {      printf ( "fun start\n" );        int i = 0;      for (; i < 3;i++)      {          printf ( "fun running\n" );          sleep(1);      }        printf ( "fun over\n" ); }

gcc编译代码时报`undifined reference to xxxxx错误，都是因为程序中调用了一些方法，但是没有连接该方法所在的文件，例如下面的情况：

连接库文件编译成功并执行，这一点在帮助手册中也有提示：Compile and link with -pthread

比较两次运行的结果发现前三条执行语句时一样的

结论

• 创建线程并执行线程函数，和调用函数是完全不同的概念。
• 主线程和函数线程是并发执行的。
• 线程提前于主线程结束时，不会影响主线程的运行
• 主线程提前于线程结束时，整个进程都会结束，其他线程也会结束
• 创建函数线程后，哪个线程先被执行是有操作系统的调度算法和机器环境决定。

函数线程在主线程结束后也随之退出，原因：主线程结束时使用的是exit方法，这个方法结束的是进程。

然而修改代码为：pthread_exit(NULL);此时主线程结束，函数线程会继续执行直至完成。即便如此，我们还是不推荐大家手动结束主线程，我们更喜欢让主线程等待一会。

给线程函数传参

①值传递

将变量的值直接转成void*类型进行传递

因为线程函数接受的是一个void*类型的指针，只要是指针，32位系统上都是4个字节，值传递就只能传递小于或等于4字节的值。

代码示例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

#include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #include<unistd.h>   #include<pthread.h>   void *fun( void *);   int main() {      printf ( "main start\n" );        int a = 10;           pthread_t id;      int res = pthread_create(&id,NULL,fun,( void *)a);      assert (res == 0);        int i = 0;       for (; i < 5; i++)      {          printf ( "main running\n" );          sleep(1);      }        printf ( "main over\n" );      exit (0); }     void * fun( void *arg) {      int b = ( int )arg;      printf ( "b == %d\n" ,b); }

②地址传递

将变量（所有类型）的地址强转成void*类型进行传递，就和在普通函数调用传递变量的地址相似。

主线程和函数线程通过这个地址就可以共享地址所指向的空间。

一个进程内的所有线程是共享这个进程的地址空间。

多线程下进程的4G虚拟地址空间

一个进程内的所有线程对于全局数据，静态数据，堆区空间都是共享的。

线程之间传递数据很简单，但是随之带来的问题就是线程并发运行时无法保证线程安全。

代码示例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

#include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #include<unistd.h>   #include<pthread.h>   int gdata = 10; //.data   void *fun( void *);   int main() {      int *ptr = ( int *) malloc (4); //.heap      *ptr = 10;           pthread_t id;      int res = pthread_create(&id,NULL,fun,( void *)ptr);      assert (res == 0);        sleep(2); //等待两秒，保证函数线程已经讲数据修改        printf ( "main : gdata == %d\n" ,gdata);      printf ( "main : *ptr = %d\n" ,*ptr);        exit (0); }     void *fun( void *arg) {      int *p = ( int *)arg;        gdata = 20000;      *p = 20;        printf ( "fun over\n" ); }

线程库中的其他方法

线程退出的三种方式：

• 线程从执行函数返回，返回值是线程的退出码；
• 线程被同一进程的其他线程取消；
• 调用pthread_exit（）函数退出；

等待线程终止

?

1 2 3 4 5 6

int pthread_join(pthread_t thread , void **retval); args:      pthread_t thread : 被连接线程的线程号，该线程必须位于当前进程中，而且不得是分离线程      void **retval :该参数不为NULL时，指向某个位置 在该函数返回时，将该位置设置为已终止线程的退出状态      return :      线程连接的状态，0是成功，非0是失败

当A线程调用线程B并 pthread_join() 时，A线程会处于阻塞状态，直到B线程结束后，A线程才会继续执行下去。当 pthread_join() 函数返回后，被调用线程才算真正意义上的结束，它的内存空间也会被释放（如果被调用线程是非分离的）。

这里有三点需要注意：

• 1.被释放的内存空间仅仅是系统空间，你必须手动清除程序分配的空间，比如 malloc() 分配的空间。
• 2.一个线程只能被一个线程所连接。
• 3.被连接的线程必须是非分离的，否则连接会出错。所以可以看出pthread_join()有两种作用：1-用于等待其他线程结束：当调用 pthread_join() 时，当前线程会处于阻塞状态，直到被调用的线程结束后，当前线程才会重新开始执行。2-对线程的资源进行回收：如果一个线程是非分离的（默认情况下创建的线程都是非分离）并且没有对该线程使用 pthread_join() 的话，该线程结束后并不会释放其内存空间，这会导致该线程变成了“僵尸线程”。

等待指定的子线程结束

• 等待thread（）指定的线程退出，线程未退出时，该方法阻塞
• result接收thread线程退出时，指定退出信息

?

1	int pthread_join(pthread_t id, void **result) //调用这个方法的线程会阻塞，直到等待线程结束

代码演示：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

#include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #include<unistd.h>   #include<pthread.h>   int main() {      printf ( "main start\n" );        pthread_t id;      int res = pthread_create(&id,NULL,fun,NULL);      assert (res == 0);        //之后并发运行      int i = 0;       for (; i < 5; i++)      {          printf ( "main running\n" );          sleep(1);      }           char *s = NULL;      pthread_join(id,( void **)&s);      printf ( "join : s = %s\n" ,s);           exit (0); }   //定义线程函数 void * fun( void *arg) {      printf ( "fun start\n" );        int i = 0;      for (; i < 10;i++)      {          printf ( "fun running\n" );          sleep(1);      }        printf ( "fun over\n" );        pthread_exit( "fun over" ); //将该字符常量返回给主线程 }

此时，主线程完成五次输出，就会等待子线程结束，阻塞等待，子线程结束后，最后，主线程打印join：s = fun over

关于exit和join的一些详细说明：

• 线程自己运行结束，或者调用pthread_exit结束，线程都会释放自己独有的空间资源；
• 若线程是非分离的，线程会保留线程ID号，直到其他线程通过joining这个线程确认其已经死亡，join的结果是joining线程得到已终止线程的退出状态，已终止线程将消失；
• 若线程是分离的，不需要使用pthread_exit（），线程自己运行结束，线程结束就会自己释放所有空间资源（包括线程ID号）；
• 子线程最终一定要使用pthread_join（）或者设置为分离线程来结束线程，否则线程的资源不会被完全释放（使用取消线程功能也不能完全释放）；
• 主线程运行pthrea_exit()，会结束主线程，但是不会结束子线程；
• 主线程结束，则整个程序结束，所以主线程最好使用pthread_join函数等待子线程结束，使用该函数一个线程可以等待多个线程结束；
• 使用pthread_join函数的线程将会阻塞，直到被join的函数线程结束，该函数返回，但是它对被等待终止的线程运行没有影响；
• 如果子线程使用exit()则可以结束整个进程；

线程属性

线程具有的属性可以在线程创建的时候指定；

——pthread_create()函数的第二个参数(pthread_attr_t *attr)表示线程的属性，在以前的例子中将其值设为NULL,也就是采用默认属性，线程的多项属性都是可以修改的，这些属性包括绑定属性，分离属性，堆栈属性，堆栈大小，优先级。

系统默认的是非绑定，非分离，缺省1M的堆栈以及父子进程优先级相同

线程结构如下：

?

1 2 3 4 5 6 7 8 9 10 11 12

typedef struct {      int             detachstate;     //线程的分离状态      int             schedpolicy;    //线程调度策略      struct sched_param  schedparam; //线程的调度参数      int             inheritsched;   //线程的继承性      int             scope;      //线程的作用域      size_t          guardsize;  //线程栈末尾的警戒缓冲区大小      int             stackaddr_set; //线程的栈设置      void *           stackaddr;  //线程栈的位置      size_t          stacksize;  //线程栈的大小 } pthread_attr_t;

每一个属性都有对应的一些函数，用于对其进行查看和修改，下面分别介绍：

线程属性初始化

初始化和去初始化分别对应于如下的两个函数：

?

1 2 3 4

#include <pthread.h> ​ ① int pthread_attr_init(pthread_attr_t *attr); ②it pthread_attr_destroy(pthread_attr_t *attr);

①功能：

• 初始化线程属性函数，注意：应先初始化线程属性，再pthread_create创建线程

参数：

• attr：线程属性结构体

返回值：

• 成功：0
• 失败：-1

②​功能：

• 销毁线程属性所占用的资源函数

参数：

• attr：线程属性结构体

返回值：

• 成功：0
• 失败：-1

线程分离

线程的分离状态决定一个线程以什么样的方式来终止自己，这个在之前我们也说过了。

• 非分离状态：线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
• 分离状态：分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。

相关API如下：

?

1 2 3

#include <pthread.h> ​ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

功能：设置线程分离状态

参数：

• attr：已初始化的线程属性
• detachstate： 分离状态

PTHREAD_CREATE_DETACHED（分离线程）

PTHREAD_CREATE_JOINABLE（非分离线程）

返回值：

• 成功：0
• 失败：非0

​

?

1	int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate);

功能：获取线程分离状态

参数：

• attr：已初始化的线程属性detachstate： 分离状态

PTHREAD_CREATE_DETACHED（分离线程）

PTHREAD _CREATE_JOINABLE（非分离线程）

返回值：

• 成功：0
• 失败：非0

注意：

当一个线程被设置为分离线程时，假设此时该线程的执行速度非常快，它很可能在pthread_create返回之前就终止； 终止之后将线程号和系统资源移交给其他线程使用，这样调用create就得到了错误的线程号，因此就必须采取一些同步措施，可以在被创建的线程里调用pthread_cond_timedwait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回，设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait()之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。

原文链接：https://blog.csdn.net/qq_44824574/article/details/110672780