进程间共享的Posix mutex的锁定状态能否被子进程继承？

[justkk]

APUE中有这样一句话：
"By inheriting a copy of the address space, the child also inherits the state of every mutex, readerwriter lock, and condition variable from the parent process."

说父进程中的mutex的锁定状态会被子进程继承，但是没有提及具有进程间共享属性的mutex是否也遵守这一规则。
写了个小程序验证一下（程序中省略了错误检查）。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(void)
{
    pid_t pid;
    int   mid;
    int   bCreate = 0;      // 是否新建mutex
    key_t key = 0x12341234;

    pthread_mutex_t *mut;
    pthread_mutexattr_t attr;

    // shared memory
    mid = shmget(key, 0, 0);

    if( mid == -1 )         // 共享内存不存在，新建
    {
        bCreate = 1;
        mid = shmget(key, 64, IPC_CREAT | 0666);
    }
    mut = (pthread_mutex_t *) shmat(mid, 0, 0);

    if( bCreate == 1 )      // 初始化mutex，设置为进程间共享
    {
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_mutex_init(mut, &attr);
        pthread_mutexattr_destroy(&attr);
    }

    printf("lock\n");
    pthread_mutex_lock(mut);

    printf("fork\n");
    pid = fork();
    if( pid == 0 )          // 子进程无限期睡眠
    {
        while( 1 ) pause();
        exit(0);
    }

    printf("unlock\n");
    pthread_mutex_unlock(mut);

    printf("lock again\n");
    pthread_mutex_lock(mut);
    printf("over\n");

    pthread_mutex_destroy(mut);
    kill(pid, SIGKILL);     // 杀死子进程
    return(0);
}

1、初次执行时，程序会创建共享内存，初始化mutex。结果是无停顿执行完毕。
--看来父进程中的锁定状态没有被子进程继承，否则父进程的lock again不能完成。
2、再次执行时，程序阻塞在第一个lock的位置
--UNP第二卷中，说“Posix mutex具有随进程的持续性”，看来也不适用于具有进程间共享属性的mutex

经验不足，不知道理解的对不对，求证一下。

[zsjay758]

[Quote=引用 5 楼 justkk 的回复:]

引用 1 楼 zsjay758 的回复:“父进程中的mutex的锁定状态会被子进程继承”？ 我在APUE的第八章看到的是“父进程设置的锁，子进程不继承”...
我手头没有中文版。那儿说的锁是什么类型的锁？
[/Quote]

在第八章没有详细说明是什么锁，只有在说记录锁的时候有说：“由f o r k产生的子程序不继承父进程所设置的锁”

[justkk]

那就是fcntl记录锁了，它好像不会被继承.
谢谢支持，先回家了，明天再来看贴

[justkk]

我找到那句话了，是文件锁，应该就是指fcntl记录锁了
"The differences between the parent and child are:
. The return value from fork
. The process IDs are different
. The two processes have different parent process IDs ...
. ...
. File locks set by the parent are not inherited by the child"

[谭海燕]

里面说道的是文件锁。但是，互斥锁应该不会被继承。回去我也测试下。以前记得里面哪里有一句话说锁不会被继承。

[justkk]

在AIX 5.3、SunOS 5.9、HP-UX B.11.23、Linux version 2.6.22.5-31分别验证了一下，总结如下：
对于非进程间共享的Posix mutex，fork()之后，子进程会继承父进程中的锁定状态。
这也与APUE中的描述相符。
代码如下，有兴趣的同学请验证一下，欢迎大家拍砖.. 编译时指定-lpthread

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

int main(void)
{
    pid_t pid;
    pthread_mutex_t mut;
    pthread_mutexattr_t attr;

    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
    pthread_mutex_init(&mut, &attr);
    pthread_mutexattr_destroy(&attr);

    printf("lock\n");
    pthread_mutex_lock(&mut);

    printf("fork\n");
    pid = fork();
    if( pid == 0 )          // 子进程尝试锁定
    {
        printf("child: lock\n");
        pthread_mutex_lock(&mut);
        printf("child: lock again\n");
        pthread_mutex_lock(&mut);
        printf("child: over\n");

        exit(0);
    }

    pthread_mutex_destroy(&mut);
    return(0);
}

我在上述环境中的试验结果是一致的，子进程总是阻塞在第一个lock的调用上。

另外，如果编译时不指定-lpthread，在Sun、HP环境可以编译通过，子进程两次锁定成功，迷惑...
不知道不指定-lpthread编译时的语义是什么？

[justkk]

[Quote=引用 6 楼 zsjay758 的回复:]奇怪，这段代码在我的机子上测试是能够顺利执行的（子进程并不会阻塞），我用的书ubuntu9.10的系统[/Quote]
在你的环境中，能输出"child over"吗？
程序运行后，父进程是退出了，然后shell显示了命令行提示符，但是子进程还在阻塞。
你用ps命令看看呢

[zsjay758]

第一次测试（使用你上面的代码）：
jackson@jackson-desktop:~/桌面$ ./mut
lock
fork
child: lock
child: over

第二次测试（将pthread_mutex_lock改为pthread_mutex_trylock）
jackson@jackson-desktop:~/桌面$ g++ -o mut mutex.cpp -lpthread
jackson@jackson-desktop:~/桌面$ ./mut
lock
fork
child: lock
try lock errno:16
child try lock: Device or resource busy
child: over

最后一次测试（重新改为pthread_mutex_lock）：
jackson@jackson-desktop:~/桌面$ g++ -o mut mutex.cpp -lpthread
jackson@jackson-desktop:~/桌面$ ./
lock
fork
child: lock

第一次测试和后两次测试结果居然不同，此后测试也都是子进程阻塞，迷糊了。。。。
机子重启之后，重新编译mut，按上面的流程测试，测试结果跟上面一样....

[zsjay758]

发现一点，就是当我不适用-lpthread选项去编译你上面的程序的时候，运行，父子进程都正常退出，而如果加上-lpthread，则子进程阻塞....

[justkk]

不使用-lpthread选项编译时，你可以检查一下子进程中的pthread_mutex_lock是否成功，怀疑出错了..

[zsjay758]

对于父子进程，pthread_mutex_lock返回值都是0，但是连续的调用pthread_mutex_lock(&mut)，每次返回值也都是0，似乎在没有-lpthread选项的情况下，pthread_mutex_lock并没有起到作用。
在没有-lpthread的情况下，似乎是通过semaphore实现mutex的，而pthread是利用futex实现mutex。

[justkk]

会不会在你的环境中，mutex的缺省属性是PTHREAD_MUTEX_RECURSIVE类型的？
试试这个代码

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

int main(void)
{
    int t;
    pid_t pid;
    pthread_mutex_t mut;
    pthread_mutexattr_t attr;

    pthread_mutexattr_init(&attr);
    pthread_mutexattr_gettype(&attr, &t);
    printf("mutex type=%d\n", t);
    pthread_mutex_init(&mut, &attr);
    pthread_mutexattr_destroy(&attr);

    printf("lock\n");
    pthread_mutex_lock(&mut);

    printf("fork\n");
    pid = fork();
    if( pid == 0 )          // 子进程尝试锁定
    {
        printf("child: lock\n");
        pthread_mutex_lock(&mut);
        printf("child: over\n");

        exit(0);
    }

    pthread_mutex_destroy(&mut);
    return(0);
}

在我的环境中，显示mutex type=0，子进程阻塞..

[justkk]

顶一下，高手给个说法哈..

[快乐田伯光]

Mutex本来就不是用于进程间通讯的方式, 是用于线程间通讯的, 研究这个有何意义?

[justkk]

哈，谢谢关注..
只是对APUE中的那句话有点疑问
"By inheriting a copy of the address space, the child also inherits the state of every mutex, readerwriter lock, and condition variable from the parent process."

[快乐田伯光]

是的,fork的时候复制整个内存空间,就会包括mutex, readerwriter lock, condition variable等线程间通讯的方式.
[Quote=引用 21 楼 justkk 的回复:]
哈，谢谢关注..
只是对APUE中的那句话有点疑问
"By inheriting a copy of the address space, the child also inherits the state of every mutex, readerwriter lock, and condition variable from the parent process."
[/Quote]

[kakam]

"By inheriting a copy of the address space, the child also inherits [color=#FF00FF]the state of every mutex[/color], readerwriter lock, and condition variable from the parent process."

[kakam]

"By inheriting a copy of the address space, the child also inherits the state of every mutex, readerwriter lock, and condition variable from the parent process."

[kakam]

所有的mutex的状态也被继承过来了,当然你进程lock后子进程不能在lock.你父进程将状态改变后,子进程才能lock

[do多多do]

记住了，赞楼主。 有个疑问，mutex应该是需要操作系统来维护其等待队列的，难道fork一个进程的时候，操作系统除了产生进程相关的描述信息外，还会复制该队列？

[do多多do]

楼主的第一个例子中，由于最后没有unlock,而共享存储区又没有删除，因此，程序结束后，其中的状态仍然是locked的状态。下次获取的是同样的内存地址，由于已经是locked status, 因此lock会导致死锁。 destroy之前先unlock则不会对后面的执行产生影响。