c-克隆人的奇怪行为

这是一个相当简单的应用程序，它使用clone()调用创建了一个轻量级进程（线程）。

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#define STACK_SIZE 1024*1024
int func(void* param) {
    printf("I am func, pid %dn", getpid());    
    return 0;
}
int main(int argc, char const *argv[]) {
    printf("I am main, pid %dn", getpid());
    void* ptr = malloc(STACK_SIZE);
    printf("I am calling clonen");             
    int res = clone(func, ptr + STACK_SIZE, CLONE_VM, NULL);
    // works fine with sleep() call
    // sleep(1);
    if (res == -1) {
        printf("clone error: %d", errno);       
    } else {
        printf("I created child with pid: %dn", res);      
    }
    printf("Main done, pid %dn", getpid());        
    return 0;
}

以下是结果：

运行1:

➜  LFD401 ./clone
I am main, pid 10974
I am calling clone
I created child with pid: 10975
Main done, pid 10974
I am func, pid 10975

运行2:

➜  LFD401 ./clone
I am main, pid 10995
I am calling clone
I created child with pid: 10996
I created child with pid: 10996
I am func, pid 10996
Main done, pid 10995

运行3:

➜  LFD401 ./clone
I am main, pid 11037
I am calling clone
I created child with pid: 11038
I created child with pid: 11038
I am func, pid 11038
I created child with pid: 11038
I am func, pid 11038
Main done, pid 11037

运行4:

➜  LFD401 ./clone
I am main, pid 11062
I am calling clone
I created child with pid: 11063
Main done, pid 11062
Main done, pid 11062
I am func, pid 11063

这是怎么回事？为什么"我创建了孩子"的信息有时会打印几次？

此外，我注意到在clone调用后添加延迟"修复"了问题。

您有一个竞争条件（即，您没有stdio的隐含线程安全性）。

问题更为严重。您可以获得重复的"func"消息。

问题是使用clone与pthread_create没有相同的保证。（即）您确实而不是获得printf的线程安全变体。

我不确定，但实际上，IMO关于stdio流和线程安全的措辞只适用于使用pthreads的情况。

因此，您必须处理自己的线程间锁定。

这是您的程序的一个版本，已重新编码为使用pthread_create。它似乎在没有事故的情况下工作：

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#define STACK_SIZE 1024*1024
void *func(void* param) {
    printf("I am func, pid %dn", getpid());
    return (void *) 0;
}
int main(int argc, char const *argv[]) {
    printf("I am main, pid %dn", getpid());
    void* ptr = malloc(STACK_SIZE);
    printf("I am calling clonen");
    pthread_t tid;
    pthread_create(&tid,NULL,func,NULL);
    //int res = clone(func, ptr + STACK_SIZE, CLONE_VM, NULL);
    int res = 0;
    // works fine with sleep() call
    // sleep(1);
    if (res == -1) {
        printf("clone error: %d", errno);
    } else {
        printf("I created child with pid: %dn", res);
    }
    pthread_join(tid,NULL);
    printf("Main done, pid %dn", getpid());
    return 0;
}

这是我用来检查错误的测试脚本[有点粗糙，但应该没问题]。根据您的版本运行，它将很快中止。pthread_create版本似乎通过了很好的

#!/usr/bin/perl
# clonetest -- clone test
#
# arguments:
#   "-p0" -- suppress check for duplicate parent messages
#   "-c0" -- suppress check for duplicate child messages
#   1 -- base name for program to test (e.g. for xyz.c, use xyz)
#   2 -- [optional] number of test iterations (DEFAULT: 100000)
master(@ARGV);
exit(0);
# master -- master control
sub master
{
    my(@argv) = @_;
    my($arg,$sym);
    while (1) {
        $arg = $argv[0];
        last unless (defined($arg));
        last unless ($arg =~ s/^-(.)//);
        $sym = $1;
        shift(@argv);
        $arg = 1
            if ($arg eq "");
        $arg += 0;
        ${"opt_$sym"} = $arg;
    }
    $opt_p //= 1;
    $opt_c //= 1;
    printf("clonetest: p=%d c=%dn",$opt_p,$opt_c);
    $xfile = shift(@argv);
    $xfile //= "clone1";
    printf("clonetest: xfile='%s'n",$xfile);
    $itermax = shift(@argv);
    $itermax //= 100000;
    $itermax += 0;
    printf("clonetest: itermax=%dn",$itermax);
    system("cc -o $xfile -O2 $xfile.c -lpthread");
    $code = $? >> 8;
    die("master: compile errorn")
        if ($code);
    $logf = "/tmp/log";
    for ($iter = 1;  $iter <= $itermax;  ++$iter) {
        printf("iter: %dn",$iter)
            if ($opt_v);
        dotest($iter);
    }
}
# dotest -- perform single test
sub dotest
{
    my($iter) = @_;
    my($parcnt,$cldcnt);
    my($xfsrc,$bf);
    system("./$xfile > $logf");
    open($xfsrc,"<$logf") or
        die("dotest: unable to open '$logf' -- $!n");
    while ($bf = <$xfsrc>) {
        chomp($bf);
        if ($opt_p) {
            while ($bf =~ /created/g) {
                ++$parcnt;
            }
        }
        if ($opt_c) {
            while ($bf =~ /func/g) {
                ++$cldcnt;
            }
        }
    }
    close($xfsrc);
    if (($parcnt > 1) or ($cldcnt > 1)) {
        printf("dotest: fail on %d -- parcnt=%d cldcnt=%dn",
            $iter,$parcnt,$cldcnt);
        system("cat $logf");
        exit(1);
    }
}

更新：

您是否能够用克隆重新创建OP问题？

当然。在创建pthreads版本之前，除了测试OP的原始版本外，我还创建了以下版本：

（1）将setlinebuf添加到main 的开头

（2）在clone和__fpurge之前添加fflush作为func 的第一条语句

（3）在return 0 之前的func中添加了fflush

版本（2）消除了重复的父消息，但重复的子消息保持

如果你想亲眼看到这一点，可以从问题、我的版本和测试脚本中下载OP的版本。然后，在OP的版本上运行测试脚本。

我发布了足够多的信息和文件，这样任何人都可以重现这个问题。

注意，由于我的系统和OP之间的差异，我一开始无法在3-4次尝试中重现这个问题。所以，这就是我创作剧本的原因。

该脚本进行了100000次测试，通常问题会在5000-15000次内显现出来。

我无法重新创建OP的问题，但我不认为printf实际上是个问题。

glibc文档：

POSIX标准要求默认情况下流操作原子的即，在两个流中为同一个流发出两个流操作线程同时将导致操作执行为如果它们是按顺序发布的。执行的缓冲区操作而阅读或写作受到保护，不受其其他用途的影响流动为此，每个流都有一个内部锁定对象，该对象具有在完成任何工作之前（隐含地）获得。

编辑：

正如rici所指出的，尽管以上对线程来说是正确的，但对源软件有一个评论：

基本上，除非child将自己限制为纯计算和直接系统调用（通过sys/syscall.h）。如果使用任何标准库父母和孩子互相攻击对方的内在状态。你也有一些问题，比如glibc在用户空间中缓存pid/tid，以及glibc希望始终有一个有效的线程指针您对克隆的调用无法正确初始化，因为它不知道（也不应该知道）螺纹。

显然，如果设置了clone_VM，但没有设置clone_THREAD|clone_SIGHAND，那么glibc就不能与clone一起工作。

您的进程都使用相同的stdout（即C标准库FILE结构），其中包括意外共享的缓冲区。这无疑会引发问题。

假设每个人都建议：这似乎真的是一个问题，在clone()的情况下，我应该怎么说，过程安全？通过printf的锁定版本的粗略草图（使用write(2)），输出如预期。

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#define STACK_SIZE 1024*1024
// VERY rough attempt at a thread-safe printf
#include <stdarg.h>
#define SYNC_REALLOC_GROW 64
int sync_printf(const char *format, ...)
{
  int n, all = 0;
  int size = 256;
  char *p, *np;
  va_list args;
  if ((p = malloc(size)) == NULL)
    return -1;
  for (;;) {
    va_start(args, format);
    n = vsnprintf(p, size, format, args);
    va_end(args);
    if (n < 0)
      return -1;
    all += n;
    if (n < size)
      break;
    size = n + SYNC_REALLOC_GROW;
    if ((np = realloc(p, size)) == NULL) {
      free(p);
      return -1;
    } else {
      p = np;
    }
  }
  // write(2) shoudl be threadsafe, so just in case
  flockfile(stdout);
  n = (int) write(fileno(stdout), p, all);
  fflush(stdout);
  funlockfile(stdout);
  va_end(args);
  free(p);
  return n;
}

int func(void *param)
{
  sync_printf("I am func, pid %dn", getpid());
  return 0;
}
int main()
{
  sync_printf("I am main, pid %dn", getpid());
  void *ptr = malloc(STACK_SIZE);
  sync_printf("I am calling clonen");
  int res = clone(func, ptr + STACK_SIZE, CLONE_VM, NULL);
  // works fine with sleep() call
  // sleep(1);
  if (res == -1) {
    sync_printf("clone error: %d", errno);
  } else {
    sync_printf("I created child with pid: %dn", res);
  }
  sync_printf("Main done, pid %dnn", getpid());
  return 0;
}

第三次：这只是一个草图，没有时间制作一个健壮的版本，但这不应该妨碍你写一个。

正如evaitl所指出的，glibc的文档记录了printf是线程安全的但是，这通常假设您正在使用指定的glibc函数来创建线程（即pthread_create()）。如果你不这样做，那么你就只能靠自己了。

printf()获取的锁是递归的（请参见flockfile）。这意味着，如果锁已经被占用，则实现将对照locker检查锁的所有者。如果锁定器与所有者相同，则锁定尝试成功。

要区分不同的线程，您需要正确设置TLS，但pthread_create()需要这样做。我猜发生的情况是，在您的情况下，标识线程的TLS变量对于两个线程都是相同的，所以您最终获得了锁。

TL；DR：请使用pthread_create()

相关内容

最新更新

热门标签：