LINUX下的进程与线程

最新推荐文章于 2024-09-27 21:56:37 发布
最新推荐文章于 2024-09-27 21:56:37 发布
阅读量471 收藏 2
点赞数 1
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flora_SM/article/details/105586888
版权

文章目录

1.系统的启动运行进程
  • 当用户进程init开始运行，就开始扮演用户进程的祖先角色，永远不会被终止。
  • 所以：计算机上的所有进程都是有上下亲属关系的，他们组成一个庞大的家族树。

※ 观察linux下的进程间父子关系:

  • pstree
    以树状结构方式列出系统中正在运行的各进程间的父子关系。
  • ps ax -o pid,ppid,command
    在这里插入图片描述
2. 基本进程编程

在这里插入图片描述

(1)新建进程——fork
  • pid_t fork(void);
  • 一次克隆，两个返回值
  • 两个执行线路
//示例1：执行一次fork语句，父亲睡眠2秒
[flora@localhost ~]$ vi fork_1.c
[flora@localhost ~]$ gcc -o myfork_1 fork_1.c
[flora@localhost ~]$ cat fork_1.c 
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(void){
    pid_t pid;
    char *message;
    int x; 
    pid = fork(); 
        if (pid < 0)
         {   perror("fork failed");
             exit(1);    }
        if (pid == 0) 
         {   message = "This is the child\n";
             x = 0;  } 
        else 
         {   message = "This is the parent\n";              
             x = 10;
             sleep(2);     }   //注意
        printf("%s I'm %d, x=%d，my father is:%d\n",message,getpid(),x,getppid());
        return 0;
} 
[flora@localhost ~]$ ./myfork_1 
This is the child
 I'm 3928, x=0，my father is:3927
This is the parent
 I'm 3927, x=10，my father is:2725

上例运行结果：先输出孩子语句，等待两秒后输出父亲语句。

//示例2：执行一次fork语句，孩子睡眠2秒
[flora@localhost ~]$ vi fork_2.c
[flora@localhost ~]$ cat fork_2.c
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(void){
    pid_t pid;
    char *message;
    int x; 
    pid = fork();
    if (pid < 0)
       {   perror("fork failed");
           exit(1);    }
    if (pid == 0) 
       {   message = "This is the child\n";             
           x = 0;   
           sleep(2);     }    //注意
    else 
       {   message = "This is the parent\n";
           x = 10;
                         }
      printf("%s I'm %d, x=%d，my father is:%d\n",message,getpid(),x,getppid());      return 0;
}
[flora@localhost ~]$ gcc -o myfork_2 fork_2.c 
[flora@localhost ~]$ ./myfork_2
This is the parent
 I'm 3168, x=10，my father is:3084
[flora@localhost ~]$ This is the child
 I'm 3169, x=0，my father is:1
ps
   PID TTY          TIME CMD
  2721 pts/0    00:00:00 bash
  2893 pts/0    00:00:00 bash
  3084 pts/0    00:00:00 bash
  3179 pts/0    00:00:00 ps

上例结果分析：先输出父亲语句，父亲语句执行完后，bash获得了cpu,把命令行输出了一下，然后孩子睡两秒后输出语句。
注意：可以看到父亲的父亲是bash,而孩子的父亲是1（因为父亲执行完后就结束了，孩子睡完再执行时，孩子的父亲就是祖先进程了，由祖先进程回收进程）

注意：当循环语句中含fork语句时，循环n次，则有2^n个进程。
但是当子进程中含有while语句时情况则不同，如下图：
在这里插入图片描述
产生的进程数：循环n次，则有n个子进程，再加一个父进程（因为由于fork语句产生的新子进程中有while语句，所以当执行子进程时就会一直while下去，后续就不再执行fork语句循环产生新的子进程了）

(2）执行新工作——exec
  • int execve()是最根本的系统调用
  • 需要路径、命令行参数、和环境变量三种参数
    在这里插入图片描述

在这里插入图片描述

  • p:利用PATH环境变量查找可执行的文件；
  • l:希望接收以逗号分隔的形式传递参数列表，列表以NULL指针作为结束标志；
  • v：希望以字符串数组指针（ NULL结尾）的形式传递命令行参数；
  • e:传递指定参数envp，允许改变子进程的环境，后缀没有e时使用当前的程序环境

注意：只有execve是系统调用；其他函数调用最终都由execve完成工作。无论是哪个exec类函数，都是将要执行程序的路径、命令行参数、和环境变量3个参数传递给execve

示例：

[flora@localhost ~]$ vi forkexec_1.c
[flora@localhost ~]$ cat forkexec_1.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(void){
    pid_t a;
    a = fork();
    if (a < 0)  {
        perror("fork failed");
        exit(1);  
    }
    if (a == 0) {
        execlp ("ps" ,"ps",NULL);   
        execlp ("ls" ,"ls","-al","/etc/passwd ",NULL); 
        return 1;
    } 
    else    {
        wait(NULL);
        printf("father exit\n");
    }
    return 0;
}
[flora@localhost ~]$ gcc -o myforkexec_1 forkexec_1.c 
[flora@localhost ~]$ ./myforkexec_1 
   PID TTY          TIME CMD
  2721 pts/0    00:00:00 bash
  2893 pts/0    00:00:00 bash
  3084 pts/0    00:00:00 bash
  6591 pts/0    00:00:00 myforkexec_1
  6592 pts/0    00:00:00 ps
father exit

上例结果分析：因为父进程有wait语句，相当于阻塞态，所以cpu会先给孩子进程，执行第一条execlp语句，但是当执行完这条语句后，已经覆盖掉了孩子进程中的代码，所以不会执行后续的指令了，当孩子进程执行完后，系统会触发刚才的父亲进程，父亲进程被唤醒，输出它的语句。

注意：

  • exec函数执行成功会装入新代码，原来的代码在其进程空间中已不存在。
  • 只有exec调用失败返回-1，其后的代码才有可能得到执行。

拓展：若修改子进程代码：在开始时加入输出语句

if (a == 0) {
        printf("I am child\n");
        execlp ("ps" ,"ps",NULL);   
        execlp ("ls" ,"ls","-al","/etc/passwd ",NULL); 
        return 1;
    }

则结果如下图：
在这里插入图片描述

(3）进程的消亡——exit
  • void exit(int status);
  • 需要路径、命令行参数、和环境变量三种参数

注意：程序执行结束或调用exit后并不是马上消失，而是变为僵死状态——放弃了几乎所有内存空间，不再被调度，但保留有PCB信息供wait收集。

示例：注意要想看子进程的僵死态，必须让父进程睡眠一段时间，否则父进程结束后，就只能由祖先进程回收子进程，就看不到僵死态了

[flora@localhost ~]$ vi fork_1.c
[flora@localhost ~]$ cat fork_1.c
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(void){
    pid_t pid;
    char *message;
    int x; 
    pid = fork();
        if (pid < 0)
         {   perror("fork failed");
             exit(1);    }
        if (pid == 0) 
         {   message = "This is the child\n";
             x = 0;  } 
        else 
         {   message = "This is the parent\n";              
             x = 10;
             sleep(20);     }
        printf("%s I'm %d, x=%d，my father is:%d\n",message,getpid(),x,getppid());
        return 0;
} 
[flora@localhost ~]$ gcc fork_1.c
[flora@localhost ~]$ ./a.out&    //注意：&使进程在后台执行
[1] 7202
[flora@localhost ~]$ This is the child
 I'm 7203, x=0，my father is:7202
ps -x|grep a.out    //此时父亲在睡眠，此契机下，用ps命令观察子进程死亡前状态
  7202 pts/0    S      0:00 ./a.out            //睡眠态
  7203 pts/0    Z      0:00 [a.out] <defunct>  //僵死态
  7205 pts/0    R+     0:00 grep --color=auto a.out
[flora@localhost ~]$ This is the parent   //父亲睡眠后返回，打印其输出
 I'm 7202, x=10，my father is:3084
 
 [1]+  完成                  ./a.out
(4）进程间的等待——wait
  • pid_t wait(int *status)
  • 使调用它的进程等待，进入阻塞状态
  • 子进程死亡会唤醒阻塞的父进程（但注意：一个孩子只能唤醒一次父亲，如果有多个孩子的话，则需要加多个wait语句）

示例：
在这里插入图片描述

[flora@localhost ~]$ vi forkwait_cp.c
[flora@localhost ~]$ cat forkwait_cp.c
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main(){
    pid_t pc1,pc2,pw1,pw2;
    pc1=fork();
    pc2=fork();
    if (pc1>0&&pc2>0) {     //*父进程
        pw1=wait(NULL);
        printf("***Catch a dead child process with pid: %d\n",pw1);
        pw2=wait(NULL);
        printf("***Catch a dead child process with pid: %d\n",pw2);
        printf("***I'M %d,THE MAIN PROCESS LEAVE!\n",getpid()); \
    }
    if (pc1==0&&pc2>0) {        //*子进程1
        printf("I'M the first child PID:%d,my father is:%d\n",getpid(),getppid());
        sleep(10);               
    }
    if (pc1>0&&pc2==0)          //*子进程2
        printf("I'M the 2nd child PID:%d,my father is:%d,i don't sleep.\n",getpid(),getppid());
    if (pc1==0&&pc2==0)         //*孙进程
        printf("I'M grandson PID:%d,my father is:%d,no one is waiting for – me.\n",getpid(),getppid());
    
    exit(0);    
}   
[flora@localhost ~]$ gcc forkwait_cp.c -o myforkwait_cp
[flora@localhost ~]$ ./myforkwait_cp
I'M the 2nd child PID:7852,my father is:7850,i don't sleep.
***Catch a dead child process with pid: 7852
I'M the first child PID:7851,my father is:7850
I'M grandson PID:7853,my father is:7851,no one is waiting for – me.
***Catch a dead child process with pid: 7851
***I'M 7850,THE MAIN PROCESS LEAVE!

上例结果分析：
可以看出由于父进程有wait语句，所以cpu会先给子进程，而子进程1有睡眠时间，因此子进程2会先输出执行，结束后会唤醒一次父进程，输出对应的语句；然后由于父进程还有一个wait语句，所以子进程1和孙进程会先后执行输出对应的语句，停顿10s后，子进程1结束再次唤醒父进程，输出对应语句，最后再输出自己的语句，而孙进程则由祖先进程回收。

Flora_M
关注
专栏目录
Linux讲解 进程线程
Hanani_Jia的博客
10-15 406
  我们之前在Linux中引入了进程的概念，今天我们就在仔细的分析一下什么是进程，什么是线程，进程和线程之间有什么关系。   现在有两个程序一个是小红，一个是小蓝。   在计算机发展初期的时候，CPU是一个很稀缺的资源，他们两个必须轮流使用，只有小红执行结束之后，让出CPU，小蓝才能从头开始运行。人们把这种方式叫做批处理。     慢慢的，随着计算机的不断发展，CPU的处理能力越来越快了，...
Linux中进程和线程的对比与区别
09-15
在Linux操作系统中，进程和线程是两种不同的执行单元，它们在系统中有着各自的特点和作用。理解这两者的差异对于优化程序性能、管理和调度系统资源至关重要。 首先，让我们来看看进程和线程的概念： **进程...
linux下进程和线程
ptgood的博客
07-30 206
前言 学习自用,这篇还比较没头绪,标题和内容很难对上 问题 子进程能继承父进程的什么东西？不能继承父进程的什么东西？ fork以后会生成一个task_struct,还会修改页表吧,每个线程还都有自己的thread_info,在栈的底部(应该是线程栈吧),其中有一个成员指针指向task_struct 信号处理函数不能继承,毕竟在子进程里对应的处理函数的地址是无效的(来自APUE),未决信号集也是不能继承的, 而task_struct存有被阻塞的信号集 线程独立的资源 linux内核并没有.
Linux进程管理（一）进程与线程基础
最新发布
weixin_44555799的博客
09-27 796
线程被设计成进程的一个执行路径，同一个进程中的线程共享进程的资源，线程是进程的一部分，描述指令流执行状态，它是进程中的指令执行流的最小单元，是CPU调度的基本单位，因此系统对线程的调度所需的成本远远小于进程。进程与线程的区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位。一个进程至少有一个线程，线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。每个进程都有独立的地址空间，进程之间的切换会有较大的开销；
Linux操作系统中的进程、线程
lllee111的博客
02-25 841
• 线程是操作系统执行调度的基本单位。每一个线程可以执行一个任务（一段代码）。 • 进程和线程是包含关系，进程包含线程。我们可以用工厂和生产线来理解进程和线程。 为了提高生产效率，我们有两种方法： 1.增设工厂：增设工厂，多个工厂同时工作，工作效率就提高了，这就相当于创建多个进程，多个进程同时执行，执行速度自然比一个进程单独执行要快。 2. 在工厂内部增加生产线：多条生产线当然要比一条生产线工作效率高，这就相当于创建多条线程。
Linux的线程与进程
weixin_43557605的博客
09-21 538
进程（process）和线程（thread）是操作系统的基本概念，但是它们比较抽象，不容易掌握下面以一个类比，把它们解释地清晰易懂。 计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。 2.假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。 3.进程就好比工厂的车间，它代表...
linux线程与进程
weixin_42271802的博客
01-01 1071
在Linux系统中，进程（Process）和线程（Thread）是操作系统中两个重要的概念，它们都是用于执行程序的执行单元，但有一些关键的区别。
linux下的C\C++多进程多线程编程实例详解
09-15
### Linux下的C/C++多进程多线程编程实例详解 #### 一、多进程编程 在Linux环境下，多进程编程是实现并发处理的一种常见方法。通过`fork()`系统调用，我们可以创建一个新的进程，该进程几乎复制了父进程的所有属性...
Linux下的LWP（轻量级进程）、进程、线程、用户级线程、内核线程
01-27
本文主要讲解了Linux下的LWP（轻量级进程）、进程 、线程、用户级线程、内核线程的概念、区别与联系、优缺点、发展等相关内容。 本文来自于CSDN，由火龙果软件Linda编辑、推荐。 再看正文之前我要先强调一下几点： ...
【Linux】线程（轻量级进程）
muyuteacher的博客
07-07 764
线程概念、特性、优点、缺点、异常、用途，进程和线程的对比、线程控制、包含线程的编译链接、创建线程、获得线程自身的ID、线程终止、线程等待、线程分离、线程ID及进程地址空间布局、重谈文件系统（地址空间、页表、物理内存）、Linux线程互斥、进程线程间的互斥相关背景概念、互斥量mutex、互斥量的接口、互斥量的实现原理探究、可重入和线程安全的概念、可重入和线程安全的各种情况、死锁、Linux线程同步、条件变量、同步概念与竞态条件，条件变量函数，生产者消费者模型，基于BlockingQueue的生产者消费者模型
Linux中的线程与进程
Free雅轩的博客
10-15 2366
前面我们看到，进程和线程创建都是调用内核中的 do_fork 函数来执行的。和 copy_files 函数类似，在 copy_fs 中如果指定了 CLONE_FS（创建线程的时候），并没有真正申请独立的 fs_struct 出来，近几年只是在原有的 fs 里的 users +1 就算是完事。从代码看出，如果指定了 CLONE_FILES（创建线程的时候），只是在原有的 files_struct 里面 +1 就算是完事了，指针不变，仍然是复用创建它的进程的 files_struct 对象。
Linux——进程、线程
wei
06-22 1496
Q&A 进程的六种状态及其转换过程（生命周期）——就绪态，运行态，深度睡眠态，浅睡眠态，停止态，僵尸态。 进程的生命周期，就绪态和运行态在数值上是相等的，都是由宏TASK_RUNNING定义。 Linux中Task_struct是如何被管理的呢？ 理解僵尸进程——放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置（资源已经释放，Task_struct结构还在）。如果他的父进程没安装SIGCHLD信号处理函数调用wait()/waitpid()等待子进程结束，又没
linux进程 线程详解
m0_49133355的博客
07-25 954
在 Linux 操作系统中，进程是执行中的程序的实例。理解进程及其管理是系统编程、性能调优和系统管理的基础。以下是对 Linux 进程的详细介绍，包括进程的基本概念、生命周期、管理以及常用的命令和工具。基本概念进程（Process）：进程是程序在执行中的实例。每个进程都有一个唯一的进程标识符（PID）以及一组资源（如内存、文件描述符等）。线程（Thread）：线程是进程内的一个执行单元。一个进程可以包含多个线程，共享进程的资源和内存。
linux 进程和线程
日积月累
03-01 133
一、进程是操作系统分配资源的基本单位，线程是任务调度的基本单位 二、进程视图 参考： https://www.cnblogs.com/lovemdx/p/3308057.html
linux中进程与线程
wanger5354的博客
02-07 2825
进程进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中
Linux系统中的进程与线程
Snow_233的博客
11-12 532
Linux进程与线程的区别在于，进程是操作系统资源分配的基本单位，而线程是进程内的执行单位。 一个进程可以包含多个线程，它们共享进程的资源，如内存空间、文件句柄等。 线程之间的切换比进程之间的切换更快，因为它们共享同一进程的地址空间，不需要进行上下文切换和资源分配。
【Linux进程、线程、任务调度】二 fork/vfork与写时拷贝 线程的本质 托孤 进程睡眠和等待队列
厚积薄发
10-13 6647
上一篇文章 点击链接【Linux进程、线程、任务调度】一 讲了 Linux进程生命周期（就绪、运行、睡眠、停止、僵尸） 僵尸的含义 停止状态与作业控制， cpulimit 内存泄漏的真实含义 task_struct以及task_struct之间的关系 初见fork和僵尸 本篇接着上一篇文章主要记录以下学习内容： fork vfork clone 的含义 写时拷贝技术 Linux线程的实...
linux 进程 线程 详解,linux进程与线程详解
weixin_39645249的博客
04-28 135
多线程和多进程，无论在嵌入式领域，还是应用开发领域，都是不可避免要设计和使用的。那什么是线程，什么是进程，他们之间有什么区别呢？进程和线程各自优缺点1.进程的优点1)健壮性比线程好；2)由于进程间各自互相独立，所以如果多进程程序设计，当有一个进程挂掉的时候，不会影响其他进程的执行。2.进程的缺点1)创建进程比创建线程会消耗更多的系统性能；2)由于进程创建需要系统分配更多的资源，所以创建会更加复杂；...
linux中的进程与线程,linux 进程与线程
weixin_34079177的博客
04-28 200
Linux的每个进程(除了init进程以外)都依赖于一个父进程, 内核启动init作为第一个进程.创建进程的方式有两种, 一种是fork,一种是execfork会生成一个父进程的副本,父进程和子进程只有PID不同,不过linux采用了一种copy on write 写时复制 的策略来使fork更加高效, 内存复制操作会被延迟到父进程或子进程向内存写入数据之前, 如果不需要写入, 父进程和子进程将一...
Linux下进程与线程详解：C编程基础与多任务协作
本文档深入探讨了Linux平台下的C编程中的进程与线程概念，以及其在Unix/Linux核心编程课程中的重要性。首先，我们从进程的角度出发，解释了进程是操作系统中的基本执行单元，它是资源分配的主要单位。进程的上下文...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值