linux——进程替换

如果给一个进程发送一个 SIGINT 信号，进程的信号处理函数需要执行 10 秒钟才能结束，
然后再 10 秒之内， 又给其发送了 SIGINT 信号， 进程如果执行。
1、 如果第二次发送的信号和第一次不同？ ？
2、 信号处理函数需要尽可能的快。

代码//

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>
#include <signal.h>

void sig_fun(int sign)
{
	printf("sig_fun start  %d\n", sign);
	int i = 0;
	for(; i < 10; ++i)
	{
		sleep(1);
		printf("sig_fun running\n");
	}
	printf("sig_fun end\n");
	signal(sign, SIG_DFL);
}

void main()
{
	signal(SIGINT, sig_fun);
	signal(SIGTERM, sig_fun);

	while(1)
	{
		sleep(2);
		printf("main running\n");
	}
}

进程替换： exec 系列函数
何为进程替换： 一个运行的进程通过某种方式， 用磁盘上存储的程序（可执行文件） 覆
盖 原进程的所有的指令和数据。
int execl(char *pathfile, char *argv1, char*argv2, .... , (char*)0);
int execv(char *pathfile, char *argv[]);

int execl(const char *path,  char *arg, ...（char*）0)，;

int execlp(const char *file,  char *arg, ...);

int execle(const char *path,  char *arg, ..., char * const envp[]);

int execv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

练习题：
1 、 exec 进程启动输出“。。。。”， sleep 2 秒， fork 生成子进程， 子进程调用可执行
程序 main ， 父进程输出“ father start ”， 然后 sleep 3 秒， 输出“ father over ”； main 程序输
出传递给主函数的参数。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>

void main()
{
	printf("exec start\n");

	sleep(2);

	printf("exec front pid == %d\n", getpid());

	execl("./mykill", "./mykill", (char *)0);

	printf("exec finish\n");

	sleep(2);

	printf("exec end\n");
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <signal.h>

int main(int argc, char *argv[])
{
	printf("mykill pid == %d\n", getpid());
	if(argc < 2)
	{
		printf("please input pid\n");
		exit(0);
	}

	//argv[1] = "1234";
	int pid = 0;

	sscanf(argv[1], "%d", &pid);
	printf("pid == %d\n", pid);

	if(kill(pid, SIGCHLD) == -1)
	{
		perror(NULL);
		exit(0);
	}
}

深入分析：：
父进程通过 fork 产生子进程， 如果子进程是父进程复制而来， 那么子进程开调用
exec 用新程序替换本身。 子进程复制父进程的过程就是无用的。
写时拷贝技术：
fork 产生子进程时， 并不会完全复制其父进程。 内核将父进程的所有空间设置为只读，
父子进程共享这些空间， 当父子进程任意一个进程试图修改某个数据时， 内核会将数据所在
的“页” 整体拷贝一份