C语言简单进程

进程：

进程是正在运行的程序的实例

进程是一个具有独立功能的程序关于某个数据集合的一次运行活动

是系统进行（资源分配和调度）的基本单位，是操作系统结构的基础

是一个动态的概念，是一个活动的实体

init是个有超级权限的用户进程

执行态（Running）：包括运行和就绪

  睡眠（sleeping）：

（S）浅睡眠 interruptable 进程在等待一个事件的发生或者某种系统资源，可响应异步信号

（D）深睡眠 uninterruptable 无法响应异步信号， kill -9 是杀不死的，

停止态（sTopped）进程被暂停或者跟踪状态(pause/trace)  ctrl+Z 

僵尸态（Zombie） 进程处于退出状态，不能被调度，但是PCB还没有被释放. 

 如子进程退出，父进程没有回收资源而且还在继续运行，这样就会造成子进程变成僵尸进程

实例一：进程创建

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int global = 10;
int main(void)
{
	//printf("pid = %d , ppid = %d \n", (int)getpid(), (int)getppid() );
	//while(1);

	pid_t id;//注意创建子进程返回的类型
	int val = 100;
	
	printf("before fork \n");
	id = fork();//创建子进程
	if(id < 0 )
	{
		printf("Fork failed \n"); // perror
		exit(1);
	}
	else if(id == 0)
	{	
		val--;
		global--;
		printf("in Child process %d, %d\n", val,global);
		printf("pid = %d , ppid = %d \n ", getpid(), getppid() );
	}	
	else if(id > 0)
	{
		//sleep(1);
		/*
		1、fork创建后，不保证两进程的调用顺序，
		也就是根据系统当前环境不同，可能先调用父进程也可能先调用子进程
		2、在这不加sleep,先执行父进程，然后父进程结束之后就执行父进程的父进程即是bash
		也就会先输出root@xx:,然后再输出子进程的内容，
		这时的子进程的父进程就不是此程序了，是被遗弃给了init。
		3、加上sleep就是先让子进程先显示，然后再显示出父进程的。
		子进程的父进程就也是此程序了，可以看pid。
		4、父、子进程共享正文段，不共享数据空间、堆、栈;
		子进程也是由父进程调用FORK后的代码开始执行，变量有独立的拷贝
		所以2个进程的val和global都不互相影响
		*/
		val --;	
		global--;
		printf("in Parent process %d, %d\n", val,global);
		printf("pid = %d , ppid = %d \n ", (int)getpid(), (int)getppid() );
	}
	
	
//	return 0;
	exit(0);
//	_exit(0);
}

2个进程执行输出。然后开另外一个终端，kill掉父进程，

子进程会继续执行，但父进程会变为1，不是此程序的父进程了。

在console中按ctrl+c，那是会给当前所有的会话中的进程发信号。

所以要用kill，但kill掉父进程后，再用ctrl+c也kill不掉子进程的。

也要用kill。但如果先kill掉子进程，再ctrl+c就可以kill掉父进程。

实例二：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
/*
创建一个子进程， 该子进程会执行一个程序
用exec族的函数
*/
int main()
{
	//printf("start of main\n");	
	pid_t id = fork();
	if(id < 0 )
	{
		printf("Fork failed \n"); // perror
		exit(1);
	}
	else if(id == 0)
	{	
		//printf("child pid = %d \n", getpid());
		
		if(execl("./homework","homework",NULL)<0)
		{
			perror("execl error!");
			exit(1);
		}
	}
	else if(id > 0)
	{
		int status;
		wait(&status);
		//sleep(1);
		printf("parent pid = %d \n", getpid());
	}
	exit(0);
}

实例三：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> 
/*
在父进程中创建两个子进程
子进程分别执行不同的内容
然后再回收
*/
void fun(void)
{
	printf("all die ~~~\n");
}

int main(int argc, char *argv[])
{
	int i, status;
	pid_t id, pid1, pid2;

	printf("%s's pid = %d\n", argv[0], (int)getpid());

	pid1 = fork();
	if (pid1 < 0)
	{
		perror("error to fork pid1\n");
		exit(0);
	}
	else if (pid1 == 0)
	{
		for (i = 0; i < 5; i++)
		{
			printf("child 1: pid = %d, ppid = %d\n", (int)getpid(), (int)getppid());
			sleep(1);
		}
		exit(0);
	}
	wait(&status);
	/*有特殊回收需求的，可以用waitpid<span style="white-space:pre">															</span>wait(&status);等价于waitpid(-1, &status, 0);<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>&status 可用NULL 代替。
	如果一个子进程结束时候没有被父进程回收资源，在父进程存在期间，它是作为僵尸进程；
	只有父进程结束时候，它由1号进程init收养后,init会回收该僵尸进程资源
	references:http://c.biancheng.net/cpp/html/289.html*/
	/*id = waitpid(pid1, &status,0);// wait pid1 
	printf("%d\n", i);*/
	/*这里回收资源，然后再fork一个子进程。如果放到最后和第2个子进程一起回收
	那输出显示的时候是交替的*/
	pid2 = fork();
	if (pid2 < 0)
	{
		perror("error to fork pid2\n");
		exit(0);
	}
	else if (pid2 == 0)
	{
		for (i = 0; i < 5; i++)
		{
			printf("child 2: pid = %d, ppid = %d\n", (int)getpid(), (int)getppid());
			sleep(1);
		}
		exit(0);
	}

	wait(&status);
	/*id = waitpid(pid2, &status,0);// wait pid2 
	printf("%d\n", i);*/
	//atexit 注册进程正常退出时候的处理程序， 注册的顺序和处理的顺序是相反的
	if(atexit(fun))
			perror("error1 ");
	/*
	上面思路是，fork一个，父进程处理函数后，再fork一个。
	OR:这个思路是先fork一个，然后进入到父进程处理函数里再fork一个。
	id=fork();
	if(id < 0 )//error
	else if(id == 0)//child process
	else if(id > 0)//parent process create fork again
		id = fork();
		if(id < 0 ) // perror
		else if(id == 0)//child process
		else if(id > 0)//parent process 
	*/
	exit(0);
}

相关函数介绍：

fork: 用fork创建子进程， 

返回值为-1的时候表示没有创建成功

创建成功的话，0是给子进程； 子进程ID返回给父进程

父、子进程共享正文段，不共享数据空间、堆、栈;

子进程也是由父进程调用FORK后的代码开始执行，变量有独立的拷贝

IO缓冲区也有拷贝

 

写时复制COW ( COPY ON WRITE)

 

fork创建后，不保证两进程的调用顺序，

也就是根据系统当前环境不同，可能先调用父进程也可能先调用子进程

 

vfork: 可以保证子进程先调， 直到子进程调用的exit或者是exec后，父进程才运行

        vfork产生的子进程是和父进程共用资源，数据和代码都共享

 

 

 

 

exec 函数族：（令子进程“脱胎换骨”）

 调用的exec后，如果启动成功，子进程就被新执行程序替换了，只保留了进程号, 其它都被替换；

 启动失败就返回-1 

 

man 3 environ

execl: exec list 用list挨个写cmd

execv: exec v 指针数组写cmd

 

execlp: execl path 使用系统环境变量PATH对应的路径中去寻找对应的可执行文件 

execvp: exec vp

 

execle: execl env 环境变量，也是用指针数值去写env

execve: exec ve ---- 内核调用

 

 

 

 

 

进程的退出：

_exit(0);  必须是自带有刷写io缓存的动作才能显示出来，这个退出函数是不会关闭IO缓冲区的

exit();  是会处理退出处理函数的，而且会关闭IO缓冲区

 

孤儿进程：父进程先于子进程结束了， 

这个时候子进程就变成孤儿进程，会由init进程接管；

该孤儿进程结束时候，init会自行回收资源

在bash里面调用一个可执行文件./func ，  func执行完了就会有一个信号SIGCHLD返回给bash

bash 收到信号后，就会显示gec@ubuntu:/mnt/hgfs/94/系统编程/0910/code$

即使现在还有孙子进程，bash也是不管，但是如果孙子进程要打印数据，依旧是在bash窗口里面显示

 

atexit 注册进程正常退出时候的处理程序， 注册的顺序和处理的顺序是相反的

atexit(func1) in atexit.c

 

 

进程同步（回收资源）

在进程结束的时候回收对应资源

如：之前在虚拟内存里面的申请到的堆数据， 

    如果进程是一直运行并且不断申请内存而不释放， 就会导致内存泄漏；

 

如果一个子进程结束时候没有被父进程回收资源，在父进程存在期间，它是作为僵尸进程；

    只有父进程结束时候，它由1号进程init收养后,init会回收该僵尸进程资源

 

wait （）:

等待子进程结束并回收资源 

 等待任意一个子进程

waitpid()：

有所扩展的wait 

 #include <sys/wait.h>

 

        pid_t wait(int *stat_loc); 

         pid_t waitpid(pid_t pid, int *stat_loc, int options);

 

int status ;

pid_t id;

id = wait(&status); < == > id = waitpid(-1, &status,0);

 

在waitpid里面的

pid > 0  就是等待具体的一个进程，其进程号为PID

    = 0  等待本进程组里任意子进程

    = -1   等待任意一个子进程

    < -1 , 等待ID为pid绝对值的进程组里的任意一个子进程

option

WNOHANG, 不需要有已结束进程，立刻返回，不会挂起，也就是不等待

WUNTRACED 若进程被暂停，sTop了，立即返回

WCONTINUED ：子进程收到SIGCONT立刻返回

 

 

 进程的终止：

5种正常

从main返回；

   return 0；

调用exit函数；

   会先执行一些清理处理，包括调用执行处理终止程序，关闭所有标准I/O流等，然后返回内核

调用_exit或_Exit函数；立即进入内核。

最后一个线程从其启动例程返回；

从最后一个线程调用pthread_exit；

 

3种异常

调用abort； SIGABRT

接到一个信号并终止；ctrl+c  ctrl +\ 

最后一个线程对取消请求作出响应；

实例二：