操作系统 | 进程

作业：被组装成一个整体运行的一组计算步骤。通俗地讲，一个作业就是一个程序。出现于批处理系统中。
进程：执行中的程序；进程的执行必须以顺序方式进行。或者可以理解为，一个程序在一个数据集上的一次执行。（上述的三个“一次”如果发生变化，则对应的就不是同一个进程）。出现于交互系统。
任务：进程或线程都可以统称为任务。

进程包括的内容（用户环境）

代码（Text），相对固定

当前活动，相对是变化

程序计数器（PC）：指向当前要执行的指令（地址）。（程序由多行组成，PC指向下一行要执行的代码，指出进程运行的下一行代码）
堆栈（Stack）：存放函数参数、临时变量等临时数据。
数据（Data）：全局变量，处理的文件。
堆（Heap）：动态内存分配。

堆栈 Stack

内存管理角度

堆栈就是一块连续的内存空间。
堆栈的操作采用先入后出的规则。

进程角度

每一进程都有自己的堆栈。
主要用来给线程提供一个暂时存放数据的区域。
使用pop/push及其指令来对堆栈进行操作。通常在函数调用时使用该指令。

堆 Heap

允许程序在运行时动态申请内存空间。（在运行之前先给每个进程分配一个较大的堆，然后运行中可以动态的在堆中申请，不需要直接从内存中申请，进而减小内存申请的开销，内存空间的浪费较小）

获得堆内存：

extern void *malloc(unsigned int num_bytes);
分配长度为num_bytes字节的内存块
例子：int *p；p = (int*)malloc(sizeof(int));

进程和程序的关系

进程是程序的一个实例，是程序的一次执行。
一个程序可以对应一个或多个进程；一个进程也可以对应一个或多个程序（一个进程来自过个程序）。
程序是进程的代码部分。可以将进程理解为容器，其中程序仅仅是进程的一部分。
进程是活动实体，程序静止（被动）的实体。
一般情况进程在内存，程序在外存。

进程状态

进程执行时，状态会发生改变

就绪：进程等待分配处理器。
运行：指令在执行。
阻塞：进程等待某些事件发生。
新建：创建进程。
终止：进程执行完毕。

从进程新建态开始；一旦建立成功立马转入就绪态；如果被调度程序选中，转入运行态；运行态进程如果遇到中断被打断就转为就绪态，遇到运行一段时就后等待某时间发生就转为阻塞态，如果进程运行结束就转为终止态。

创建态---就绪态

就绪态---执行态

执行态---就绪态（系统行为）

执行态---阻塞态（进程行为）

执行态---终止态

阻塞态---就绪态

进程控制块（PCB），位于内核空间

系统通过管理PCB来管理进程。进程运行中包含的信息均在PCB中。用户进程如果想要访问进程控制块需要通过系统调用进行。

进程控制
程序计数器
CPU寄存器
CPU调度信息
内存管理信息
记账信息
I/O状态信息

Windows PCB

每个Win32进程都由一个执行体进程块（executive process block）EPROCESS：PID，PCB，Access Token，句柄表，指向进程环境块PEB指针，处理器集合等。
Windows的PCB称为内核进程对象KPROCESS。
执行体进程对象EPOCESS和KPROCESS位于内核空间。
进程环境块PEB（Process Environment Block），PEB位于用户空间。

进程上下文切换

进程的并发执行需要PCB保存和恢复现场（状态信息）。现场指：进程计算环境，包括寄存器、标志位等。

上下文切换的过程中需要耗费SYS时间。

进程操作

进程创建

父进程创建子进程，如此轮流创建进程下去，构成一棵进程树。所有进程都按照树形结构进行组织。

资源共享

父进程和子进程共享所有的资源。
子进程共享父进程资源的子集。
父进程和子进程无资源共享。

执行

父进程和子进程并发执行。
父进程等待，直到子进程终止。

地址空间

子进程复制父进程空间，子女复制双亲。
子女有一个程序被调入。

UNIX例子

fork系统调用创建新进程。
在fork用一个新程序替代了进程的内存空间之后，采用exec系统调用。

原子操作

进程创建是一个原子操作，意味着进程的创建不能被打断，要么创建成功，要么失败。
不会被打断的操作。
原子性操作必须要硬件的支持。X86中CPU在指令执行期间对总线加锁的手段。

进程终止

进程执行最后一项并使用（exit）退出时，意味着进程终止了。

从子进程向父进程输出数据（通过wait）
操作系统收回进程的资源。

父进程可终止子进程的执行（abort），一般遇到下述情况时父进程会执行终止操作。（父进程终止子进程，并不是操作系统终止。）

子进程超量分配资源。
赋予子进程的任务不再需要。
如果父进程结束。若父进程终止，一些系统不允许子进程继续存在，因此所有子进程都需要终止，这称为级联终止。

父进程可等待子进程的结束（abort）

通常通过调用wait()系统调用来实现。

Windows进程操作

CreateProcess：进程创建

新进程可以继承：打开文件的句柄、各种对象的句柄、环境变量、当前目录、原进程的控制终端、原进程的进程组-----每个句柄在创建或者打开时就可以指定是否可以继承。
新进程不能继承：优先权类、内存句柄、DLL模块句柄。

ExitProocess和TerminateProcess：进程退出

ExitProocess-----主动终止
TerminateProcess----强制终止
若某个process想自己停止执行，可调用ExitProocess()。C中的exit()在自动执行一些清除垃圾工作后，在调用ExitProocess()终止进程。
若process A想要process B停止执行，可在取得process B的handle后，调用TerminateProcess()结束进程。

WaitForSingleObject：等待子进程结束

Win32进程相关

Win32操作系统平台提供了强大的多任务功能，其中“进程（Process）”和“线程（Thread）”是其控制多任务的两个重要概念。
进程有独自的内存空间、程序代码、信息以及一堆大大小小的系统资源。
Window中的每个Win32进程都由一个执行体进程块（Executive Process Block）表示，执行体进程块描述进程的基本信息，并指向其他与进程控制块相关的数据结构。
与LINUX进程一样，父进程和子进程是并发运行的。

Linux进程操作

fork 函数

#include<unistd.h>
pid_t fork()；

当一个进程调用fork()后会创建一个子进程，系统会先给新的进程分配资源（例如存储数据和代码空间），然后把原来进程的信息全复制到新的进程中，其中只有少数信息（进程ID等）与原来的进程不一样。

fork()函数的奇妙在于仅仅被调用一次，却能够返回两次，且可能有三个不同的返回值。

父进程和子进程

根据fork()返回值来区分父子进程

父进程fork返回子进程的ID。
子进程fork返回0。
失败的话返回-1。

执行其他程序

exec 族函数有着6个函数。
exec 族作用：根据指定的文件名找到可执行文件，并用它来取代调用进程的内容（在调用进程内部执行一个可执行文件）
exec 族函数执行成功后不会返回。

父进程阻塞直到子进程完成任务。

可以通过调用wait或者waitpid系列调用来实现。

#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *stat_loc);
pid_t waitpid(pid_t pit, int *stat_loc, int options);

进程一旦调用wait函数，将立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样的一个已经变为僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底校徽后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个这样的子进程出现为止。

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>

int main() {
    int rtn;  //子进程的返回数值
    if (fork == 0) {
        // 子进程执行此命令
        execlp("/bin/ls", "ls -al", (char *)0);
        // 如果exec函数有返回值，表明没有正常执行命令，打印错误信息
        exit(1);
    } else {
        // 父进程执行；等待子进程结束，并打印子进程的返回值
        wait(&rtn);
        printf("child process return %d/n", rtn);    
    }
}

创建进程过程

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>

void main(void) {
    pid_t child;
    int status;
    printf("This will demostrate how to get child status\n");
    if ((child = fork()) == -1) {
        printf("Fork error: %s\n", strerror(errno));
        exit(1);
    } else if (child == 0) {
        int i;
        ptintf("I am the child: %ld\n", getpid());
        for (i = 0; i < 1000000; i++) {
            i++;
        }
        i = 5;
        printf("I exit with %d\n", i);
        exit(i);
    }
    
    while (((child = wait(&status)) == -1) & (errno == EINTR)) {};
}

进程通信

进程通信主要手段

管道（pipe）
信号（signal）
消息（message）
共享内存（shared memory）
信号量（semaphore）
套接口（socket）

系统进程

独立进程：不会影响另一个进程的执行或不会被另一个进程执行影响。（不与其他进程共享数据）

协同进程：可能影响另一个进程的执行或被另一个进程的执行所响。（与其他进程共享数据）

进程系统的优点

信息共享
加速运算，一个任务可以进行划分多块通过相互的共享来加速计算。
模块化
方便

进程间通信（IPC）

用于进程通信的机制，同步其间的活动。早期操作系统一般都是独立进程，因而也不需要IPC。现代计算机系统都需要进程间通信。

两种基本模式（下图所示）

共享模式（图b）：以最快的速度进行方便的通信。一般用于传递大块的信息。只能做物理计算机内部之间的进程通信。
消息传递（图a）：时间耗费较多，交换较小数量的数据。

共享内存模式

（1）需要建立一块共享内存区域。

通常一块共享内存区域驻留在深层内存共享段进程的地址空间，其他希望使用该内存的进程必须将此放到他们自己的地址空间上。

（2）通信由应用程序自己控制。

（3）一般用于大数据通信。常见大数据通信的实现手段还有

文件映射
管道
剪贴板

生产者-消费者例子

生产者进程生产供消费者进程消费的信息。

无界缓冲（Unbounded-buffer），没有对缓冲区大小进行限制。
有界缓冲（Bounded-buffer），对缓冲区大小作了限定。如果缓冲区为空，消费者进程必须等待；如果缓冲区为满，生产者必须等待。

// 有界缓冲共享变量
#define BUFFER_SIZE 10
Typedef struct {
    ...
} item;

item buffer[BUFFER_SIZE];
// in指向缓冲区中下一个空位；
// out指向缓冲区中第一个非空位，但最多只能填充满缓冲区的BUFFER_SIZE - 1 个项。
int in = 0;
int out = 0;

// 生产者进程
item nextProduced;
while (true) {
    // produce an item in nextProduced
    while ((in = (in + 1) % BUFFER_SIZE) == out) { // 表明缓冲区为满
        // do nothing -- no free buffers
    }
    buffer[in] = nextProduced;
    in = (in + 1) % BUFFER_SIZE;
}

// 消费者进程
item nextConsumed;
while (true) {
    while (in == out) { // 表明缓冲区为空
        // do nothing -- nothing to consume
    }
    // remove an item from the buffer
    nextConsumed = buffer[out];
    out = (out + 1) % BUFFER_SIZE;
    // consume the item in nextConsumed
}