fork()父子进程变量之间的关系与信号的响应

1.变量关系：

根据《unix 高级环境编程》中的一句话：子进程和父进程继续执行fork调用之后的指令。子进程是父进程的副本。例如：子进程获取父进程数据空间，堆和栈的副本。注意，这是子进程所拥有的副本。父子进程并不共享这些存储空间部分。父子进程共享正文段（就是代码段.text）。

个人理解:就是说一子进程会复制父进程的数据，但是这些数据是存放在另一个地方的，双方的数据都是对自己可见而已，你不可能通过一个变量来进行双方的通信！！！

下面来做个小测试，关于变量的可见性：

volatile int g_val = 0;
int main()
{
int val = 0;
pid_t fpid;

printf("\nprocess\tpid\tppid\tcpid\tval\tval_address\tg_val\tg_val_address \n");
printf("%s\t%d\t%d\t  \t%d\t%x\t%d\t%x\n","main",getpid(),getppid(),val,&val,g_val,&g_val);

if ((fpid = fork()) < 0)
printf("fork error\n");
else if (0 == fpid)//child
{
val++;
g_val++;
printf("%s\t%d\t%d\t%d\t%d\t%x\t%d\t%x\n","child",getpid(),getppid(),fpid,val,&val,g_val,&g_val);
}
else//father
{
sleep(5);//wait for child exit,and we can sure the variable has changed but maybe the result is not like what we think it is.
//printf("father wakes up\n");
printf("%s\t%d\t%d\t%d\t%d\t%x\t%d\t%x \n","father",getpid(),getppid(),fpid,val,&val,g_val,&g_val);
}

return 0;
}

测试结果：

[root@localhost src]# ./sig_main

process   pid	    ppid	cpid	 val	 val_address	  g_val	   g_val_address
main	  2976	   2698	  	         0	   bfcd7ce8	     0	     8049138
child	  2977	   2976	         0	 1	   bfcd7ce8	     1	     8049138
father	  2976	   2698  	2977	 0	   bfcd7ce8	     0	     8049138
[root@localhost src]#

从结果可以看出来：子进程修改的值并没有对父进程有影响。但是变量的地址都是一样的，数据却是不一样的。怎么理解。。。。。个人觉得吧，物理地址一定是一样的，但是它们的逻辑地址是不一样的，就是进程的虚拟地址是不一样的，不知道对不对，先这样觉得吧。

2.信号响应

对于父子进程，都能响应信号，但是，如果我发一个SIGINT信号一次，那么父子进程都响应这个信号（前提是父子进程都注册了这个信号响应）吗？另外信号处理程序只有一个，父子进程是共享的，那么，当父子进程分别响应信号时，是否在各自的进程领域内？

从第一点来看，父子进程正文段是共享的，但数据存储区并不是共享的，那么数据是属于进程领域内的。

那么问题是什么?这里想验证一下，同一个信号响应处理程序是不是对父子的调用是独立的。

测试代码：

<pre name="code" class="cpp">volatile int flag = 0;
void myhandler(int signo)
{
pid_t fpid;
if (SIGUSR1 == signo)
printf("receive SIGUSER1\n");
else if (SIGUSR2 == signo)
printf("receive SIGUSER2\n");
else if ( SIGALRM == signo)
{
fpid = getpid();
printf("pid = %d\n",fpid);
alarm(2);
}
else if (SIGINT == signo)
{
printf("SIGINT catch\n");
fpid = getpid();
printf("in handle pid = %d\n",fpid);
}
else if (SIGCHLD == signo)
{
printf("SIGCHLD catch\n");
fpid = getpid();
printf("in handle pid = %d\n",fpid);
flag = 1;
printf("wait child succeed\n");
}

else
printf("received signal %d\n",signo);

//printf("alarm handler\n");
}

int main()
{
pid_t fpid;
sigset_t newmask,oldmask,waitmask;
/*为父子进程同时注册信号*/
if (signal(SIGUSR2,myhandler) == SIG_ERR)
printf("can't catch SIGUSER2");
if (signal(SIGUSR1,myhandler) == SIG_ERR)
printf("can't catch SIGUSER1");
if (signal(SIGALRM,myhandler) == SIG_ERR)
printf("can't catch SIGUSER1");
if (signal(SIGQUIT,myhandler) == SIG_ERR)
printf("can't catch SIGQUIT");
if (signal(SIGINT,myhandler) == SIG_ERR)
printf("can't catch SIGQUIT");
if (signal(SIGCHLD,myhandler) == SIG_ERR)
printf("can't catch SIGCHLD");

sigemptyset(&waitmask);
fpid = fork();

if (0 == fpid)//child
{
printf("start child pid = %d\n",getpid());
//sigaddset(&newmask,SIGINT);
//sigprocmask(SIG_BLOCK,&newmask,&oldmask);//子进程不接收中断信号
sleep(10);
printf("child exit\n");

}
else//father
{
printf("wait child,father pid=%d\n",getpid());
while (flag == 0)//这样做是因为这期间可能会有很多信号到来，然后sigsuspend会被唤醒，但这并是我想要的信号，所以等。
sigsuspend(&waitmask);
fpid = wait();
flag = 0;
printf("father exit,getchild pid:%d \n ",fpid);
}

return 0;
}

说明：

测试程序流程：子进程先休眠10s，在这个过程任何信号可唤醒子进程。父进程等待子进程结束，而这个过程接收任意信号。

测试结果：
[root@localhost src]# ./sig_main

wait child,father pid=8065

start child pid = 8066

^CSIGINT catch

in handle pid = 8066

child exit

SIGCHLD catch

in handle pid = 8065

wait child succeed

SIGINT catch

in handle pid = 8065

father exit,getchild pid:8066

[root@localhost src]#



NOTE:

上面的^C 是crtl+c 发送一个SIGINT信号

一个SIGINT信号，父子进程都接收了，并且是分别接收的，从PID就可以看出来。