我想到的第一个问题是,为什么我们需要信号(Semaphores)?一个简单的答案,就是保护多个进程之间共享公共区域。

让我们假设,多个进程正在使用相同的代码区域,并且如果所有进程都希望并行访问,那么输出是重叠的,因此,我们需要使用信号量来保护它,即在一个进程运行时锁定关键部分,并在完成时解锁。将对每个用户/进程重复此操作,以使一个作业不与另一作业重叠。

基本上,信号量分为两种类型  -

二进制信号量(Binary Semaphores)  -  互斥量实现只有0和1这两个状态,即锁定/解锁或可用/不可用。

计数信号量(Counting Semaphores)  -  允许任意资源计数的信号量称为计数信号量。

要使用信号量执行同步,请按照以下步骤操作:

步骤1  -  创建一个信号量或连接到一个已经存在的信号量(semget())

步骤2  -  对信号量执行操作,即分配或释放或等待资源(semop())

步骤3  -  对消息队列执行控制操作(semctl())

现在,让我们用我们拥有的系统调用来检查这一点。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg)

该系统调用创建或分配系统V信号量集。需要传递以下参数-

  • 第一个参数key      -  识别消息队列,键可以是任意值,也可以是从库函数ftok()派生的值。

  • 第二个参数nsems  -  指定信号量的数量,如果为二进制,则为1,表示需要1个信号集,否则按所需的信号集数量计数。

  • 第三个参数semflg  -  指定所需的信号量标志,如IPC_CREAT(如果不存在则创建信号量)或IPC_EXCL(与IPC_CREAT一起使用来创建信号量,如果信号量已经存在,则调用失败) 。还需要传递权限。

注意-有关权限的详细信息,请参阅前面的部分。

此调用将在成功时返回有效的信号量标识符,在失败的情况下返回-1。要知道失败的原因,请使用errno变量或perror()函数进行检查。

关于此调用的各种错误包括EACCESS(拒绝权限),EEXIST(无法创建已经存在的队列),ENOENT(队列不存在),ENOMEM(没有足够的内存来创建队列),ENOSPC(超过最大设置限制),等等。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semop(int semid, struct sembuf *semops, size_t nsemops)

该系统调用对System V信号量集执行操作,即分配资源,等待资源或释放资源。以下参数需要传递-

  • 第一个参数Semid   -  表示由semget()创建的信号量集标识符。

  • 第二个参数semops -  是指向要在信号量集上执行的操作的数组的指针。结构如下-

struct sembuf {
   unsigned short sem_num; /* Semaphore set num */
   short sem_op; /* Semaphore operation */
   short sem_flg; /* Operation flags, IPC_NOWAIT, SEM_UNDO */
};

在上述结构中,元素sem_op指示需要执行的操作-

  • 如果sem_op为-ve ,请分配或获取资源,阻塞调用进程,直到其他进程释放了足够的资源,以便该进程可以分配。

  • 如果sem_op为0    ,则调用进程将等待或休眠,直到信号量值达到0。

  • 如果sem_op为+ve,请释放资源。

如-

struct sembuf sem_lock={0,-1,SEM_UNDO};

struct sembuf sem_unlock={0,1,SEM_UNDO};

  • 第三个参数nsemops是该数组中的操作数。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, …)

该系统调用对System V信号量执行控制操作。需要传递以下参数-

  • 第一个参数Semid     -  是信号量的标识符,此id是信号量标识符,它是semget()系统调用的返回值。

  • 第二个参数semnum -  是信号量的数量,信号量从0开始编号。

  • 第三个参数cmd        -  是用于对信号量执行所需控制操作的命令。

  • 第四个参数union semun,取决于cmd。在少数情况下,第四个参数不适用。

让我们检查一下工会-

union semun {
   int val; /* val for SETVAL */
   struct semid_ds *buf; /* Buffer for IPC_STAT and IPC_SET */
   unsigned short *array; /* Buffer for GETALL and SETALL */
   struct seminfo *__buf; /* Buffer for IPC_INFO and SEM_INFO*/
};

在sys/sem.h中定义的semid_ds数据结构如下-

struct semid_ds {
   struct ipc_perm sem_perm; /* Permissions */
   time_t sem_otime; /* Last semop time */
   time_t sem_ctime; /* Last change time */
   unsigned long sem_nsems; /* Number of semaphores in the set */
};

有效cmd值为-

链接:https://www.learnfk.com/article-inter_process_communication/inter_process_communication_semaphores

来源:LearnFk无涯教程网

  • IPC_STAT       -  将struct semid_ds每个成员的当前值信息复制到arg.buf指向的传递结构,此命令需要对信号量具有读取权限。

  • IPC_SET         -  设置结构Semid_ds指向的用户ID,所有者的组ID,权限等。

  • IPC_RMID      -  删除信号量集。

  • IPC_INFO      -  返回有关arg .__ buf指向的Semid_ds结构中的信号量限制和参数的信息。

  • SEM_INFO    -  返回seminfo结构,其中包含有关信号量消耗的系统资源的信息。

此调用将返回值(非负值),具体取决于传递的命令。成功后,IPC_INFO和SEM_INFO或SEM_STAT根据信号量或GETNCNT的semncnt值或GETPID的sempid值或GETVAL 0的semval值返回每个成功使用的其他项的索引或标识符,如果成功,则返回0,如果发生故障则为1。要知道失败的原因,请使用errno变量或perror()函数进行检查。

在查看代码之前,让我们了解其实现-

  • 创建两个进程,即子进程和父进程。

  • 创建共享内存,主要用于存储计数器和其他标志以指示对共享内存的读/写进程已结束。

  • 父进程和子进程都将计数器增加计数,该计数要么作为命令行参数传递,要么作为默认值。以一定的睡眠时间进行调用,以确保父进程和子进程同时(即并行)访问共享内存。

  • 由于父进程和子进程都将计数器以1为增量递增,因此最终值应为计数器的两倍,由于父进程和子进程都同时执行操作,因此计数器不会按要求递增。因此,我们需要确保一个进程完成之后另一个进程完成。

  • 上述所有实现均在文件shm_write_cntr.c中执行

  • 检查计数器值在文件shm_read_cntr.c中实现

  • 为确保完成,信号量程序在文件shm_write_cntr_with_sem.c中实现,整个进程完成后(从其他程序读取完成后)删除信号量

  • 因为我们有单独的文件来读取共享内存中的counter值,并且对写入没有任何影响,所以读取程序保持不变(shm_read_cntr.c)

  • 始终最好在一个终端中执行写入程序并从另一个终端中读取程序,由于该程序仅在读写进程完成后才完成执行,因此可以在完全执行写入程序后运行该程序。写入程序将等到读取程序运行后再执行,直到完成。

没有信号量的程序。

/* Filename: shm_write_cntr.c */
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

#define SHM_KEY 0x12345
struct shmseg {
   int cntr;
   int write_complete;
   int read_complete;
};
void shared_memory_cntr_increment(int pid, struct shmseg *shmp, int total_count);

int main(int argc, char *argv[]) {
   int shmid;
   struct shmseg *shmp;
   char *bufptr;
   int total_count;
   int sleep_time;
   pid_t pid;
   if (argc != 2)
   total_count = 10000;
   else {
      total_count = atoi(argv[1]);
      if (total_count < 10000)
      total_count = 10000;
   }
   printf("Total Count is %d\n", total_count);
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);

   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }

   //Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   if (shmp == (void *) -1) {
      perror("Shared memory attach");
      return 1;
   }
   shmp->cntr = 0;
   pid = fork();

   /* Parent Process - Writing Once */
   if (pid > 0) {
      shared_memory_cntr_increment(pid, shmp, total_count);
   } else if (pid == 0) {
      shared_memory_cntr_increment(pid, shmp, total_count);
      return 0;
   } else {
      perror("Fork Failure\n");
      return 1;
   }
   while (shmp->read_complete != 1)
   sleep(1);

   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }

   if (shmctl(shmid, IPC_RMID, 0) == -1) {
      perror("shmctl");
      return 1;
   }
   printf("Writing Process: Complete\n");
   return 0;
}

/* Increment the counter of shared memory by total_count in steps of 1 */
void shared_memory_cntr_increment(int pid, struct shmseg *shmp, int total_count) {
   int cntr;
   int numtimes;
   int sleep_time;
   cntr = shmp->cntr;
   shmp->write_complete = 0;
   if (pid == 0)
   printf("SHM_WRITE: CHILD: Now writing\n");
   else if (pid > 0)
   printf("SHM_WRITE: PARENT: Now writing\n");
   //printf("SHM_CNTR is %d\n", shmp->cntr);
   
   /* Increment the counter in shared memory by total_count in steps of 1 */
   for (numtimes = 0; numtimes < total_count; numtimes++) {
      cntr += 1;
      shmp->cntr = cntr;
      
      /* Sleeping for a second for every thousand */
      sleep_time = cntr % 1000;
      if (sleep_time == 0)
      sleep(1);
   }
   
   shmp->write_complete = 1;
   if (pid == 0)
   printf("SHM_WRITE: CHILD: Writing Done\n");
   else if (pid > 0)
   printf("SHM_WRITE: PARENT: Writing Done\n");
   return;
}

编译和执行步骤

Total Count is 10000
SHM_WRITE: PARENT: Now writing
SHM_WRITE: CHILD: Now writing
SHM_WRITE: PARENT: Writing Done
SHM_WRITE: CHILD: Writing Done
Writing Process: Complete

现在,让我们检查共享内存读取程序。

/* Filename: shm_read_cntr.c */
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>

#define SHM_KEY 0x12345
struct shmseg {
   int cntr;
   int write_complete;
   int read_complete;
};

int main(int argc, char *argv[]) {
   int shmid, numtimes;
   struct shmseg *shmp;
   int total_count;
   int cntr;
   int sleep_time;
   if (argc != 2)
   total_count = 10000;
   
   else {
      total_count = atoi(argv[1]);
      if (total_count < 10000)
      total_count = 10000;
   }
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
   
   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }
   //Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   
   if (shmp == (void *) -1) {
      perror("Shared memory attach");
      return 1;
   }
   
   /* Read the shared memory cntr and print it on standard output */
   while (shmp->write_complete != 1) {
      if (shmp->cntr == -1) {
         perror("read");
         return 1;
      }
      sleep(3);
   }
   printf("Reading Process: Shared Memory: Counter is %d\n", shmp->cntr);
   printf("Reading Process: Reading Done, Detaching Shared Memory\n");
   shmp->read_complete = 1;
   
   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }
   printf("Reading Process: Complete\n");
   return 0;
}

编译和执行步骤

Reading Process: Shared Memory: Counter is 11000
Reading Process: Reading Done, Detaching Shared Memory
Reading Process: Complete

如果您观察到以上输出,则计数器应为20000,但是,由于在完成一个进程任务之前,另一个进程也正在并行处理,因此计数器值与预期不符。输出会因系统而异,并且每次执行时都会不同。为确保两个进程在完成一项任务后执行任务,应使用同步机制来实现它。

现在,让我们使用信号量检查同一应用程序。

/* Filename: shm_write_cntr_with_sem.c */
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

#define SHM_KEY 0x12345
#define SEM_KEY 0x54321
#define MAX_TRIES 20

struct shmseg {
   int cntr;
   int write_complete;
   int read_complete;
};
void shared_memory_cntr_increment(int, struct shmseg*, int);
void remove_semaphore();

int main(int argc, char *argv[]) {
   int shmid;
   struct shmseg *shmp;
   char *bufptr;
   int total_count;
   int sleep_time;
   pid_t pid;
   if (argc != 2)
   total_count = 10000;
   else {
      total_count = atoi(argv[1]);
      if (total_count < 10000)
      total_count = 10000;
   }
   printf("Total Count is %d\n", total_count);
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
   
   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }
   //Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   
   if (shmp == (void *) -1) {
      perror("Shared memory attach: ");
      return 1;
   }
   shmp->cntr = 0;
   pid = fork();
   
   /* Parent Process - Writing Once */
   if (pid > 0) {
      shared_memory_cntr_increment(pid, shmp, total_count);
   } else if (pid == 0) {
      shared_memory_cntr_increment(pid, shmp, total_count);
      return 0;
   } else {
      perror("Fork Failure\n");
      return 1;
   }
   while (shmp->read_complete != 1)
   sleep(1);
   
   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }
   
   if (shmctl(shmid, IPC_RMID, 0) == -1) {
      perror("shmctl");
      return 1;
   }
   printf("Writing Process: Complete\n");
   remove_semaphore();
   return 0;
}

/* Increment the counter of shared memory by total_count in steps of 1 */
void shared_memory_cntr_increment(int pid, struct shmseg *shmp, int total_count) {
   int cntr;
   int numtimes;
   int sleep_time;
   int semid;
   struct sembuf sem_buf;
   struct semid_ds buf;
   int tries;
   int retval;
   semid = semget(SEM_KEY, 1, IPC_CREAT | IPC_EXCL | 0666);
   //printf("errno is %d and semid is %d\n", errno, semid);
   
   /* Got the semaphore */
   if (semid >= 0) {
      printf("First Process\n");
      sem_buf.sem_op = 1;
      sem_buf.sem_flg = 0;
      sem_buf.sem_num = 0;
      retval = semop(semid, &sem_buf, 1);
      if (retval == -1) {
         perror("Semaphore Operation: ");
         return;
      }
   } else if (errno == EEXIST) { //Already other process got it
      int ready = 0;
      printf("Second Process\n");
      semid = semget(SEM_KEY, 1, 0);
      if (semid < 0) {
         perror("Semaphore GET: ");
         return;
      }
      
      /* Waiting for the resource */
      sem_buf.sem_num = 0;
      sem_buf.sem_op = 0;
      sem_buf.sem_flg = SEM_UNDO;
      retval = semop(semid, &sem_buf, 1);
      if (retval == -1) {
         perror("Semaphore Locked: ");
         return;
      }
   }
   sem_buf.sem_num = 0;
   sem_buf.sem_op = -1; /* Allocating the resources */
   sem_buf.sem_flg = SEM_UNDO;
   retval = semop(semid, &sem_buf, 1);
   
   if (retval == -1) {
      perror("Semaphore Locked: ");
      return;
   }
   cntr = shmp->cntr;
   shmp->write_complete = 0;
   if (pid == 0)
   printf("SHM_WRITE: CHILD: Now writing\n");
   else if (pid > 0)
   printf("SHM_WRITE: PARENT: Now writing\n");
   //printf("SHM_CNTR is %d\n", shmp->cntr);
   
   /* Increment the counter in shared memory by total_count in steps of 1 */
   for (numtimes = 0; numtimes < total_count; numtimes++) {
      cntr += 1;
      shmp->cntr = cntr;
      /* Sleeping for a second for every thousand */
      sleep_time = cntr % 1000;
      if (sleep_time == 0)
      sleep(1);
   }
   shmp->write_complete = 1;
   sem_buf.sem_op = 1; /* Releasing the resource */
   retval = semop(semid, &sem_buf, 1);
   
   if (retval == -1) {
      perror("Semaphore Locked\n");
      return;
   }
   
   if (pid == 0)
      printf("SHM_WRITE: CHILD: Writing Done\n");
      else if (pid > 0)
      printf("SHM_WRITE: PARENT: Writing Done\n");
      return;
}
   
void remove_semaphore() {
   int semid;
   int retval;
   semid = semget(SEM_KEY, 1, 0);
      if (semid < 0) {
         perror("Remove Semaphore: Semaphore GET: ");
         return;
      }
   retval = semctl(semid, 0, IPC_RMID);
   if (retval == -1) {
      perror("Remove Semaphore: Semaphore CTL: ");
      return;
   }
   return;
}

编译和执行步骤

Total Count is 10000
First Process
SHM_WRITE: PARENT: Now writing
Second Process
SHM_WRITE: PARENT: Writing Done
SHM_WRITE: CHILD: Now writing
SHM_WRITE: CHILD: Writing Done
Writing Process: Complete

现在,我们将通过读取进程检查计数器值。

执行步骤

Reading Process: Shared Memory: Counter is 20000
Reading Process: Reading Done, Detaching Shared Memory
Reading Process: Complete

这一章你学到了什么?来做个笔记,好记忆不如烂笔头! 如果觉得对您有帮助,麻烦帮分享给您的朋友。

祝学习愉快! (如果觉得不正确,选中要修改的内容->右键->编辑)

点我分享笔记