多进程服务器端

1.调用fork函数创建进程

 

fork函数：

#include<unistd.h>

pid_t fork(void);

//成功时返回进程ID，失败时返回-1

fork函数将创建进程副本，两个进程将执行fork函数调用后的语句，且之后的程序要根据fork函数的返回值加以区分。

父进程（原进程）：fork函数返回子进程ID

子进程（进程副本）：fork函数返回0

fork函数调用后分成了完全不同的进程，只是两者共享同一份代码，父子进程拥有完全独立的内存结构，接下来是一个示例。

#include<stdio.h>
#include<unistd.h>

int gval=10;
int main(int argc,char *argv[])
{
	pid_t pid;
	int lval=20;
	gval++;
	lval+=5;

	//创建子进程。父进程的pid中存有子进程的ID,子进程的pid是0
	pid=fork();
	//if Child Process
	if(pid==0)
	{
		gval+=2;
		lval+=2;
	}
	//if Parent Process
	else
	{
		gval-=2;
		lval-=2;
	}

	if(pid==0)
		printf("Child proc: [%d,%d] \n",gval,lval);
	else 
		printf("Parent proc: [%d,%d] \n",gval,lval);

	return 0;
}

输出结果：

Parent proc: [9,23]
Child proc: [13,27]

2.僵尸进程

进程完成工作后（执行完main函数中的程序后）应被销毁，但有时这些进程将变成僵尸进程，占用系统中的重要资源。

调用fork函数产生的子进程有以下两种结束方式：

（1）传递参数并调用exit函数

（2）main函数中执行return语句并返回值

产生原因：向exit函数传递的参数值和main函数的return语句返回的值都会传递给操作系统。而操作系统不会销毁子进程，直到把这些值传递给产生该子进程的父进程。处在这种状态下的进程就是僵尸进程。

解决办法：向创建子进程的父进程传递子进程的exit参数值或return语句的返回值。

操作系统不会主动把这些值传递给父进程，只有父进程主动发起请求（函数调用）时，操作系统才会传递该值。

下面一个是一个僵尸进程的示例（./zombie &：后台运行）：

#include<stdio.h>

#include<unistd.h>

int main(int argc,char *argv[])
{
	pid_t pid=fork();

	if(pid==0)
	{
		puts("Hi, I am a child process");
	}
	else 
	{
		printf("Child Process ID: %d \n",pid);
		//如果父进程终止，处于僵尸状态的子进程将同时销毁
		sleep(30);
	}

	if(pid==0)
		puts("End child process");
	else 
		puts("End parent process");
	return 0;
}

 输出：

Child Process ID: 8692
Hi, I am a child process
End child process
End parent process

 如上图，PID为8692的进程为僵尸进程。

3.销毁僵尸进程

3.1.利用wait函数

wait函数：

#include<sys/wait.h>

//成功时返回终止的子进程ID，失败时返回-1
pid_t wait(int *statoc);

调用此函数时如果已有子进程终止，那么子进程终止时候时传递的返回值（exit函数的参数值、main函数的return返回值）将保存到该函数的参数所指向的内存空间。但函数参数指向的单元中还包含其他信息，因此需要通过下列宏进行分离。

if(WIFEXITED(status))
{
    puts("Normal termination!")
    printf("Child pass num: %d\n",WEXITSTATUS(status));
}
				

下面示例利用wait函数销毁僵尸进程

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

int main(int argc,char *argv[])
{
	int status;
	pid_t pid=fork();

	if(pid==0)
	{
		return 3;
	}
	else 
	{
		printf("Child PID: %d \n",pid);
		pid=fork();
		if(pid==0)
		{
			exit(7);
		}
		else 
		{
			printf("Child PID: %d\n",pid);
			wait(&status);
			if(WIFEXITED(status))
				printf("Child send one: %d \n",WEXITSTATUS(status));

			wait(&status);
			if(WIFEXITED(status))
				printf("Child send two: %d \n",WEXITSTATUS(status));
			sleep(30);
		}

	}
	return 0;
}

运行结果：

Child PID: 8965
Child PID: 8966
Child send one: 3
Child send two: 7

已经没有僵尸进程

 需要注意的是：调用wait函数时，如果没有已终止的子进程，程序将阻塞（Blocking）直到有子进程终止，因此需谨慎调用该函数。

3.1利用waitpid函数

wait函数会引起程序的阻塞，还可以考虑调用waitpid函数

#include<sys/wait.h>

pid_t waitpid(pid_t pid,int *statloc,int options);
//成功时返回终止的子进程ID(或0),失败时返回-1
//pid:等待终止的目标进程id，传递-1，则与wait相同，可以等待任意子进程终止
//statloc 与wait相同
//设为WNOHANG

示例：

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

int main()
{
	int status;
	pid_t pid=fork();

	if(pid==0)
	{
		sleep(15);
		return 24;
	}
	else 
	{
                //若之前没有终止的子进程将返回0
		while(!waitpid(-1,&status,WNOHANG))
		{
			sleep(3);
			puts("sleep 3sec.");
		}

		if(WIFEXITED(status))
			printf("Child send %d \n",WEXITSTATUS(status));

	}

	return 0; 
}

输出:

sleep 3sec.
sleep 3sec.
sleep 3sec.
sleep 3sec.
sleep 3sec.
Child send 24

4.信号处理

父进程往往与子进程一样繁忙，因此不能只调用waitpid函数以等待子进程的终止

引入信号机制：进程发现自己的子进程结束时，请求操作系统调用特定函数。

4.1.signal函数

signal函数，第一个参数为特殊情况信息，第二个参数为特殊情况下将要调用的函数的地址值。

发生第一个参数代表的情况时，调用第二个参数所指的函数。

SIGALRM：已到通过调用alarm函数注册的时间

SIGINTL：输入CTRL+C

SIGCHLD：子进程终止

使用示例：

#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void timeout(int sig)
{
	if(sig==SIGALRM)
		puts("Time out!");
	alarm(2);
}

void keycontrol(int sig)
{
	if(sig==SIGINT)
		puts("CTRL+C pressed");
}

int main(int argc,char *argv[])
{
	signal(SIGALRM,timeout);
	signal(SIGINT,keycontrol);
	alarm(2);
	for(int i=0;i<3;i++)
	{
		puts("wait...");
		sleep(100);
	}
	return 0;
}

输出：

wait...
Time out!
wait...
Time out!
wait...
Time out!

产生信号时，为了调用信号处理器，将唤醒由于调用sleep函数而进入阻塞状态的进程。而且进程一旦被唤醒，就不会再进入睡眠状态。

4.2.sigaction函数

signal函数在UNIX系列的不同操作系统中可能存在区别，但sigaction函数完全相同，因此现在很少使用signal函数编写程序

示例：

#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void timeout(int sig)
{
	if(sig==SIGALRM)
		puts("Time out!");
	alarm(2);
}

int main(int argc,char *argv[])
{
	struct sigaction act;
	act.sa_handler=timeout;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	sigaction(SIGALRM,&act,0);

	alarm(2);
	for(int i=0;i<3;i++)
	{
		puts("wait...");
		sleep(100);
	}

	return 0;

}

5.利用信号处理技术消灭僵尸进程

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

void read_childproc(int sig)
{
	int status;
	pid_t id=waitpid(-1,&status,WNOHANG);
	if(WIFEXITED(status))
	{
		printf("Removed proc id: %d \n",id);
		printf("Child send: %d \n",WEXITSTATUS(status));
	}
}

int main(int argc,char *argv[])
{
	pid_t pid;
	struct sigaction act;
	act.sa_handler=read_childproc;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	sigaction(SIGCHLD,&act,0);

	pid=fork();
	if(pid==0)
	{
		puts("Hi! I'm child process");
		sleep(10);
		return 12;
	}
	else
	{
		printf("Child proc id: %d \n",pid);
		pid=fork();
		if(pid==0)
		{
			puts("Hi! I'm child process");
			sleep(10);
			exit(24);
		}
		else
		{
			printf("Child proc id: %d \n",pid);
			for(int i=0;i<5;i++)
			{
				puts("wait...");
				sleep(5);
			}
		}
	}

	return 0;

}

运行结果：

Hi! I'm child process
Child proc id: 9900
wait...
Hi! I'm child process
wait...
Removed proc id: 9899
Child send: 12
wait...
Removed proc id: 9900
Child send: 24
wait...
wait...