Linux中的进程管理

我们先来看下基本概念：
1.进程
进程是一个具有一定独立功能的程序的一次运行活动
特点：动态性、并发性、独立性、异步性

下面是系统的几个状态

一开始的程序都处于就绪状态。
2 进程ID
进程ID(PID)：标识进程的唯一数字
父进程的ID:PPID
启动进程的用户ID:UID
3.进程互斥
进程互斥是指当有若干进程都要使用某一共享资源时，任何时刻最多允许一个进程使用，其他要使用该资源的进程必须等待，直到占用该资源者释放了该资源为止
4.临界资源
操作系统中将一次只允许一个进程访问的资源称为临界资源。进程中访问临界资源的那段程序代码称为临界区。
5.进程同步
一组并发进程按一定的顺序执行的过程称为进程间的同步。具有同步关系的一组并发进程称为合作进程，合作进程间互相发送的信号称为消息或事件。
6.进程调度
按一定的算法，从一组待运行的进程中选出一个来占有CPU运行
调度方式：抢占式和非抢占式
调度算法：先来先服务调度算法
短进程优先调度算法
高优先级优先调度算法
时间片轮转法
7.死锁
多个进程因竞争资源而形成一种僵局，若无外力作用，这些进程都将永远不能再向前推进

获取ID

有两个函数
getpid(); //获取子进程
getppid(); //获取父进程
包含头文件
#include<unistd.h> #include<stdlib.h>

进程创建 fork(比较重要)
#include <unistd.h> pid_t fork(void)
创建子进程
fork被掉用一次，缺返回两次，有三种不同的返回值
1.在父进程中，fork返回新创建的子进程的PID 大于0
2.在子进程中,fork返回0
3.如果出现错误，fork返回一个负值
返回用来判断fork之后的程序是父进程还是子进程

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.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;
		printf("I am the child: %s\n", getpid());
		for(i=0;i<1000000;i++) sin(i);
		i=5;
		printf("I exit with %d\n", i);
		exit(i);
	}

	while(((child=wait(&status))==-1)&(errno==EINTR));  //子进程未结束

	if(child==-1)
		printf("Wait Error: %s\n", strerror(errno));
	else if(!status)             // 子进程退出值为0
		printf("Child %ld terminated normally return status is zero\n", child);
	else if(WIFEXITED(status))   // 子进程退出值0
		printf("Child %ld terminated normally return status is %d\n", child, WEXITSTATUS(status));
	else if(WIFSIGNALED(status)) // 子进程未获信号而退出
		printf("Chlid %ld terminated due to signal %d not caught\n", child, WTERMSIG(status));
}	

思考一个问题：
如果一个程序中如下：

main(void)
{
  pid_t pid ;
  int count=0;
   pid=fork();
   count++;
   printf("count=%d\n",count);
}

打印的count的值是多少(两次都是1)，可以去linux下去运行下。这是因为子进程的数据空间、堆栈空间都会从父进程得到一个拷贝，而不是共享。在子进程中对count进行加1的操作，并没有影响到父进程的count值，父进程中的count值仍然为0。

再举一个例子：

// 请问下面的程序一共输出多少个“-”？为什么？
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(void) {
   int i;
   for (i=0; i<2; i++) {
      fork();
      printf("-\n");
   }
   return 0;
}

1.printf("-\n");对于行输出/n有清除缓存的作用；
2.fork（）可以复制父进程的缓存，变量值等信息；
3.i＝0时，父进程A产生一个子进程A1，此时输出两行“－”；
4.i＝1时，fork使父进程A产生子进程A2，A1产生子进程A3，此时A－A3共产生4行“－”（因为现在A，A1的输出行缓冲均为空）；
总数为6：2（A）＋2（A1）＋1（A2）＋1（A3）＝6；

如果printf("-");
由于A2，A3会继承A和A1的输出行缓冲区，所以会分别输出两个“－”，加起来为：2（A）+2（A1）＋2（A2）+2（A3）=8；

还有一个函数vfork也是创建子进程
#include<sys/types.h>
#include<unistd.h>
pid_t vfork(void)

两者区别：

1. fork:子进程拷贝父进程的数据段
   vfork：子进程与父进程共享数据段
2. fork:父、子进程的执行次序不确定
   vfork：子进程先运行，父进程后运行

main(void)
{
  pid_t pid ;
  int count=0;
   pid=vfork();
   count++;
   printf("count=%d\n",count);
}

换成vfork，count的值将变成多少1 ，2 . 1是子程序的运行的，2是父进程运行的

3.exec函数
exec用被执行的程序替换调用它的程序
区别： fork创建一个新的进程,产生一个新的PID
exec启动一个新程序,替换原有的进程,因此进程的PID不会改变
比较简单，不多说

wait函数
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status)
阻塞该进程，直到其某个子进程退出

代码

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

void die(const char *msg)
{
        perror(msg);
        exit(1);
}

void child2_do()
{
        printf("In child2: execute 'date'\n");

        sleep(5);
        if (execlp("date", "date", NULL) < 0) {
                perror("child2 execlp");
        }
}

void child1_do(pid_t child2, char *argv)
{
        pid_t pw;

        do {
                if (*argv == '1') {
                        pw = waitpid(child2, NULL, 0);
                }
                else {
                        pw = waitpid(child2, NULL, WNOHANG);
                }
                if (pw == 0) {
                        printf("In child1 process:\nThe child2 process has not exited!\n");
                        sleep(1);
                }
        }while (pw == 0);

        if (pw == child2) {
                printf("Get child2 %d.\n", pw);
                sleep(5);
                if (execlp("pwd", "pwd", NULL) < 0) {
                        perror("child1 execlp");
                }
        }
        else {
                printf("error occured!\n");
        }
}

void father_do(pid_t child1, char *argv)
{
        pid_t pw;

        do {
                if (*argv == '1') {
                        pw = waitpid(child1, NULL, 0);
                }
                else {
                        pw = waitpid(child1, NULL, WNOHANG);
                }

                if (pw == 0) {
                        printf("In father process:\nThe child1 process has not exited.\n");
                        sleep(1);
                }
        }while (pw == 0);

        if (pw == child1) {
                printf("Get child1 %d.\n", pw);
                if (execlp("ls", "ls", "-l", NULL) < 0) {
                        perror("father execlp");
                }
        }
        else {
                printf("error occured!\n");
        }
}

int main(int argc, char *argv[])
{
        pid_t child1, child2;

        if (argc < 3) {
                printf("Usage: waitpid [0 1] [0 1]\n");
                exit(1);
        }

        child1 = fork();

        if (child1 < 0) {
                die("child1 fork");
        }
        else if (child1 == 0) {
                child2 = fork();

                if (child2 < 0) {
                        die("child2 fork");
                }
                else if (child2 == 0) {
                        child2_do();
                }
                else {
                        child1_do(child2, argv[1]);
                }
        }
        else {
                father_do(child1, argv[2]);
        }

        return 0;
}