前言：进程是什么？在操作系统中，我们经常能听到这样的话。我们要终止一个进程或者杀死一个进程，父进程创建了子进程这一类的话。往往我们听到都会觉得很高大上，这跟编程语言完全不同的感觉，操作了整个计算机。

一，进程的概念

冯诺依曼体系结构
在进程之前首先要提一下我们的“祖师爷”——冯诺依曼体系结构。

这个是一个计算机入门第一节课必然会提到的知识。冯诺依曼体系结构提出了计算机采用二进制；计算机应该按照程序顺序执行。它由输入设备，输出设备，存储器，控制器，运算器组成。

【注意！！注意！！！】

1、这里的存储器指的是内存。

2、不考虑缓存情况，这里的cpu（控制器+运算器）只能对内存进行读写，不能访问外设（输入或输出设备）

3、外设要输入或输出数据，也只能写入内存或者从内存中读取

二，操作系统（0S）

任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)，操作系统的存在就是让计算机更加的好用，能更方便的、统筹合理的管理计算机的软硬件资源。

那么是怎么管理的？(我们可以先举一个例子，学校的管理，首先我们被辅导员统一管理，辅导员又由院内领导管理，院内领导又由校长管理。)

学生->辅导员->院内领导->校长 这么一个层次结构。但在这之前需要制定一个制度来管理，每一个层次的人都遵守这个制度。这样才能按部就班地进行工作的分配。

那么操作系统也一样。总的来说就是：先描述，再组织；描述用struct结构体，比如进程有task_struct这样一个结构体来描述,组织可以用链表或者其他高效的数据结构。

三，系统调用和库函数概念

在开发角度，操作系统对外会表现一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作系统提供的接口，叫做系统调用。

系统调用在使用上，功能比较基础，对用户的要求也相对比较高，所以，有心的开发者可以对部分系统调用进行适度封装，从而形成了库，有了库，就很有利于更上层用户或者开发者进行二次开发。

(1)进程概念
从用户角度：进程就是一个正在运行中的程序。

操作系统角度：操作系统运行一个程序，需要描述这个程序的运行过程，这个描述通过一个结构体task_struct{}来描述，统称为PCB，因此对操作系统来说进程就是PCB(process control block)程序控制块

进程的描述信息有：标识符PID，进程状态，优先级，程序计数器，上下文数据，内存指针，IO状态信息，记账信息。都需要操作系统进行调度。

那么在Linux操作系统下，怎么查看进程呢
(2)查看进程
输入ls /porc指令即可

前面蓝色数字代表的进程的ID。如果你想查看PID为1的进程信息，你需要查看/porc/1这个文件夹

我们也可以使用ps -ef -aux指令来直接显示进程状态.。

还有getpid()和getppid()这两个函数用来查看当前程序的进程和父进程PID。

int main(){
    printf("getpid:%d",getpid());
    printf("getppid:%d",getppid());
    return 0;
}

(3)进程创建
Linux中非常重要的函数——fork()，它从已存在的进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include <unistd.h>
pid_t fork(void);
返回值：
	父进程：返回值大于0，子进程的pid
	子进程：返回值等于0

写这么个程序来初始fork函数

#include <stdio.h>
#include <unistd.h>   
int main(){    
  printf("parent pid:%d\n",getpid());    
  int a = 100;    
  pid_t pid = fork();    
  if(pid < 0){    
    return -1;    
  }else if(pid == 0){    
    a = 20;    
    printf("child !! pid:%d----a:%d--%p\n",getpid(),a ,&a);    
    
  }else{    
    sleep(1);    
    printf("parent !! pid:%d----a:%d--%p\n",getpid(), a, &a);    
  }    
  printf("nihaoa %d\n",a);    
  return 0;    
}  

关于fork函数需要理解，每当调用一次fork函数时，会返回两个两次。一次是在调用进程中（父进程）返回一次，返回值是新派生的进程的进程ID。一次是在子进程中返回，返回值是0，代表当前进程为子进程。如果返回-1，那么则代表在创建子进程的过程中出现了错误。

将上面代码执行之后显示如下：

先返回了子进程的pid，之后再返回了父进程的pid；fork()相当于创建了一个新的子进程，但是拷贝的是fork()函数之后的所有数据，之前的并不会拷贝。在代码之上就可以看到parentpid只打印了一次

总的来说：复制pcb，代码共享，但是子进程并非从头开始，而是从fork()函数之后开始，数据独有。
借用一下网上大佬对fork()的理解：

• (1)一个进程进行自身的复制，这样每个副本可以独立的完成具体的操作，在多核处理器中可以并行处理数据。这也是网络服务器的其中一个典型用途，多进程处理多连接请求。
• (2)一个进程想执行另一个程序。比如一个软件包含了两个程序，主程序想调起另一个程序的话，它就可以先调用fork来创建一个自身的拷贝，然后通过exec函数来替换成将要运行的新程序。

那么创建子进程的意义是什么————压力分摊/干其他工作

(4)进程状态
进程状态一般有：就绪态，阻塞态，运行态

在Linux下：R运行状态，S睡眠状态，D磁盘休眠状态，T停止状态，X死亡状态

这些当我们使用指令ps -aux就可以看到

(5)僵尸进程
在进程状态中有两个比较特殊的存在。僵尸和孤儿

僵尸进程是进程退出后，但是资源没有释放，处于僵死状态的进程。

产生原因：子进程先于父进程退出，操作系统检测到进程的退出，通知父进程，但是父进程这时候正在执行其他操作，没有关注这个通知，这时候操作系统为了保护子进程，不会释放子进程资源，因为子进程的PCB中包含有退出原因。这时候因为既没有运行也没有退出，因此处于僵死状态，成为僵尸进程。

#include <stdio.h>    
#include <stdlib.h>    
#include <unistd.h>    
#include <errno.h>                                                                                                         
int main()    
{    
  pid_t  pid;    
  //循环创建子进程    
  while(1)    
  {    
    pid = fork();    
    if (pid < 0)    
    {    
      perror("fork error:");    
      exit(1);    
    }    
    else if (pid == 0)    
    {    
  printf("I am a child process.\nI am exiting.\n");    
  //子进程退出，成为僵尸进程    
  exit(0);    
    }    
    else    
    {    
      //父进程休眠20s继续创建子进程    
      sleep(20);    
      continue;
    }       
  }      
  return 0;                            
}

执行这上面这个程序，子进程中途退出了。

z+这个标志就是僵尸进程的标志。

那么怎么避免僵尸进程的产生？

我们一般处理就是关闭父进程，这样僵尸子进程也随之消失了。

所以我们最好设置进程等待，等待子进程完成了工作，并且通知了父进程之后，在退出。

(6)孤儿进程
孤儿进程与僵尸进程在理解上可以认为相反。

父进程先于子进程退出，父进程退出后，子进程成为后台进程，并且父进程为1号进程。

守护进程：特殊（脱离了与终端的关联+会话的关联）的孤儿进程

(7)进程优先级
优先级：决定资源的优先分配权的等级划分

那么进程为什么具有优先级呢？

为了让操作系统的运行更加的合理——交互式进程（一旦有操作优先处理）和批处理进程（一直处理程序，但对CPU要求不高）

设置优先级，可以使用指令ps -elf先查看进程

可以看到 PRI 和 NI这两个数值

PRI：优先级 NI：nice值

PRI是无法直接调整的，但是可以通过调整nice值来调整优先级的大小

PRI = PRI + NI，但是NI也是有范围的——(-20~19)

指令操作为renice -n size -p pid

运行时操作为nice -n size ./main(可执行文件)

这里稍微提一下，程序在运行时具有并行和并发两种执行。
并行：CPU资源足够，多个程序同时运行

并发：CPU资源不够，多个程序切换调度运行（可以看看我之前的一篇关于操作系统的博客，有关调度方法的介绍）

Linux下指令top指令可以查看进程的优先级，进入top后按“r”–>输入进程PID–>输入nice值

四，环境变量

环境变量是保存系统运行环境参数的变量

环境变量在安装java的过程中，可能接触过，需要进入系统环境变量，然后设置PATH添加java的路径

在Linux下可以通过命令指令自己设置

echo 通过变量名称，查看指定环境变量

env 查看所有环境变量

set 查看环境变量以及临时变量

export 声明一个环境

unset 删除一个临时变量

常见的环境变量：HOME SHELL USER PATH

环境变量的全局特性：在子进程中获取继承于父进程的环境变量信息

三种获取环境变量的参数

main(int argc, char *argc[],char *env[])	参数获取

extern char **environ;	全局变量获取

char *getenv(const char *env_name)	接口获取

写一个获取变量的demo

#include <stdio.h>    
  #include <stdlib.h>    
      
W>int main(int argc, char *argv[], char *env[]){    
    //main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时，在DOS提示符下键入文件名，再输入实际参数>  即可把这些实参传送到main的形参中去。        
    //C:\>可执行文件名 参数 参数……    
    //argv参数是字符串指针数组，其各元素值为命令行中各字符串(参数均按字符串处理)的首地址    
    //env：字符指针的数组，每一个元素是指向一个环境变量的字符指针                                                       
    int i;                                      
    for(i = 0;i < argc; i++){                   
      printf("argv[%d]=[%s]\n",i , argv[i]);     
    }                                            
    extern char **environ;                       
    for(i = 0;environ[i] != NULL;i++){           
      printf("env[%d]=[%s]\n",i, environ[i]);    
    }                               
    char *ptr = getenv("MYENV");    
    printf("MYENV:[%s]\n",ptr);    
    return 0;                 
  } 

如果输入export MYENV=“10000”，在运行程序，MYENV将变成MYENV:[10000]。

程序地址空间

地址是什么？地址是内存的编号，指向内存的一块区域

虚拟地址空间：

mm_struct{
long int size
code_start
code_end
data_start
a
data_end
}

上图之中，中间的物理内存地址，两边的为虚拟内存地址。

右边是父进程将虚拟地址通过页表查找到物理内存的地址，这时父进程在运行一个程序。此时父进程又创建了一个子进程(图最右)。子进程也通过页表找到物理内存的地址，这是子进程运行的程序在物理内存的另一个新空间运行。

这是虚拟内存地址使用的过程。它的作用就是保持进程的独立性，通过页表映射物理地址，充分地利用物理地址，增加内存访问控制。

这就是进程有关的知识。总结一下

进程从用户角度和操作系统角度去理解。前者就是一个运行的程序，后者表示运行一个程序，需要描述一个程序的运行过程，通过一个结构体task_struct{}来描述，叫做PCB。对操作系统来说，进程就是PCB

进程的创建需要一个我们必须要掌握的函数——fork()函数，创建一个子进程。并且fork()函数会有两个返回值，在返回的过程中父进程之前的数据不进行拷贝，之后与父进程的运行一致。创建子进程是为了分摊压力/干其他工作

进程的状态有运行态，睡眠状态，磁盘休眠状态，停止状态，死亡状态。每一种状态是容易理解的。但是还有两个特殊的进程

僵尸进程和孤儿进程，前者是进程退出后资源没有释放，操作系统通知父进程，但是父进程此时正在处理其他事情，没有关注子进程的退出通知，系统为了保护资源，没有释放掉，并且在子进程的PCB中也保留了退出原因，此时既没有运行也没有完全退出，处于了僵死状态。但是后者是父进程先于子进程先退出，子进程成为了后台程序，由一号进程接管。