Linux: 进程概念详解

三目的有声博客

已于 2024-08-14 08:45:10 修改

阅读量871

点赞数 28

文章标签： linux 服务器操作系统

于 2024-08-11 06:58:57 首次发布

本文链接：https://blog.csdn.net/MaoRuofeng/article/details/136985379

版权

1. 冯诺依曼体系结构

2. 操作系统(Operator System)

1. 冯诺依曼体系结构

截至目前，我们所认识的计算机，都是有一个个的硬件组件组成。

【注意】：

a. 这里的存储器指的是内存

b. 不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出设备)

c.外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。

d. 一句话，所有设备都只能直接和内存打交道。

冯诺依曼体系结构计算机的基本原理是?

答：计算机就是为了完成指定的数据处理，而通过指令按指定流程完成指定功能，指令的合集就是一段程序。说白了计算机就是按照指定的指令执行流程完成对指定数据的处理。

2. 操作系统(Operator System)

--------------------先描述，再组织！--------------------

先描述问题再用特定的数据结构组织起来！！！

1. 概念

任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)。笼统的理解，操作系统包括：

a. 内核（进程管理，内存管理，文件管理，驱动管理）
b . 其他程序（例如函数库，shell程序等等）

2. 设计OS的目的

为什么要有操作系统？

答：操作系统对下（手段）进行软硬件管理工作，对上层提供良好（高效、稳定、安全）的运行环境（目的）！！！！！

3. 任务（定位）

承担管理任务的软件！

4. 理解管理

系统调用和库函数概念

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

3. 进程

---------- 进程 = PCB（task_struct） + 程序的代码和数据 ! ! ! ----------

1. 基本概念

a. 课本概念：程序的一个执行实例，正在执行的程序等
b. 内核观点：担当分配系统资源（CPU时间，内存）的实体。

2. 描述进程-PCB

a. 进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
b. 课本上称之为PCB（process control block），Linux操作系统下的PCB是:task_structtask_structhttps://www.cnblogs.com/tongyan2/p/5544887.html

task_struct-PCB的一种

a. 在Linux中描述进程的结构体叫做task_struct。
b. task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息。

task_ struct内容分类

标示符: 描述本进程的唯一标示符，用来区别其他进程。

状态: 任务状态，退出代码，退出信号等。

优先级: 相对于其他进程的优先级。

程序计数器: 程序中即将被执行的下一条指令的地址。

内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针

上下文数据: 进程执行时处理器的寄存器中的数据。

I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。

记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。

<linux/sched.h>


struct task_struct {
	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
	void *stack;
	atomic_t usage;
	unsigned int flags;	/* per process flags, defined below */
	unsigned int ptrace;
 
	int lock_depth;		/* BKL lock depth */
    ......

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

(每个进程都有自己唯一的标识符)

a: 进程id（PID）

b: 父进程id（PPID）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
printf("pid: %d\n", getpid());
printf("ppid: %d\n", getppid());
return 0;
}

查看进程

进程的信息可以通过 /proc 系统文件夹查看

3. 进程状态

Linux内核源代码解释：

/*
* 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 */
};

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

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

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

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

X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

进程状态转换

阻塞和运行的变化，往往伴随着PCB被连入不同的队列中！入队列不是进程的代码和数据，而是进程的task_struct。

进程切换

进程在切换之前，最重要的一件事：上下文数据的保护和恢复。

程序的上下文：CPU内部的所有寄存器中的临时数据。

CPU内的寄存器：寄存器本身是硬件，具有数据存储的能力，CPU寄存器硬件只有一套。

CPU内部的数据：CPU内部的数据可以有多套，有几个进程，就有几套和该进程对应的上下文数据。

4. 进程状态查看

ps aux / ps axj 命令

循环查看指定进程：

while :; do ps axj | head -1 && ps axj | grep XXXXX | grep -v grep;sleep 1;done

4. 创建进程 fork

fork调用很简单，但是要理解fork还是有点绕的！

fork之后：创建一个进程，多了一个进程，就是多了一个内核task_struct，自己的代码和数据。

父进程的数据和代码是从磁盘加载进来的，默认情况下子进程的代码和数据是继承父进程的。

是不是很奇怪？为什么fork的返回值 id==0 又 id！=0 ?返回两次？先看一下手册怎么说？

原因：进程要做到独立性，父子要各自独立，原则上数据要相互分开！ 父进程得到return id==子进程的id 父进程拿到id可能要对子进程做管理，子进程得到return id = 0子进程通过 fork() 返回的 0 来识别自己。

5. (Zombie)-僵尸进程

直接在命令行启动的进程，他的父进程是bash，bash会自动回收新进程的z。

a. 僵死状态（Zombies）是一个比较特殊的状态。

当进程退出并且父进程（使用wait()系统调用,后面讲）没有读取到子进程退出的返回代码时就会产生僵死(尸)进程。
b. 僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
c. 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

//测试僵尸进程   
int main()
{
    int count=5;
    while(count--)   
    {    printf("I am a parent process,running always! pid:%d--ppid:%d\n",getpid(),getppid());
        sleep(1);
    }
    pid_t id=fork();
    if(id==0)
    {
        int count=5;
        while(count--)
        {
        printf("I am a child process,pid:%d--ppid:%d\n",getpid(),getppid());
        sleep(1);
        }
        printf("-------I am a child process,running done!-------\n");
    }
    else
    {
         int count=10;
        while(count--)
        {
        printf("I am a parent process,running always! pid:%d--ppid:%d\n",getpid(),getppid());
        sleep(1);
        }

    }
   return 0; 
}

僵尸进程危害

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务,我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态。
b.

维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护。
c.

那一个父进程创建了很多子进程，就是不回收，就会造成内存资源的浪费。因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！
d.

内存泄漏 ! ! !

e. 解决办法：wait（）/waitpid（）！！！

6. 孤儿进程

a: 父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？

b: 父进程先退出，子进程就称之为“孤儿进程”

c: 孤儿进程被1号init进程领养，当然要有init进程回收。

#include <stdio.h>
#include <unistd.h>
#include<sys/types.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;
}

7. 进程优先级

基本概念

a: cpu资源分配的先后顺序，就是指进程的优先权（priority），根据有优先级指定进程获取某种资源(CPU)的先后顺序。

b: 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。

c: 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。

d: 保证进程在被CPU调度时的顺序性，确保了操作系统能够合理分配CPU资源，优化系统性能和响应时间。

为什么要有优先级？

a: 进程访问的资源(CPU)始终是有限的，系统中进程大部分情况都是较多的。

b: 操作系统关于调度和优先级的原则：分时操作系统，基本的公平，如果进程因为长时间得不到调度就会造成饥饿问题。

关于分时系统和实时系统：http://t.csdnimg.cn/YAZ8Qhttp://t.csdnimg.cn/YAZ8Q

查看系统进程

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

这里有几个重要信息：

UID : 代表执行者的身份

PID : 代表这个进程的代号

PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号

PRI ：代表这个进程可被执行的优先级，其值越小越早被执行

NI ：代表这个进程的nice值

PRI and NI

a: PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高

b: 那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值

c: PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为： PRI(new)=PRI(old)+nice

d: 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行所以，调整进程优先级，在Linux下，就是调整进程nice值

e: nice其取值范围是-20至19，一共40个级别

PRI vs NI

a: 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。

b: 可以理解nice值是进程优先级的修正修正数据

8. 进程其他相关概念

a. 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级。

b. 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰。

c. 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行。

d. 并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发。

http://t.csdnimg.cn/zHgwnhttp://t.csdnimg.cn/zHgwn http://t.csdnimg.cn/Ihg19http://t.csdnimg.cn/Ihg19

4. 命令行参数与环境变量

命令行参数

为什么要有命令函数？：

本质：命令行参数本质是交给我们程序的不同的选型，用来制定不同的程序功能。命令中会携带很多选项。

环境变量

基本概念以及使用: http://t.csdnimg.cn/O5i49

a: 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数。（系统中很多的配置在我们登录linux系统的时候，就已经被加载到了bash进程中(内存)），所以，默认我们查到的环境变量是内存级的。

b: 如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。

c: 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性。

之前我们提到过：直接在命令行启动的进程，他的父进程是bash。所以我们在命令行运行程序的时候，bash进程默认会给子进程两张表：

1：argv[]命令行参数表(用户输入参数) 2：env[]环境变量表(从OS的配置文件来)。

环境变量具有系统级的全局属性，因为环境变量本身会被子进程继承下去！

内建命令与外部命令

5. 程序地址空间

平台: kernel 2.6.32 32位

程序的地址空间分布图：

先来看一段代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include<sys/types.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;
}

父子进程的地址是一样的? 变量也一样？

我们再来给代码做点小改动：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.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;
}