0

我在 Unix C 中使用共享内存、信号量和分叉时遇到问题。我的信号量不是 posix。我创建了一个指向共享内存 2*sizeof(float) 的指针。我用 semctl 将信号量的值初始化为 2。我在 for 循环（i<2）中做了一个 fork()。在子进程中（如果 fork() == 0），每个子进程对信号量（-1）执行 ap 操作，写入共享内存然后执行 av 操作（+1）然后退出。父进程对信号量执行 ap 操作（-2），读取整个共享内存段（使用 for 循环）并执行 av 操作（+2）。他在退出之前等待子进程以避免僵尸。我在输出中遇到的问题是我得到：

 Parent reading 0
 Parent reading 1
 Parent reading 0
 Parent reading 1
 Child writing 0
 Child writing 1

当我应该得到的是：

 Child writing 0
 Child writing 1
 Parent reading 0
 Parent reading 1

我已经尝试将我的信号量初始化为 1 而不是 2，但这只会停止程序，因为信号量永远不会有值 2，因此父进程永远不会读取。

如果我对信号量的理解是正确的，那么我将它初始化为 2 的事实意味着即使没有孩子写任何东西，父进程也可以直接读取。我该如何解决这个问题？

编辑：我在请求后添加了我的代码的简化版本，我删除了错误检查，并等待孩子减少长度。

/** OPEN MEMORY **/

int shmid1 = shmget(1990, (size),  IPC_CREAT | 0666 ); 

float * shmPt = (float*)shmat(shmid1, NULL, 0);    

/** CREATE INITIALIZE SEMAPHORE **/   

semun1.val = 2;

int semid = semget(1991, 1, 0666 | IPC_CREAT)

semctl(semid, 0, SETVAL, semun1 )


  /**  CREATE PROCESSES **/
  for ( ii = 0; ii < 2; ++ii) {
    if ((p = fork()) == 0) {

      int semid = semget(1991, 1, 0666);

      struct sembuf p_buf;

      p_buf.sem_num = 0;p_buf.sem_op = -1;p_buf.sem_flg = SEM_UNDO;
      /** LOCK **/ 
      semop(semid, &p_buf,1);
      /** WRITE **/
      shmPt[ii] = RandomFloat;

      v_buf.sem_num = 0;v_buf.sem_op = 1;v_buf.sem_flg = SEM_UNDO;
      /** UNLOCK **/
      semop(semid, &v_buf,1) 

      exit(0);
    }
    else {

      int semid = semget(1991, 1, 0666);

      struct sembuf p_buf;

      p_buf.sem_num = 0;p_buf.sem_op = -2;p_buf.sem_flg = SEM_UNDO;
      /** LOCK **/ 
      semop(semid, &p_buf,1);
      /** READ **/
      for(int j =0;j<2;j++) tabFloat[j] = shmPt[j];

      v_buf.sem_num = 0;v_buf.sem_op = 2;v_buf.sem_flg = SEM_UNDO;
      /** UNLOCK **/
      semop(semid, &v_buf,1) 

    }
}

编辑：我的最终目标是让 24 个孩子一个接一个地写入相同大小的共享内存段，并且只有当它已满时，父母才能读取所有内容并处理信息。最重要的是，所有这些都需要在一个 while 循环中进行（想象一下 24 辆汽车在每次完成一圈时不断生成随机时间，直到第一辆汽车完成 50 圈）

4

1 回答 1

4

你误用了信号量。一般的想法是，信号量计算“现在允许有多少实体（线程，等等）使用这些数据”。通过从 2 开始计数，您是在说“两个线程现在可以使用它”。信号量没有说明哪些实体，也没有说明如何（读取与写入），只有多少. 例如，信号量可用于计算生产者/消费者队列中可检索项目的数量：生产者递增，消费者递减。（当然，信号量有各种扩展的风格；既然你说这些不是 POSIX，但不是它们是什么，很难概括更多。）

使这项工作如所描述的一种方法（但当然，实际代码往往与描述不同）是从 0 开始信号量计数，派生一个孩子，让孩子在不查看信号量计数的情况下编写，派生另一个孩子，拥有那个孩子也在不看信号量的情况下写，然后让父母在信号量（P）上等待。也就是说，信号量说“没有人会通过”，但孩子们实际上并没有看它。然后，两个孩子各自做 V 操作（每个 +1）。一旦信号量变为 1，父母就开始：然后他可以找到至少一个（但也许只有一个）子结果。如果父母需要两个结果，他可以立即做另一个 P。

（更一般地说，您可能需要读/写锁或互斥锁和条件变量。如果您有 POSIX 线程，请参阅pthread_cond_init()、pthread_cond_wait()、pthread_cond_signal()、pthread_mutex_init()等）

啊哈，从评论和问题编辑中，我看到您正在使用可恶的 System V 共享内存和信号量接口。

  • 你真的坚持吗？在我看来，POSIX 线程的东西更好（而且通常更轻）。
  • 你打算如何组织你的共享内存？如果每辆车都有自己的单圈时间区域，仅与显示线程/proc 共享，您可能会减少锁争用：有一个生产者（汽车）和一个消费者（显示线程/proc），但有 24 个这样的锁（每辆车一个）。如果所有汽车与显示线程/proc 共享一个共享内存区域，则您只需要一个锁，但它更活跃。哪个“更好”取决于您在做什么。
  • 而且，如果您想等待“某辆车跑完 50 圈”，请考虑让每辆车都有自己的私人（或可能与显示器共享）计数器，以及一个用于“跑完 50 圈的汽车数量”的计数信号量”。每辆汽车简单地计数，达到 50 时，计数信号量也增加（一次）。

Final (I hope) edit: after fixing smaller problems, the last remaining one was the use of SEM_UNDO in each child process, which would do a V (of +1) to signal "data produced and all done" and then exit. SEM_UNDO records a balancing adjustment value that is applied on process exit, so the semaphore would count up, but then immediately count right back down, leaving the parent waiting for another V that would never occur.

于 2013-05-26T18:44:24.393 回答