精华内容
下载资源
问答
  • linux 学习day03 进程相关概念
    2022-03-27 14:06:03

    文章目录

    操作系统(Operator System)

    概念

    任何计算机系统都包含一个基本的程序集合,称为操作系统(OS)。笼统的理解,操作系统包括:
    内核(进程管理,内存管理,文件管理,驱动管理)
    其他程序(例如函数库,shell程序等等)
    

    设计OS的目的

    与硬件交互,管理所有的软硬件资源
    为用户程序(应用程序)提供一个良好的执行环境

    定位

    在整个计算机软硬件架构中,操作系统的定位是:一款纯正的“搞管理”的软件

    如何理解 “管理”

    管理的例子
    描述被管理对象
    组织被管理对象

    总结

    计算机管理硬件
    1. 描述起来,用struct结构体
    2. 组织起来,用链表或其他高效的数据结构

    系统调用和库函数概念

    在开发角度,操作系统对外会表现为一个整体,但是会暴露自己的部分接口,供上层开发使用,这部分
    由操作系统提供的接口,叫做系统调用。
    系统调用在使用上,功能比较基础,对用户的要求相对也比较高,所以,有心的开发者可以对部分系统
    调用进行适度封装,从而形成库,有了库,就很有利于更上层用户或者开发者进行二次开发。

    进程

    基本概念

    课本概念:程序的一个执行实例,正在执行的程序等
    内核观点:担当分配系统资源(CPU时间,内存)的实体。

    描述进程-PCB

    进程信息被放在一个叫做进程控制块的数据结构中,可以理解为进程属性的集合。
    操作系统上称为 PCB(process control block),Linux操作系统下的PCB是: task_struct
    
    task_struct 是 PCB的一种
    在Linux中描述进程的结构体叫做task_struct。
    task_struct是Linux内核的一种数据结构,它会被装载到RAM(内存)里并且包含着进程的信息。
    
    task_ struct内容分类
    	标示符: 		描述本进程的唯一标示符,用来区别其他进程。
    	状态: 		任务状态,退出代码,退出信号等。
    	优先级: 		相对于其他进程的优先级。
    	程序计数器: 	程序中即将被执行的下一条指令的地址。
    	内存指针: 	包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针。
    	上下文数据: 	进程执行时处理器的寄存器中的数据[休学例子,要加图CPU,寄存器]。
    	I/O状态信息: 包括显示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表。
    	记账信息: 	可能包括处理器时间总和,使用的时钟数总和,时间限制,记账号等。
    	其他信息
    
    

    组织进程

    可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。
    

    查看进程

    进程的信息可以通过/proc系统文件夹查看
    如:要获取PID为 1 的进程信息,你需要查看/proc/1这个文件夹。
    
    大多数进程信息同样可以使用top和ps这些用户级工具来获取
    

    通过系统调用获取进程标示符

    进程id(PID)
    父进程id(PPID

    通过系统调用创建进程-fork初识

    运行man fork认识fork
    fork有两个返回值
    父子进程代码共享,数据各自开辟空间,私有一份(采用写时拷贝)
    
    fork 之后通常要用if进行分流
    
    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    	int main(){
    		while(1){
    		sleep(1);
    	}
    		return 0;
    	}
    
    	#include <stdio.h>
    	#include <sys/types.h>
    	#include <unistd.h>
    	
    	int main(){
    		printf("pid: %d\n", getpid());
    		printf("ppid: %d\n", getppid());
    		return 0;
    	}
    
    	#include <stdio.h>
    	#include <sys/types.h>
    	#include <unistd.h>
    	
    	int main(){
    		int ret = fork();
    		printf("hello proc : %d!, ret: %d\n", getpid(), ret);
    		sleep(1);
    		return 0;
    	}
    

    进程状态

    为了弄明白正在运行的进程是什么意思,我们需要知道进程的不同状态。一个进程可以有几个状态(在
    Linux内核里,进程有时候也叫做任务)。 下面的状态在kernel源代码里定义:
    

    R运行状态(running): 并不意味着进程一定在运行中,它表明进程要么是在运行中要么在运行队列
    里。

    S睡眠状态(sleeping): 意味着进程在等待事件完成(这里的睡眠有时候也叫做可中断睡眠
    (interruptible sleep))。

    D磁盘休眠状态(Disk sleep)有时候也叫不可中断睡眠状态(uninterruptible sleep),在这个状态的
    进程通常会等待IO的结束。

    T停止状态(stopped): 可以通过发送 SIGSTOP 信号给进程来停止(T)进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。

    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    int main(){
    	int ret = fork();
    		if(ret < 0){
    		perror("fork");
    		return 1;
    	}
    	else if(ret == 0){ //child
    		printf("I am child : %d!, ret: %d\n", getpid(), ret);
    	}else{ //father
    		printf("I am father : %d!, ret: %d\n", getpid(), ret);
    	}
    	sleep(1);
    	return 0;
    }
    
    /*
    * The task state array is a strange "bitmap" of
    * reasons to sleep. Thus "running" is zero, and
    * you can test for combinations of others with
    * simple bit tests.
    */
    static const char * const task_state_array[] = {
    "R (running)", /* 0 */
    "S (sleeping)", /* 1 */
    "D (disk sleep)", /* 2 */
    "T (stopped)", /* 4 */
    "t (tracing stop)", /* 8 */
    "X (dead)", /* 16 */
    "Z (zombie)", /* 32 */
    };
    
    X死亡状态(dead):这个状态只是一个返回状态,你不会在任务列表里看到这个状态。
    

    进程状态查看

    Z(zombie)-僵尸进程

    僵死状态(Zombies)是一个比较特殊的状态。当进程退出并且父进程(使用wait()系统调用,后面讲)
    没有读取到子进程退出的返回代码时就会产生僵死()进程
    僵死进程会以终止状态保持在进程表中,并且会一直在等待父进程读取退出状态代码。
    所以,只要子进程退出,父进程还在运行,但父进程没有读取子进程状态,子进程进入Z状态
    
    来一个创建维持 30 秒的僵死进程例子:
    
     #include <stdio.h>
     #include <stdlib.h> 
     int main() { 
    	 	pid_t id = fork();
    		if(id < 0){
    			 perror("fork"); 
    			 return 1; 
    		}else if(id > 0){ 
    			//parent 
    			printf("parent[%d] is sleeping...\n", getpid());
    			sleep(30); 
    		}else{
    			printf("child[%d] is begin Z...\n", getpid()); 
    			sleep(5); exit(EXIT_SUCCESS);
    		} 
    		return 0;
    	}
    
    
    
    ps aux / ps axj 命令
    

    僵尸进程危害

    进程的退出状态必须被维持下去,因为他要告诉关心它的进程(父进程),你交给我的任务,我办的怎
    么样了。可父进程如果一直不读取,那子进程就一直处于Z状态?是的!
    维护退出状态本身就是要用数据维护,也属于进程基本信息,所以保存在task_struct(PCB)中,换句话
    说,Z状态一直不退出,PCB一直都要维护?是的!
    那一个父进程创建了很多子进程,就是不回收,是不是就会造成内存资源的浪费?是的!因为数据结构
    对象本身就要占用内存,想想C中定义一个结构体变量(对象),是要在内存的某个位置进行开辟空
    间!
    内存泄漏?是的!
    如何避免?后面讲
    

    进程状态总结

    至此,值得关注的进程状态全部讲解完成,下面来认识另一种进程

    孤儿进程

    父进程如果提前退出,那么子进程后退出,进入Z之后,那该如何处理呢?
    父进程先退出,子进程就称之为“孤儿进程”
    孤儿进程被 1 号init进程领养,当然要有init进程回收喽。
    
    代码:
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main(){
    	pid_t id = fork();
    	if(id < 0){
    		perror("fork");
    		return 1;
    	}
    	else if(id == 0){//child
    		printf("I am child, pid : %d\n", getpid());
    		sleep(10);
    	}else{//parent
    		printf("I am parent, pid: %d\n", getpid());
    		sleep(3);
    		exit(0);
    	}
    	return 0;
    }
    

    环境变量

    基本概念

    环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
    如:我们在编写C/C++代码的时候,在链接的时候,从来不知道我们的所链接的动态静态库在哪里,但
    是照样可以链接成功,生成可执行程序,原因就是有相关环境变量帮助编译器进行查找。
    环境变量通常具有某些特殊用途,还有在系统当中通常具有全局特性
    

    常见环境变量

    PATH : 指定命令的搜索路径
    HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)[重点]
    SHELL : 当前Shell,它的值通常是/bin/bash。
    

    查看环境变量方法

    echo $NAME //NAME:你的环境变量名称
    

    测试PATH

    1. 创建hello.c文件
    2. 对比./hello执行和之间hello执行
    3. 为什么有些指令可以直接执行,不需要带路径,而我们的二进制程序需要带路径才能执行?
    4. 将我们的程序所在路径加入环境变量PATH当中,export PATH=$PATH:hello程序所在路径
    5. 对比测试
    6. 还有什么方法可以不用带路径,直接就可以运行呢?

    测试HOME

    1. 用root和普通用户,分别执行echo $HOME,对比差异
    #include <stdio.h>
    
    int main(){
    	printf("hello world!\n");
    	return 0;
    }
    
    1. 执行cd ~; pwd,对应~ 和 HOME的关系

    和环境变量相关的命令

    1. echo: 显示某个环境变量值[重点]
    1. export: 设置一个新的环境变量[重点]
    1. env: 显示所有环境变量[重点]
    1. unset: 清除环境变量
    1. set: 显示本地定义的shell变量和环境变量

    环境变量的组织方式

    每个程序都会收到一张环境表,环境表是一个字符指针数组,每个指针指向一个以’\0’结尾的环境字符串

    通过代码如何获取环境变量

    命令行第三个参数
    通过第三方变量environ获取
    
    #include <stdio.h>
    
    int main(int argc, char *argv[], char *env[]){
    	int i = 0;
    	for(; env[i]; i++){
    		printf("%s\n", env[i]);
    	}
    	return 0;
    }
    
    #include <stdio.h>
    
    int main(int argc, char *argv[]){
    	extern char **environ;
    	int i = 0;
    	for(; environ[i]; i++){
    		printf("%s\n", environ[i]);
    	}
    	return 0;
    }
    
    libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时 要用extern声明。
    

    通过系统调用获取或设置环境变量

    常用getenv和putenv函数来访问特定的环境变量。
    putenv
    getenv
    

    环境变量通常是具有全局属性的

    环境变量通常具有全局属性,可以被子进程继承下去
    直接查看,发现没有结果,说明该环境变量根本不存在
    导出环境变量 export MYENV="hello world"
    
    再次运行程序,发现结果有了!说明:环境变量是可以被子进程继承下去的!想想为什么?
    
    如果只进行MYENV=“helloworld”,不调用export导出,在用我们的程序查看,会有什么结果?为什
    么?
    普通变量
    

    程序地址空间研究

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(){
    	printf("%s\n", getenv("PATH"));
    	return 0;
    }
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(){
    	char * env = getenv("MYENV");
    	if(env){
    		printf("%s\n", env);
    	}
    	return 0;
    }
    
    32 位平台

    程序地址

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int g_val = 0;
    
    int main(){
    	pid_t id = fork();
    		if(id < 0){
    		perror("fork");
    		return 0;
    	}
    	else if(id == 0){ //child
    		printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
    	}else{ //parent
    		printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
    	}
    	sleep(1);
    	return 0;
    }
    
    输出
    parent[2995]: 0 : 0x80497d
    child[2996]: 0 : 0x80497d
    
    修改后
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int g_val = 0;
    
    int main(){
    	pid_t id = fork();
    	if(id < 0){
    		perror("fork");
    		return 0;
    	}else if(id == 0){ //child,子进程肯定先跑完,也就是子进程先修改,完成之后,父进程再读取
    		g_val=100;
    		printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
    	}else{ //parent
    		sleep(3);
    		printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
    	}
    	sleep(1);
    	return 0;
    }
    
    输出
    child[3046]: 100 : 0x80497e
    parent[3045]: 0 : 0x80497e
    

    我们发现,父子进程,输出地址是一致的,但是变量内容不一样!能得出如下结论:

    变量内容不一样,所以父子进程输出的变量绝对不是同一个变量

    但地址值是一样的,说明,该地址绝对不是物理地址!

    在Linux地址下,这种地址叫做虚拟地址
    我们在用C/C++语言所看到的地址,全部都是虚拟地址!物理地址,用户一概看不到,由OS统一管理
    
    OS必须负责将虚拟地址转化成物理地址。

    进程地址空间

    所以之前说‘程序的地址空间’是不准确的,准确的应该说成进程地址空间,那该如何理解呢?看图:

    分页&虚拟地址空间

    进程优先级

    基本概念

    cpu资源分配的先后顺序,就是指进程的优先权(priority)。
    优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用,可以改善系统性能。
    还可以把进程运行到指定的CPU上,这样一来,把不重要的进程安排到某个CPU,可以大大改善系统整
    体性能。
    

    查看系统进程

    在linux或者unix系统中,用ps –l命令则会类似输出以下几个内容:

    我们很容易注意到其中的几个重要信息,有下:
    UID : 代表执行者的身份
    PID : 代表这个进程的代号
    PPID :代表这个进程是由哪个进程发展衍生而来的,亦即父进程的代号
    PRI :代表这个进程可被执行的优先级,其值越小越早被执行
    NI :代表这个进程的nice值

    PRI and NI

    PRI也还是比较好理解的,即进程的优先级,或者通俗点说就是程序被CPU执行的先后顺序,此值越小
    进程的优先级别越高
    那NI呢?就是我们所要说的nice值了,其表示进程可被执行的优先级的修正数值PRI值越小越快被执行,那么加入nice值后,将会使得PRI变为:PRI(new)=PRI(old)+nice这样,当nice值为负值的时候,那么该程序将会优先级值将变小,即其优先级会变高,则其越快被执行所以,调整进程优先级,在Linux下,就是调整进程nice值nice其取值范围是-20至 19 ,一共 40 个级别。

    PRI vs NI

    需要强调一点的是,进程的nice值不是进程的优先级,他们不是一个概念,但是进程nice值会影响到进
    程的优先级变化。
    可以理解nice值是进程优先级的修正修正数据
    

    查看进程优先级的命令

    用top命令更改已存在进程的nice:

    top
    进入top后按“r”–>输入进程PID–>输入nice值
    

    其他概念

    竞争性: 系统进程数目众多,而CPU资源只有少量,甚至 1 个,所以进程之间是具有竞争属性的。为了高
    效完成任务,更合理竞争相关资源,便具有了优先级
    独立性: 多进程运行,需要独享各种资源,多进程运行期间互不干扰
    并行: 多个进程在多个CPU下分别,同时进行运行,这称之为并行
    并发: 多个进程在一个CPU下采用进程切换的方式,在一段时间之内,让多个进程都得以推进,称为并发
    更多相关内容
  • 进程基本概念相关函数进程定义fork函数exec函数族wait函数waitpid函数 进程定义 从不同角度,进程可以有不同定义: 1.进程是程序的一次执行过程 2.进程是一个程序及其数据在处理机上顺序执行时所发生的活动。 3....
  • Linux进程相关概念

    2018-07-31 21:11:37
    拥有梦想是一种智力,实现梦想是一种能力。 程序&进程 程序:存放在磁盘上的指令和数据的有序集合(文件) ...进程是程序的一次执行过程,这是程序与进程之间的联系。 例如,我用C语言写了一个"hel...

    拥有梦想是一种智力,实现梦想是一种能力。

     

    程序&进程

    程序:存放在磁盘上的指令和数据的有序集合(文件)  
    进程:执行一个程序所分配的资源的总称

    程序 = 数据+代码
    进程 = 数据+代码+堆栈+PCB+CPU寄存器值

    程序是静态的,而进程是动态的,包括创建、调度、执行和消亡。进程是程序的一次执行过程,这是程序与进程之间的联系。

    例如,我用C语言写了一个"hello world" 程序,我将程序执行一次就产生一个进程,再执行一个又产生了第二个进程。

     

     

    之前说了,执行一个程序所分配的资源的总称。那么系统又是如何调度各个进程的呢?

    进程控制块PCB

    • 进程标识PID 
    • 进程用户
    • 进程状态、优先级
    • 文件描述符表

     

     

    进程类型

    • 交互进程:在shell下启动。以在前台运行,也可以在后台运行
    • 批处理进程:和在终端无关,被提交到一个作业队列中以便顺序执行
    • 守护进程:和终端无关,一直在后台运行

     

    进程的四种状态

     

    • 运行态:进程正在运行,或者准备运行
    • 等待态:进程在等待一个事件的发生或某种系统资源
    • 停止态:进程被中止,收到信号后可继续运行
    • 死亡态:已终止的进程,但pcb没有被释放

     

    状态转换图

     

     

    展开全文
  •  在计算机系统中,为了分配资源,人们引进了“进程”这个最基本、最重要的概念。在操作系统中,进程是享用系统资源的对象,是资源分配的基本单位。  为了提高处理器的利用率,可以像下图所描述的那样使程序并发...
  • 一、进程特殊形式 ( 内核线程 | 用户线程 )、 二、C 标准库与 Linux 内核中进程相关概念、 三、Linux 查看进程命令及输出字段解析、





    一、进程特殊形式 ( 内核线程 | 用户线程 )



    普通的进程 , 包含 内核虚拟地址空间用户虚拟地址空间 , 其中 内核虚拟地址空间 所有进程共享 , 用户虚拟地址空间 由进程独立拥有 ;


    除了 普通进程 外 , 进程 还有 2 2 2 种 特殊形式 :

    • 内核级线程 : 只有 内核虚拟地址空间 , 没有 用户虚拟地址空间 的进程 , 称为 内核线程 ;
    • 用户级线程 : 共享 用户虚拟地址空间 的进程 , 称为 用户线程 ;

    线程 : 用户线程 又称为 线程 ;

    线程组 : 共享 相同 用户虚拟地址空间 的线程 , 组成了一个 线程组 ,





    二、C 标准库与 Linux 内核中进程相关概念



    C 语言中 标准库 提供的 进程 , 与 Linux 内核 中的 进程 这两个概念是不同的 ;

    C 标准库 中的 包含多个线程 的进程 , 在 Linux 内核中 称为 " 线程组 " ;

    C 标准库 中的 只有一个线程 的进程 , 在 Linux 内核中 称为 " 任务 / 进程 " ;

    C 标准库 中的 线程 , 在 Linux 内核中 称为 " 共享 用户虚拟地址空间 的 进程 "





    三、Linux 查看进程命令及输出字段解析



    在 Ubuntu 中 , 执行

    ps aux
    

    命令 , 可以查看当前系统的进程状态 , 确定有哪些进程 正在运行 , 占用的 CPU , 内存资源比例, 进程 ID 是多少 ;

    ps 命令显示的当前执行命令时的 瞬间状态 , 不是 实时动态更新的 ;

    实时进程使用 top 命令 ;


    进程字段说明 :

    • USER : 表示 进程是属于哪个账户的 ;
    • PID : 进程 ID ;
    • %CPU : 使用的 CPU 资源占用的 百分比 ;
    • %MEM : 使用的 内存 资源占用的 百分比 ;
    • VSZ : 该进程 占用的虚拟内存容量是多少 , 单位是 KB , 225864 表示 225864KB ;
    • RSS : 实际占用的内存容量 ;
    • TTY : 进程 运行的终端 ;
    • STAT : 程序目前的状态 ; S 表示程序在休眠 , 可以发送信号唤醒 ;

    执行过程如下 :

    root@octopus:~# ps aux
    USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
    root          1  0.3  0.2 225864  9376 ?        Ss   09:26   0:03 /sbin/init splash
    root          2  0.0  0.0      0     0 ?        S    09:26   0:00 [kthreadd]
    root          3  0.0  0.0      0     0 ?        I<   09:26   0:00 [rcu_gp]
    root          4  0.0  0.0      0     0 ?        I<   09:26   0:00 [rcu_par_gp]
    root          6  0.0  0.0      0     0 ?        I<   09:26   0:00 [kworker/0:0H-kb]
    root          9  0.0  0.0      0     0 ?        I<   09:26   0:00 [mm_percpu_wq]
    root         10  0.0  0.0      0     0 ?        S    09:26   0:00 [ksoftirqd/0]
    root         11  0.0  0.0      0     0 ?        I    09:26   0:00 [rcu_sched]
    root         12  0.0  0.0      0     0 ?        S    09:26   0:00 [migration/0]
    root         13  0.0  0.0      0     0 ?        S    09:26   0:00 [idle_inject/0]
    root         14  0.0  0.0      0     0 ?        S    09:26   0:00 [cpuhp/0]
    root         15  0.0  0.0      0     0 ?        S    09:26   0:00 [cpuhp/1]
    root         16  0.0  0.0      0     0 ?        S    09:26   0:00 [idle_inject/1]
    root         17  0.0  0.0      0     0 ?        S    09:26   0:00 [migration/1]
    root         18  0.0  0.0      0     0 ?        S    09:26   0:00 [ksoftirqd/1]
    root         20  0.0  0.0      0     0 ?        I<   09:26   0:00 [kworker/1:0H-kb]
    root         21  0.0  0.0      0     0 ?        S    09:26   0:00 [cpuhp/2]
    root         22  0.0  0.0      0     0 ?        S    09:26   0:00 [idle_inject/2]
    root         23  0.0  0.0      0     0 ?        S    09:26   0:00 [migration/2]
    
    

    在这里插入图片描述

    展开全文
  • 进程概念

    2021-05-06 21:42:08
    进程的基本概念1.1 基本概念1.2 描述进程—–PCB1.3 task_ struct内容分类进程的其他概念2. 进程的特征3. 进程的状态和转换3.1 五种状态3.2 状态转换4. 进程和线程说明 1. 进程的基本概念 1.1 基本概念 进程...

    1. 进程的基本概念

    1.1 基本概念

    进程(Process)是指计算机中已运行的程序,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。进程是程序真正运行的实例,若干进程可能与同一个程序相关,且每个进程皆可以同步或异步的方式独立运行。

    狭义定义:进程是正在运行的程序的实例。

    广义定义:进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元,在传统的操作系统中,进程既是基本的分配单元,也是基本的执行单元。

    进程的概念主要有两点:第一,进程是一个实体。每一个进程都有它自己的地址空间,一般情况下,包括文本区域(text region)、数据区域(data region)和堆栈(stack region)。文本区域存储处理器执行的代码;数据区域存储变量和进程执行期间使用的动态分配的内存;堆栈区域存储着活动过程调用的指令和本地变量。第二,进程是一个“执行中的程序”。程序是一个没有生命的实体,只有处理器赋予程序生命时(操作系统执行之),它才能成为一个活动的实体,我们称其为进程。

    1.2 描述进程—–PCB

    • 进程信息被放在一个叫做进程控制块的数据结构中,可以理解为进程属性的集合。
    • 课本上称之为PCB(process control block),Linux操作系统下的PCB是: task_struct 。
    • 在Linux中描述进程的结构体叫做task_struct。
    • task_struct是Linux内核的⼀一种数据结构,它会被装载到RAM(内存)⾥里并且包含着进程的信息。

    1.3 task_ struct内容分类

    在进程执行时,任意给定一个时间,进程都可以唯一的被表征为以下元素。

    • 标示符: 描述本进程的唯一标示符,⽤用来区别其他进程。
    • 状态: 任务状态,退出代码,退出信号等。
    • 优先级: 相对于其他进程的优先级。
    • 程序计数器: 程序中即将被执行的下一条指令的地址。
    • 内存指针: 包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针
    • 上下文数据: 进程执行时处理器的寄存器中的数据
    • I/O状态信息: 包括显⽰示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表。
    • 记账信息: 可能包括处理器时间总和,使用的时钟数总和,时间限制,记账号等。
    • 其他信息

    进程的其他概念

    • 竞争性:系统进程数目众多,而CPU资源只有少量,甚至1个,所以进程之间是具有竞争属性的。为了高效完成任务,更合理竞争 相关资源,便具有了优先级。
    • 独立性:多进程运行,需要独享各种资源,多进程运行期间互不干扰。
    • 并行:多个进程在多个CPU下分别,同时进行,这称之为并行。
    • 并发:多个进程在⼀个CPU下采⽤用进程切换的方式,在⼀段时间之内,让多个进程都得以推进,称之为并发。

    2. 进程的特征

    进程是由多程序的并发执行而引出的,它和程序是两个截然不同的概念。进程的基本特征是对比单个程序的顺序执行提出的,也是对进程管理提出的基本要求。

    1. 动态性:进程是程序的一次执行,它有着创建、活动、暂停、终止等过程,具有一定的生命周期,是动态地产生、变化和消亡的。动态性是进程最基本的特征。

    2. 并发性:指多个进程实体,同存于内存中,能在一段时间内同时运行,并发性是进程的重要特征,同时也是操作系统的重要特征。引入进程的目的就是为了使程序能与其他进程的程序并发执行,以提高资源利用率。

    3. 独立性:指进程实体是一个能独立运行、独立获得资源和独立接受调度的基本单位。凡未建立PCB的程序都不能作为一个独立的单位参与运行。

    4. 异步性:由于进程的相互制约,使进程具有执行的间断性,即进程按各自独立的、 不可预知的速度向前推进。异步性会导致执行结果的不可再现性,为此,在操作系统中必须配置相应的进程同步机制。

    5. 结构性:每个进程都配置一个PCB对其进行描述。从结构上看,进程实体是由程序段、数据段和进程控制段三部分组成的。

    3. 进程的状态和转换

    3.1 五种状态

    进程在其生命周期内,由于系统中各进程之间的相互制约关系及系统的运行环境的变化,使得进程的状态也在不断地发生变化(一个进程会经历若干种不同状态)。通常进程有以下五种状态,前三种是进程的基本状态。

    1. 运行状态:进程正在处理机上运行。在单处理机环境下,每一时刻最多只有一个进程处于运行状态。
    2. 就绪状态:进程已处于准备运行的状态,即进程获得了除处理机之外的一切所需资源,一旦得到处理机即可运行。
    3. 阻塞状态,又称等待状态:进程正在等待某一事件而暂停运行,如等待某资源为可用(不包括处理机)或等待输入/输出完成。即使处理机空闲,该进程也不能运行。
    4. 创建状态:进程正在被创建,尚未转到就绪状态。创建进程通常需要多个步骤:首先申请一个空白的PCB,并向PCB中填写一些控制和管理进程的信息;然后由系统为该进程分 配运行时所必需的资源;最后把该进程转入到就绪状态。
    5. 结束状态:进程正从系统中消失,这可能是进程正常结束或其他原因中断退出运行。当进程需要结束运行时,系统首先必须置该进程为结束状态,然后再进一步处理资源释放和 回收等工作。

    注意区别就绪状态和等待状态:就绪状态是指进程仅缺少处理机,只要获得处理机资源就立即执行;而等待状态是指进程需要其他资源(除了处理机)或等待某一事件。之所以把处理机和其他资源划分开,是因为在分时系统的时间片轮转机制中,每个进程分到的时间片是若干毫秒。也就是说,进程得到处理机的时间很短且非常频繁,进程在运行过程中实际上是频繁地转换到就绪状态的;而其他资源(如外设)的使用和分配或者某一事件的发生(如I/O操作的完成)对应的时间相对来说很长,进程转换到等待状态的次数也相对较少。这样来看,就绪状态和等待状态是进程生命周期中两个完全不同的状态,很显然需要加以区分。

    在这里插入图片描述

    3.2 状态转换

    1. 就绪状态 -> 运行状态:处于就绪状态的进程被调度后,获得处理机资源(分派处理机时间片),于是进程由就绪状态转换为运行状态。

    2. 运行状态 -> 就绪状态:处于运行状态的进程在时间片用完后,不得不让出处理机,从而进程由运行状态转换为就绪状态。此外,在可剥夺的操作系统中,当有更高优先级的进程就 、 绪时,调度程度将正执行的进程转换为就绪状态,让更高优先级的进程执行。

    3. 运行状态 -> 阻塞状态:当进程请求某一资源(如外设)的使用和分配或等待某一事件的发生(如I/O操作的完成)时,它就从运行状态转换为阻塞状态。进程以系统调用的形式请求操作系统提供服务,这是一种特殊的、由运行用户态程序调用操作系统内核过程的形式。

    4. 阻塞状态 -> 就绪状态:当进程等待的事件到来时 ,如I/O操作结束或中断结束时,中断处理程序必须把相应进程的状态由阻塞状态转换为就绪状态。

    4. 进程和线程说明

    • 通常在一个进程中可以包含若干个线程,它们可以利用进程所拥有的资源。

    • 在引入线程的操作系统中,通常都是把进程作为分配资源的基本单位。

    • 而把线程作为独立运行和独立调度的基本单位,由于线程比进程更小,基本上不拥有系统资源。

    • 故对它的调度所付出的开销就会小得多,能更高效的提高系统内多个程序间并发执行的程度。

    • 当下推出的通用操作系统都引入了线程,以便进一步提高系统的并发性,并把它视为现代操作系统的一个重要指标。

    展开全文
  • 进程的基本概念

    万次阅读 2018-11-08 23:14:34
    1.什么是进程?  1. 进程就是运行起来的程序,程序运行起来需要被加载到内存中。(这是站在用户的角度看待进程的)  2. 进程就是操作系统的描述,这个描述叫PCB(进程控制块),Linux下PCB有自己的名字叫task_...
  • linux进程相关概念

    2015-11-13 12:03:02
    1.基本概念 进程定义:进程是一个具有独立功能的程序的一次运行活动。 进程特点:动态型、并发性、独立性、异步性 进程三态: 进程ID(PID):标识进程的唯一数字 父进程ID:PPID 启动进程的用户ID : UID 进程互斥:...
  • linux进程概念

    千次阅读 多人点赞 2022-03-09 21:36:52
    内存指针: 包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针 上下文数据: 进程执行时处理器的寄存器中的数据. I/ O状态信息: 包括显示的I/O请求,分配给进程的I/ O设备和被进程使用的文件列表...
  • 操作系统进程篇(详解进程相关概念及调度算法) 1 进程概念简介 1.1 进程的定义 进程是程序的一次执行过程。 进程是一个程序及其数据在处理机上顺序执行时所发生的活动。 进程是具有独立功能的程序在一个数据集合上...
  • Linux进程概念

    千次阅读 2022-03-13 20:14:02
    冯诺依曼体系结构和操作系统的认识,进程的详细介绍
  • linux的进程基本概念

    2022-03-18 10:44:55
    linux进程概念(1)冯诺依曼体系结构(2)操作系统(3)进程概念(4)进程状态(5)环境变量(6)程序地址空间 (1)冯诺依曼体系结构 计算机的硬件体系结构 五大硬件单元:输入设备,输出设备,运算器,控制器,...
  • Linux进程概念

    千次阅读 多人点赞 2022-03-03 08:54:33
    Linux进程概念零、前言一、冯诺依曼体系结构二、操作系统三、进程1、描述进程-PCB2、查看进程3、获取进程标示符4、创建进程-fork()5、进程状态6、僵尸进程7、孤儿进程8、进程优先级9、环境变量1)测试PATH2)测试HOME3...
  • 进程概念进程控制
  • 理解Linux进程概念

    千次阅读 2022-03-10 14:56:04
    了解进程的基本概念、状态、特点以及fork函数
  • 进程概念

    千次阅读 2018-04-01 22:17:21
    在要了解进程之前,需要先对计算的组成有一个大概的了解,这对于我们理解进程,有着很大的帮助。 在现在的计算机中,大多采用冯诺伊曼体系结构,在冯诺伊曼中,主要有以下几个部件。 这里需要注意一下几点: -...
  • 进程基本概念 一、进程是什么? 两个角度来理解: 对于用户来说: 进程就是一个正在运行的程序 对操作系统来说: 进程就是一个正在运行的程序的信息的描述集合,我们一般称它为 pcb,这个pcb实际上是一个名为:task...
  • 进程概念进程控制

    千次阅读 2018-08-18 18:37:12
    这里将介绍进程的基本概念,什么是进程,如何描述和组织进程,接着讨论进程的状态,最后介绍进程 控制 进程概念  1. 概念:  a. 进程是程序的一次动态执行过程  b. 担当分配系统资源(CPU时间、内存)的...
  • 程序和进程的区别? 程序是一些指令的集合,为了完成某种任务而提前设定好的指令集。它是静止的实体。 进程首先是运行状态下的程序,是执行程序的一个过程。 并发与并行的区别? 并发是在在一个时间段内有多个程序...
  • 【Python】独特的进程概念博主介绍前言python进程进程池如何使用?⭐️申请()⭐️apply_async⭐️地图()⭐️map_async()⭐️close()⭐️终端()⭐️加入()⭐️代码实列:进程池中的进程和一般的进程有...
  • 主要介绍了node.js中process进程概念和child_process子进程模块的使用方法,结合实例形式分析了node.js中process进程和child_process子进程模块相关概念、原理、使用方法及操作注意事项,需要的朋友可以参考下
  • 【Linux】进程详解一:进程概念

    千次阅读 多人点赞 2021-09-15 16:58:13
    基本概念2.描述进程-进程控制块(PCB)3.1 task_struct3.组织进程4.查看进程5.创建进程-fork()6.进程状态详解6.1 查看进程的状态6.2 不同的进程状态6.3 孤儿进程6.4 僵尸进程6.5 进程状态的转化 前言 在上一讲 认识...
  • 操作系统进程基本概念

    千次阅读 2020-01-18 17:45:49
    操作系统进程基本概念进程描述定义进程几种状态及变化(重点)创建状态和终止状态挂起状态 进程描述 定义 (1)进程是程序的一次执行。 (2)进程是一个程序及其数据在处理机上顺序执行时所发生的活动。 (3)进程是...
  • linux进程概念

    千次阅读 2022-03-07 16:04:30
    fork本质是创建进程,也就是系统里多了一个进程 与进程相关的内核数据结构(task_struct)+进程的代码和数据在系统里面多了一份 我们只是fork了,创建了子进程,但是子进程对应的代码和数据呢? ? ? 默认情况下,会...
  • Linux进程概念(精讲)

    千次阅读 多人点赞 2021-09-09 08:54:04
    文章目录基本概念描述进程-PCB组织进程查看进程通过系统调用获取进程的PID和PPID通过系统调用创建进程- fork初始进程状态运行状态-R浅度睡眠状态-S深度睡眠状态-D暂停状态-T僵尸状态-Z死亡状态-X僵尸进程僵尸进程的...
  • 进程同步的概念

    2014-05-30 20:02:21
    描述 进程相关知识信息和同步的概念,让我们更容易了解进程的一些使用
  • 进程与线程概念

    万次阅读 多人点赞 2018-09-18 15:34:48
    进程的定义: 进程是指一个具有一定独立功能的程序,在一个数据集合上的一次动态执行过程。 如下图所示,源代码文件经过编译链接形成可执行文件,将可执行文件加载进内存进行执行。为什么要加载进内存呢?这是...
  • Linux进程控制相关的一些概念
  • 进程 task_struct mm_struct 进程地址空间 进程状态 僵尸状态 运行态 可中断休眠态 不可中断休眠态 PCB 僵尸进程 孤儿进程 环境变量

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 351,681
精华内容 140,672
关键字:

进程相关概念

友情链接: GrapheneTunnel.rar