UNIX下对象析构在多进程中的行为分析

fork( )的主要任务是初始化要创建进程的数据结构，其主要的步骤有(以下内容取自joyfire笔记)：
1)申请一个空闲的页面来保存task_struct；
2)查找一个空的进程槽（find_empty_process( ))；
3)为kernel_stack_page申请另一个空闲的内存页作为堆栈；
4)将父进程的LDT表拷贝给子进程；
5)复制父进程的内存映射信息；
6)管理文件描述符和链接点。

那么，若在父进程中创建了一个对象，则经过fork，对象会有什么特殊表现呢？看看下面的程序：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

class CA
{
public:
        CA(){ printf("construct CA/n"); }
        ~CA() { printf("destruct CA/n"); }
};

int main(int argc, char **argv)
{
        pid_t pid;
        pid_t wpid;
        int status;

        CA a;

        pid = fork();

        if ( pid == (pid_t)-1 )
        {
                fprintf(stderr, "%s: Failed to fork()/n", strerror(errno));
                exit(13);
        }
        else if ( pid == 0)
        {
                printf("PID %ld: Child started, parent is %ld./n",
                        (long)getpid(),
                        (long)getppid());
                return 0;
        }

        printf("PID %ld: Started child PID %ld./n",
                (long)getpid(),
                (long)pid);

        wpid = wait(&status);
        if ( wpid == (pid_t)-1 )
                perror("wait(2)");

        return 0;
}
以下是程序某次运行结果：
construct CA
PID 29423: Child started, parent is 29422.
destruct CA
PID 29422: Started child PID 29423.
destruct CA
结果显示：对象被构造了一次，但是被析构了两次。
为什么会这样呢？这正是fork使得子进程复制父进程的内存映射信息的结果。对于类似这样的代码：
void main()
{
    CA a; //CA是一个类
}
其等价的汇编代码大概是下面这样：
10:   void main()
11:   {
00401030   push        ebp
00401031   mov         ebp,esp
00401033   sub         esp,44h
00401036   push        ebx
00401037   push        esi
00401038   push        edi
00401039   lea         edi,[ebp-44h]
0040103C   mov         ecx,11h
00401041   mov         eax,0CCCCCCCCh
00401046   rep stos    dword ptr [edi]
12:       CA a;
00401048   lea         ecx,[ebp-4]
0040104B   call        @ILT+0(CA::CA) (00401005)
13:   }
00401050   lea         ecx,[ebp-4]
00401053   call        @ILT+5(CA::~CA) (0040100a)
00401058   pop         edi
00401059   pop         esi
0040105A   pop         ebx
0040105B   add         esp,44h
0040105E   cmp         ebp,esp
00401060   call        __chkesp (00401120)
00401065   mov         esp,ebp
00401067   pop         ebp
00401068   ret
也就是说，何时插入构造/析构函数调用代码，完全是在编译期间确定的。fork后，子进程由于完全拷贝了父进程内存映射信息（含代码段和调用堆栈信息），将继续执行调用堆栈指定的指令，因此，后面的call        @ILT+5(CA::~CA) (0040100a)将被两次执行。
fork的以上特点有时被用于在父子进程间传递信息（由父进程->子进程，这种传递是单向的）。

那么，我们如何屏蔽上面重复输出的析构消息呢，通过在网上的讨论，有以下建议：
1、上策：不要在fork 中使用可重入的语句，诸如printf；
2、下策：在CA中添加一个标志，并在析构函数中根据该标志进行输出；
对于第二方案，修改后的程序如下：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

class CA
{
public:
        CA();
        ~CA();

        int _childFlag;
};

CA::CA()
{
        _childFlag = 0;
        printf("construct CA/n");
}

CA::~CA()
{
        if (!_childFlag)
        {
                printf("destruct CA/n");
        }
}

int main(int argc, char **argv)
{
        pid_t pid;
        pid_t wpid;
        int status;

        CA a;

        pid = fork();

        if ( pid == (pid_t)-1 )
        {
                fprintf(stderr, "%s: Failed to fork()/n", strerror(errno));
                exit(13);
        }
        else if ( pid == 0)
        {
                a._childFlag = 1;
                printf("PID %ld: Child started, parent is %ld./n",
                        (long)getpid(),
                        (long)getppid());
                return 0;
        }

        printf("PID %ld: Started child PID %ld./n",
                (long)getpid(),
                (long)pid);

        wpid = wait(&status);
        if ( wpid == (pid_t)-1 )
                perror("wait(2)");

        return 0;
}

附注：以上是一个很无聊的话题，但几周前被人问及，特记录于此。