线程创建、线程终止、线程等待及线程分离

最新推荐文章于 2024-05-02 20:13:17 发布
最新推荐文章于 2024-05-02 20:13:17 发布
阅读量783 收藏 3
点赞数 1
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvxin15353715790/article/details/82669635
版权

线程的概念

1.什么是线程:是一个轻量级进程，一个进程内的一条执行流，也可以说是一个进程内的控制序列。

  • linux下PCB是线程

    1. 说的是linux操作系统，其他操作系统不是这样

    2. linux对线程和进程不作区分，linux下的线程以进程PCB模拟

    3. linux下的线程以进程PCB模拟，因此也叫轻量级进程(LWP)

    4. 一个进程中至少有一个线程，进程也叫线程组

  • CPU足够的情况下，多个进程可同时运行，CPU调度进程的时候，调度的是PCB

  • 因为多个进程有多个PCB，因此多个进程可以实现并行

2.进程和线程的关系

  • 进程是具有一个或者多个线程的线程组

  • 线程共享进程数据，同时也拥有自己的一部分数据，线程ID、一组寄存器、栈、errno、信号屏蔽字及调度优先级。

  • 进程是操作系统资源分配的基本单位（ps -ef）

  • 线程是CPU调度的基本单位，或者说是程序执行的最小单位

线程与进程的优缺点：

  • 线程优点

    1. 一个进程中可能会有多个线程，而这些线程共享一个虚拟地址空间，因此有时候也会说线程是运行在进程中的

    2. 线程间通信将变得极为方便

    3. 线程占用的资源要比进程小很多，能充分利用多处理器的可并行数量

    4. 创建/销毁一个线程相较于进程来说成本更低（不需要额外创建虚拟地址空间）

    5. 线程的调度切换相较于进程也较低

  • 线程缺点

    1. 一个进程中可能会有多个线程，而这些线程共享一个虚拟地址空间

    2. 线程间的数据访问变得更加简单，因此数据访问安全问题更加突出，要考虑的问题增多，编码难度增加

    3. 一些系统调用和异常都是针对整个进程的，因此当一个线程中出现了异常，那么整个进程都会崩溃，以及一些系统调用的使用也要注意

  • 进程的优点：安全，稳定（因为进程的独立性）

进程ID和线程ID

每一个用户态的线程，在内核中都有一个调度实体，也拥有自己的描述符，即task_struct结构体，在task_struct有一个成员叫PID这个是进程PID，但是现在看进程的话，一个进程中有可能会有多个进程，也就是说会有多个PID

因为现在的进程是线程组，其实在每一个task_struct都有一个标识说他们是哪个线程组的线程，这个成员叫TGID即线程组ID

然而这个线程组ID（TGID）其实等于进程中主线程（首线程）task_struct中的PID，

而用户态ps -ef显示的进程信息其实是首线程信息，通过ps -efL查看进程内的所有线程信息

LWP---轻量级进程，这一列记录的就是每个线程task_struct中的pid

NLWP--线程组内线程的个数

PID--用户态展现出来的PID这一列其实显示的是TGID的值

struct task_struct
{
    pid_t pid;
    pid_t tgid;
    .....
    struct task_struct *group_leader;
    .....
    struct list_head thread_group;
    .....
}

线程控制

    操作系统并没有提供系统调用来创建线程，所以就在posix标准库中，实现的一套线程控制（创建/终止/等待..）的接口

    因为这套接口创建的线程是库函数(以pthreaed_ 开头)，是用户态的线程创建，因此创建的线程也叫用户线程

   在操作系统内部，一个用户线程对应了一个轻量级进程来进行调度运行

线程创建

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,

                          void *(*start_routine) (void *), void *arg);

  • 功能：线程的创建（创建用户线程），并且通过第一个参数返回了一个用户线程ID

  • thread：用于接收一个用户线程ID，其实是一个指向线程自己的线程地址空间在整个进程虚拟地址空间中的位置

  • attr：用于设置线程属性，一般置NULL

  • start_routine：线程的入口函数，线程运行的就是这个函数，这个函数退出了，线程也就退出了

  • arg：用于给线程入口函数传递参数

  • 返回值：0-成功，errno-失败

每一个线程都需要有自己的栈区，否则如果所有线程公用一个栈的话，会引起调用栈混乱，并且因为CPU是以PCB来调度的，因此线程是CPU调度的基本单位，所以每个线程也都应该有自己的上下文数据来保存CPU调度切换时的数据。（而这些都是在线程地址空间中，每一个线程都有自己的线程地址空间，他们相对来说独立，但是因为线程地址空间是在虚拟地址空间内的）

 

线程没有父子之分，所有的线程都是平级的，如果非要说有区别那么就是主线程与其它线程之分。    

pthread_t pthread_self(void)

获取调用现成的线程id（用户态线程id）

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <errno.h>
  5 #include <string.h>
  6 #include <pthread.h>
  7 
  8 void* thr_start(void *arg)
  9 {
 10     int num = (int)arg;
 11     
 12     while(1) {
 13         printf("talk with girl friend:%d\n", num);
 14         sleep(1);
 15     }   
 16     return NULL;
 17 }   
 18 int main()
 19 {
 20     //int pthread_create(pthread_t *thread, pthread_attr_t *attr,
 21     //      void *(*start_routine) (void *), void *arg);
 22     //  功能：线程的创建（创建用户线程）
 23     //  thread: 用于接收一个用户线程ID
 24     //  attr：  用于设置线程属性，一般置NULL
 25     //  start_routine：线程的入口函数
 26     //      线程运行的就是这个函数，这个函数退出了，线程也就退出了
 27     //  arg：   用于给线程入口函数传递参数
 28     //  返回值：0-成功      errno-失败
 29     pthread_t tid;
 30     int ret;
 31     ret = pthread_create(&tid, NULL, thr_start, (void*)999);
 32     if (ret != 0) {
 33         perror("pthread_create error");
 34         return -1;
 35     }
 36     //pthread_t pthread_self(void);
 37     //  获取调用线程的线程id（用户态线程id）
 38     printf("main thread id:%p\n", pthread_self());
 39     printf("child pthread id:%p\n", tid);
 40     while(1) {
 41         printf("play game!!\n");
 42         sleep(1);
 43     }
 44     return 0;

线程终止：线程的退出

线程退出的方式

  1. return退出：在线程中可以调用return退出，但是在main函数中调用return效果是退出进程

  2. 线程可以调用pthread_exit终止自己

    • #include <pthread.h>

    • void pthread_exit(void *retval);

    • 谁调用谁退出，退出的是线程，无返回值

    • pthread_exit或return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针的时候线程函数已经退出了

  3. 一个线程可以调用pthread_cancel终止同一进程中的另一个进程

    • #include <pthread.h>

    • int pthread_cancel(pthread_t thread);

  •  取消线程id为thread的线程，即让thread线程退出

  • 返回值为-1 

      1 /*  这段代码用于演示线程退出的几种方式
  2  */
  3 
  4 #include <stdio.h>
  5 #include <unistd.h>
  6 #include <stdlib.h>
  7 #include <pthread.h>
  8 
  9 //线程 的退出演示1：return
 10 void *thr_start(void *arg)
 11 {
 10 void *thr_start(void *arg)
 11 {
 12     //1. 在线程中调用exit函数会怎样？--直接退出进程
 13     //  进程要是退出了，那么进程中的所有线程也就退出了
 14     //exit(0);
 15 
 16     while(1) {
 17         printf("child pthread!!\n");
 18         sleep(1);
 19     }
 20     return NULL;
 21 }
 22 int main()
 23 {
 24     pthread_t tid;
 25     int ret = -1;
 26 
 27     ret = pthread_create(&tid, NULL, thr_start, NULL);
 28     if (ret != 0) {
 29         printf("pthread_create error\n");
 30         return -1;
 31     }
 32     //pthread_exit(NULL);
 33     //int pthread_cancel(pthread_t thread);
 34     //  取消线程id为thread的线程，即让thread线程退出
 35     pthread_cancel(tid);
 36     while(1) {
 37         printf("main thread!!!\n");
 38         sleep(1);
 39     }

线程等待

为什么要线程等待？等待到底是干什么？

线程退出实际上也会形成僵尸线程占用了一部分资源不释放，最终造成资源泄露

线程等待就是接收线程的返回值，然后释放线程的所有资源

#include <pthread.h>

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

  • 功能：等待指定的线程并获取返回值，避免资源泄露

  • thread：用于指定等待哪个线程

  • retval：用于接收线程的返回值

  • 如果调用join函数的时候线程已经退出了，那么将直接返回，否则将陷入阻塞等待，直到这个指定的线程退出

线程有一个属性：joinable

  • 如果线程的属性是处于joinable状态，代表这个线程退出后需要被别人等待

  • 一个线程只有处于joinable状态，才能被等待

  • 一个线程创建出来后，默认属性就是joinable状态

  • 而这个等待就是获取线程的返回值，并释放线程资源

  • 如果一个线程是被取消的，那么它的返回值是-1，PTHREAD_CANCELD

 1 /*  这是一段演示线程等待获取线程返回值的代码
  2  *  如何线程等待？
  3  *      int pthread_join(pthread_t thread, void **retval);
  4  *  线程有一个属性：joinable
  5  *      如果线程的属性是处于joinable状态，代表这个线程退出后需要被
  6  *      别人等待。
  7  *      一个线程只有处于joinable状态，才能被等待
  8  *      一个线程创建出来后，默认属性就是joinable状态
  9  *      而这个等待就是获取线程的返回值，并释放线程资源
 10  */
 11 
 12 #include <stdio.h>
 13 #include <unistd.h>
 14 #include <stdlib.h>
 15 #include <string.h>
 16 #include <pthread.h>
 17 
 18 void *thr_start(void *arg)
 19 {
 20     sleep(1);
 21     pthread_exit("to be bit people!!");
 22     return "hello bit!!!\n";
 23 }
 24 int main()
 25 {
 26     pthread_t tid;
 27 
 28     int ret = pthread_create(&tid, NULL, thr_start, NULL);
 29     if (ret != 0) {
 30         printf("pthread_create error\n");
 31         return -1;
 32     }
 33     //int pthread_join(pthread_t thread, void **retval);
 34     //  等待指定的线程并获取返回值
 35     //  thread：    用于指定等待哪个线程
 36     //  retval：    用于接收线程的返回值
 37     //  如果调用join函数的时候线程已经退出了，那么将直接返回，否则
 38     //  将陷入阻塞等待，直到这个指定的线程退出
 39     pthread_cancel(tid);
 40     sleep(5);
 41     char *ptr;
 42     pthread_join(tid, (void **)&ptr);
 43     printf("child thread say:%d\n", (int)ptr);
 44     return 0;
 45 }

线程分离

我们等待一个线程是因为需要获取线程的返回值，并释放资源，那么假如我根本不关心返回值，那么这个等待将毫无意义仅仅是为了释放资源，因此就有了一个线程属性叫：线程分离属性    detach属性，这个属性需要设置，他是告诉操作系统，这个指定的线程我不关心返回值，所以如果退出了，就自动把所有资源回收。

而设置一个线性分离属性我们常称为 分离线程

线程的detach属性与joinable属性相对应，也相冲突，两者不会同时存在。如果一个线程属于detach，那么调用pthread_join的时候将直接报错，所以我们在上边说，只有一个线程处于joinable状态才可以被等待

#include <pthread.h>

int pthread_detach(pthread_t thread);

  • 功能：分离指定的线程

  • 这个分离后的线程退出后将自动回收资源

  • pthread_detach并不会阻塞，只是设置了一个线程属性

1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <errno.h>
  5 #include <string.h>
  6 #include <pthread.h>
  7 
  8 void* thr_start(void *arg)
  9 {
 10     int num = (int)arg;
 11 
 12     pthread_detach(pthread_self());
 13     while(1) {
 14         printf("talk with girl friend:%d\n", num);
 15         sleep(1);
 16     }
 17     return NULL;
 18 }
 19 int main()
 20 {
 21     pthread_t tid;
 22     int ret;
 23     ret = pthread_create(&tid, NULL, thr_start, (void*)999);
 24     if (ret != 0) {
 25         perror("pthread_create error");
 26         return -1;
 27     }
 28     //int pthread_detach(pthread_t thread);
 29     //  分离指定的线程
 30     //  这个分离后的线程退出后将自动回收资源
 31     //  pthread_detach并不会阻塞,只是设置了一个线程属性
 32     pthread_detach(tid);
 33     printf("main thread id:%p\n", pthread_self());
 34     printf("child pthread id:%p\n", tid);
 35     while(1) {
 36         printf("play game!!\n");
 37         sleep(1);
 38     }
 39     return 0;
 40 }

故渊~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程终止的三种方式
聆听。。花开雨落的博客
04-28 1563
文章目录 0.准备演示Demo （1 和 2共用 Demo） 1.线程终止方式--Stop() 2.线程终止方式--interrupt() 3.线程终止方式--标志位0.准备演示Demo （1 和 2共用 Demo） public class StopThread extends Thread { private int i = 0, j = 0; @Override public void run() { synchronized (this) { // 增加同步锁...
4.如何终止线程
纵横千里 捭阖四方 的专栏
08-24 4752
本文介绍了线程终止的问题 ，特别是阻塞线程的终止。主线程想让子线程停止要通过interrupt给子线程发一个信号，告诉要中断了，而不是强制将其中断。触发复位是为了让子线程保持原来的状态，是否中断则有子线程在catch中决定。如果不处理就不中断，如果要中断就是再执行一次Thread.currentThread().interrupt();
【JavaEE】多线程的等待与状态
2301_78373304的博客
05-02 1030
先创建thread1线程，再创建thread2线程，thread1没有阻塞直接执行代码，而thread2遇到阻塞，等待thread1执行完毕之后，thread2解除阻塞，由于main线程阻塞，所以要等待thread2线程执行完毕，当thread2线程执行完毕之后，main线程解除阻塞，执行main线程中的代码。join()方法是Thread类的一个方法，用于让一个线程等待另一个线程执行结束，当一个线程调用join()方法时，当前线程就会阻塞，直到被调用的线程执行结束。指的是，这个线程“随叫随到”，
C++11线程学习（1）—— 创建+分离+分配+线程ID
Frankiehp的博客
05-26 1157
1, 创建一个线程 1.1 可以通过函数指针创建 #include <thread> #include <iostream> static void worker1(){ for (int i = 0; i < 10; ++i) { std::cout << "worker " << i << std::endl; } } int main() { std::thread t1 = std::thread(worker1
运行中的线程如何停止？
weixin_49100429的博客
07-26 3029
停止一个线程意味着在任务处理完任务之前停掉正在做的操作，也就是放弃当前的操作。停止一个线程可以用Thread.stop()方法，但最好不要用它。虽然它确实可以停止一个正在运行的线程，但是这个方法是不安全的，而且是已被废弃的方法。在java中有以下3种方法可以终止正在运行的线程： 1、使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2、使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。 3、使用interrupt方法中断线程
深入分析父子线程、进程终止顺序不同产生的结果
09-05
默认情况下，创建线程的父线程负责子线程的资源回收。这意味着，如果父线程提前终止，子线程也将随之退出，除非父线程事先通过`pthread_detach()`函数将子线程设置为分离状态。在分离状态下，子线程结束后，系统会...
分离状态创建线程
09-10
在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。一个可结合的线程能够被其他线程收回其...相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。
C++多线程的创建、终止.、连接和分离线程等pdf
最新发布
05-15
多线程
E05_多线程复习.pdf
11-02
3. **线程创建** - **方式一：继承Thread类** - 定义子类继承Thread类。 - 重写run()方法，定义线程任务。 - 创建子类对象并调用start()方法启动线程。 - **方式二：实现Runnable接口** - 定义类实现Runnable...
linux系统编程之线程.zip
05-05
调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下： 1. 如果thread线程通过return返回，retval所指向的单元里存放的是thread...
线程的终止分离
qq_41027326的博客
04-18 311
1.线程的终止                      注意该函数是针对用户级别的, 其中 retal 必须指向一个全局变量, 或者是一个 malloc 分配的, 因为如果是线程的局部变量, 当该线程退出时, 其他线程不能得到这个变量, 因为线程的局部变量各自私有 2. 现成的取消                      其中thread是线程的 tid 3.线程的等待与分...
Java多线程之线程停止的正确方式
热门推荐
dh2580
08-17 1万+
    在开发中，经常会遇到需要停止一个正在运行的线程的场景，以前的做法是通过Thread.stop() 的方式来停止具体的线程，但是这个方法目前是被废弃掉的，不推荐使用。不推荐使用的原因如下： 1、该方式是通过立即抛出ThreadDeath异常来达到停止线程的目的，而且此异常抛出可能发生在程序的任何一个地方，包括catch、finally等语句块中。 2、由于抛出ThreadDeatch异常...
25-线程终止详解
网络安全
09-20 654
1. 线程终止 线程的终止包括主动终止和被动终止两大类。 主动终止：   线程主函数执行return正常返回，返回值是线程的退出码。   线程主函数执行pthread_exit函数退出，其参数是一个传出参数，保存线程退出码 被动终止：   在同一进程中其他线程调用pthread_cancel函数   任意线程调用了exit、_Exit、_exit 导致整个进程终止，又或者主线程在main函数中执行...
JAVA语言深入--多线程
02-12
线程可以通过start方法启动，run方法执行线程的任务，而当run方法执行完毕或调用stop方法时线程终止。对于长时间运行的线程，我们也可以通过调用interrupt方法来中断线程的执行。 总之，多线程编程是Java语言中一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值