进程是Unix系统中仅次于文件的基本抽象概念。当目标代码执行的时候，进程不仅仅包括汇编代码，它由数据、资源、状态和一个虚拟的计算机组成。

• 进程ID
  每个进程都由一个唯一的标识符表示，即进程ID，简称pid。系统保证在某时刻每个pid是唯一的。
  空闲进程(idle process)——当没有其他进程在运行时，内核所运行的进程——它的pid是0。在启动后，内核运行的第一个进程称为init进程，它的pid是1。
• 分配进程ID
  缺省情况下，内核将进程ID的最大值限制为32768（和老Unix系统兼容，16位来表示进程ID）。
  内核分配进程ID是以严格的线性函数的方式进行的， 一直递增，直到分配的pid达到了/proc/sys/kernel/pid_max，内核是不会重用以前已分配过的值。
  Linux分配pid的方式在短期内至少是稳定的和并保证了pid值的唯一性。
• 进程体系
  创建新进程的那个进程叫父进程，而新进程被称为子进程。每个进程都是由其他进程创建的（除了init进程），因此每个子进程都有一个父进程，这个关系保存在每个进程的父进程ID号(ppid)中。
  每个进程都被一个用户和组拥有。每个子进程都继承了父进程的用户和组。
  每个进程都是某个进程组的一部分，它简单的表明了自己和其他进程之间的关系。子进程通常属于其父进程所在的那个进程组。
• 获得进程ID和父进程的ID
  getpid( )返回调用进程的ID：

#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);

getppid( )返回调用进程的父进程的ID：

#include <sys/types.h>
#include <unistd.h>
pid_t getppid(void);

一般把pid_t当成int形来printf。

运行新进程

在unix中，载入内存并执行程序映像的操作与创建一个新进程是分离的。
运行一个新进程：将二进制文件的程序映像载入内存，替换原先进程的地址空间，并开始运行它，该系统调用为exec系统调用（实际上是一系列的系统调用）。
创建一个新的进程：基本上就是复制父进程。通常情况下新的进程会立刻执行一个新的程序。完成创建新进程的这种行为叫做派生(fork)，完成这个功能的系统调用就是fork( )。

exec系列系统调用

没有单一的exec系统调用，它们由基于单个系统调用的一组exec函数构成。

• execl( ):

#include <unistd.h>
int execl(const char *path, const char *arg, ...);

对execl( )的调用会将path所指路径的映像载入内存，替换当前进程的映像。它的参数列表是可变长度的，但参数列表必须是以NULL结尾的。
例如，下面的代码会用/bin/vi替换当前运行的程序：

int ret;
ret = execl("/bin/vi", "vi", NULL);
if (ret == -1)
    perror("execl");

当fork/exec进程时，shell会把path的后一个成分，即本例中的"vi"，放入新进程的第一个参数argv[0]。这样一个程序就可以检测argv[0]，从而得知二进制映像文件的名字。
很多情况下，用户会看到一些系统工具有不同的名字，实际上这些名字都是指向同一个程序的硬连接。所以程序需要第一个参数来决定它的具体行为。
如果你想要编辑/home/kidd/hooks.txt，执行以下代码：

int ret;
ret = execl("/bin/vi", "vi", "/home/kidd/hooks.txt", NULL);
if (ret == -1)
  perror("execl");

execl( )成功调用的话不会返回，而是以跳到新的程序的入口点为结束，而刚刚才被运行的代码是不会存在于进程的地址空间中的。
execl( )成功的调用不仅仅改变了地址空间和进程的映像，还改变了进程的一些属性：

• 任何挂起的信号都会丢失
• 捕捉的任何信号会还原为缺省的处理方式，因为信号处理函数已经不存在于地址空间中了
• 任何内存的锁定会丢失
• 多数线程的属性会还原到缺省值
• 多数关于进程的统计信息会复位
• 与进程内存相关的任何数据都会丢失，包括映射的文件
• 包括C语言库的一些特征（例如atexit( )）等独立存在于用户空间的数据都会丢失

然而也有很多进程的属性没有改变，例如pid、ppid、优先级、所属的用户和组。

• 其他exec系列系统调用
  除了execl( )外，还有其他五个系统调用：

#include <unistd.h>
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char * const envp[ ]);
int execv(const char *path, char *const argv[ ]);
int evecvp(const char *file, char *const argv[ ]);
int execve(const char *filename, char *const argv[ ], char *const envp[ ]);

• l:列表方式 v:数组（向量）方式提供参数
• p:在用户的PATH环境变量中寻找可执行文件，只要出现在用户的路径中，带p的exec函数可以简单的只提供文件名。带p的exec函数主要用于shell的，因为在shell所执行的进程通常会从shell继承环境变量。
• e:表示会提供给新进程以新的环境变量。
• 除了需要构造一个数组并用它代替列表作为参数传递以外，使用数组作为参数的exec函数基本上没什么区别。使用数组可以在运行时动态的构造参数，且数组也必须以NULL结尾。

用execvp( )来执行vi的例子：

const char *args[ ] =  {"vi", "/home/kidd/hooks.txt", NULL};
int ret;
/* 这里假设/bin在用户的路径中 */
ret = execvp("vi", args);
if (ret == -1)
  perror ("evecvp");

---

fork( )系统调用

创建一个和当前进程映像一样的进程可以通过fork( )系统调用：

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

成功调用fork( )会创建一个新的进程，它几乎与调用fork( )的进程一模一样。这两个进程都会继续运行。
父进程和子进程在每个方面都非常相近：

• 子进程的pid是新分配的，它是与父进程不同的
• 子进程的ppid会设置为父进程的pid
• 子进程中的资源统计信息会清零
• 任何挂起的信号都会清除，也不会被子进程继承
• 任何文件锁都不会被子进程所继承

fork( )的用法如下：

pid_t pid;
pid = fork( );
if (pid > 0)
  /* 在父进程中fork( )返回子进程的pid */
  printf("I am the parent of pid = %d \n", pid);
else if (!pid)
  /* 成功调用时会返回0 */
  printf("I am the baby! \n");
else if (pid == -1)
  /* 错误时返回-1 */
  perror("fork");

最常见的fork( )用法是创建一个新的进程，然后载入二进制映像，这种派生加执行的方式是很常见的。下面的例子创建了一个新的进程来运行/bin/windlass:

pid_t pid;
pid = fork( );
if (pid == -1)
  perror("fork");
/* the child ... */
if (!pid) {
  const char *args[] = {"windlass", NULL};
  int ret;
  ret = execv("/bin/windlass", args);
  if (ret == -1) {
    perror("execv");
    exit(EXIT_FAILURE);
  }
}

---

• 写时复制：
  早期的Unix系统中，fork时会把所有的内部数据结构复制一份，复制进程的页表项，然后把父进程的地址空间中的内容逐页的复制到子进程的地址空间中。这样是十分耗时且不必要的。
  现代Unix系统采用写时复制COW的方法。
  如果多个进程要读取它们自己的那部分资源的副本，那么每个进程只需要保存一个指向这个资源的指针就可以了。如果一个进程要“修改”自己的那份资源“副本”，那么就会复制那份资源，并把复制的那份提供给进程。这就是写入时复制。
  子进程们共享父进程的原始页，接下来这些页又可以被其他的父进程或者子进程共享。
  写时复制在内核中的实现很简单，要修改时，产生缺页中断，内核处理缺页中断的方式就是对该页进行一次透明复制，这时会清楚页面的COW属性，表示着它不再被共享。
  现在的计算机结构体系中都在内存管理单元MMU提供了硬件级别的COW支持，所以实现是很容易的。