我想分叉多个进程，然后在它们上使用信号量。以下是我尝试过的：
sem_init(&sem, 1, 1); /* semaphore*, pshared, value */
.
.
.
if(pid != 0){ /* parent process */
wait(NULL); /* wait all child processes */
printf("nParent: All children have exited.n");
.
.
/* cleanup semaphores */
sem_destroy(&sem);
exit(0);
}
else{ /* child process */
sem_wait(&sem); /* P operation */
printf(" Child(%d) is in critical section.n",i);
sleep(1);
*p += i%3; /* increment *p by 0, 1 or 2 based on i */
printf(" Child(%d) new value of *p=%d.n",i,*p);
sem_post(&sem); /* V operation */
exit(0);
}
输出为：
child(0(分叉分叉的孩子子项(0(处于关键部分。儿童(1(处于危急状态。分叉的儿童孩子(2(处于危急状态。分叉的小孩孩子(3(处于危急状态。分叉的小孩孩子(4(处于危急状态。*p=0的子(0(新值。Child(1(*p=1的新值。Child(2(*p=3的新值。Child(3(*p=3的新值。Child(4(*p=4的新值。家长：所有孩子都已退出
这显然意味着信号量没有按预期工作。你能解释一下我应该如何在分叉进程上使用信号量吗？
您面临的问题是对sem_init()函数的误解。当您阅读手册页面时你会看到这个：
pshared参数指示是否要共享此信号量进程的线程之间或进程之间。
如果您已经阅读完这一点，您会认为pshared的非零值将使信号量成为进程间信号量。然而，这是错误的。您应该继续阅读，您就会明白必须在共享内存区域中定位信号量。为此，可以使用以下几个函数你可以看到以下内容：
如果pshared为非零，则信号量在进程之间共享，并且应该位于共享存储器的区域中(参见shm_open(3(，mmap(2(和shmget(2((。(由于fork(2(创建的子级继承它的父级的内存映射，它也可以访问信号量。(任何可以访问共享内存区域的进程可以在使用sem_post(3(、sem_wait(3(等的信号量
我发现这种方法比其他方法更复杂，因此我想鼓励人们使用sem_open()而不是sem_init()。
下面你可以看到一个完整的程序说明如下：
- 如何在分叉之间分配共享内存和使用共享变量过程
- 如何在共享内存区域中初始化信号量并使用通过多个过程
- 如何分叉多个进程并使父进程等待其子代退出
#include <stdio.h> /* printf() */
#include <stdlib.h> /* exit(), malloc(), free() */
#include <sys/types.h> /* key_t, sem_t, pid_t */
#include <sys/shm.h> /* shmat(), IPC_RMID */
#include <errno.h> /* errno, ECHILD */
#include <semaphore.h> /* sem_open(), sem_destroy(), sem_wait().. */
#include <fcntl.h> /* O_CREAT, O_EXEC */
int main (int argc, char **argv){
int i; /* loop variables */
key_t shmkey; /* shared memory key */
int shmid; /* shared memory id */
sem_t *sem; /* synch semaphore *//*shared */
pid_t pid; /* fork pid */
int *p; /* shared variable *//*shared */
unsigned int n; /* fork count */
unsigned int value; /* semaphore value */
/* initialize a shared variable in shared memory */
shmkey = ftok ("/dev/null", 5); /* valid directory name and a number */
printf ("shmkey for p = %dn", shmkey);
shmid = shmget (shmkey, sizeof (int), 0644 | IPC_CREAT);
if (shmid < 0){ /* shared memory error check */
perror ("shmgetn");
exit (1);
}
p = (int *) shmat (shmid, NULL, 0); /* attach p to shared memory */
*p = 0;
printf ("p=%d is allocated in shared memory.nn", *p);
/********************************************************/
printf ("How many children do you want to fork?n");
printf ("Fork count: ");
scanf ("%u", &n);
printf ("What do you want the semaphore value to be?n");
printf ("Semaphore value: ");
scanf ("%u", &value);
/* initialize semaphores for shared processes */
sem = sem_open ("pSem", O_CREAT | O_EXCL, 0644, value);
/* name of semaphore is "pSem", semaphore is reached using this name */
printf ("semaphores initialized.nn");
/* fork child processes */
for (i = 0; i < n; i++){
pid = fork ();
if (pid < 0) {
/* check for error */
sem_unlink ("pSem");
sem_close(sem);
/* unlink prevents the semaphore existing forever */
/* if a crash occurs during the execution */
printf ("Fork error.n");
}
else if (pid == 0)
break; /* child processes */
}
/******************************************************/
/****************** PARENT PROCESS ****************/
/******************************************************/
if (pid != 0){
/* wait for all children to exit */
while (pid = waitpid (-1, NULL, 0)){
if (errno == ECHILD)
break;
}
printf ("nParent: All children have exited.n");
/* shared memory detach */
shmdt (p);
shmctl (shmid, IPC_RMID, 0);
/* cleanup semaphores */
sem_unlink ("pSem");
sem_close(sem);
/* unlink prevents the semaphore existing forever */
/* if a crash occurs during the execution */
exit (0);
}
/******************************************************/
/****************** CHILD PROCESS *****************/
/******************************************************/
else{
sem_wait (sem); /* P operation */
printf (" Child(%d) is in critical section.n", i);
sleep (1);
*p += i % 3; /* increment *p by 0, 1 or 2 based on i */
printf (" Child(%d) new value of *p=%d.n", i, *p);
sem_post (sem); /* V operation */
exit (0);
}
}
输出
./a.out
shmkey for p = 84214791
p=0 is allocated in shared memory.
How many children do you want to fork?
Fork count: 6
What do you want the semaphore value to be?
Semaphore value: 2
semaphores initialized.
Child(0) is in critical section.
Child(1) is in critical section.
Child(0) new value of *p=0.
Child(1) new value of *p=1.
Child(2) is in critical section.
Child(3) is in critical section.
Child(2) new value of *p=3.
Child(3) new value of *p=3.
Child(4) is in critical section.
Child(5) is in critical section.
Child(4) new value of *p=4.
Child(5) new value of *p=6.
Parent: All children have exited.
检查shmkey也不错，因为当ftok()失败时，它会返回-1。但是，如果您有多个共享变量，并且如果ftok()函数多次失败，则具有值为-1的shmkey的共享变量将位于同一个共享存储器的区域，导致一个区域的变化影响另一个区域。因此，程序执行会变得一团糟。为了避免这种情况，最好检查ftok()return-1与否(最好签入源代码，而不是像我那样打印到屏幕上，尽管我想在发生冲突时向您显示键值(。
请注意信号量是如何声明和初始化的。这与你在问题中所做的不同(sem_t sem与sem_t* sem(。此外，您应该在本例中使用它们。不能定义sem_t*并在sem_init()中使用它。
Linux最小匿名sem_init+mmap MAP_ANONYMOUS示例
我喜欢这个设置，因为它不会像sem_open那样污染任何全局命名空间。
唯一的缺点是MAP_ANONYMOUS不是POSIX，我不知道有什么替代品：匿名共享内存？例如，CCD_ 19采用与CCD_ 20一样的全局标识符。
main.c:
#define _GNU_SOURCE
#include <assert.h>
#include <semaphore.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main(int argc, char **argv) {
pid_t pid;
typedef struct {
sem_t sem;
int i;
} Semint;
Semint *semint;
size_t size = sizeof(Semint);
semint = (Semint *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, 0, 0);
assert(semint != MAP_FAILED);
/* 1: shared across processes
* 0: initial value, wait locked until one post happens (making it > 0)
*/
sem_init(&semint->sem, 1, 0);
semint->i = 0;
pid = fork();
assert(pid != -1);
if (pid == 0) {
sleep(1);
semint->i = 1;
msync(&semint->sem, size, MS_SYNC);
sem_post(&semint->sem);
exit(EXIT_SUCCESS);
}
if (argc == 1) {
sem_wait(&semint->sem);
}
/* Was modified on the other process. */
assert(semint->i == 1);
wait(NULL);
sem_destroy(&semint->sem);
assert(munmap(semint, size) != -1);
return EXIT_SUCCESS;
}
编译：
gcc -g -std=c99 -Wall -Wextra -o main main.c -lpthread
使用sem_wait:运行
./main
在没有sem_wait:的情况下运行
./main 1
如果没有这种同步，assert很可能会失败，因为孩子会睡整整一秒钟：
main: main.c:39: main: Assertion `semint->i == 1' failed.
在Ubuntu 18.04上测试。GitHub上游。