示例: 使用信号量集和共享内存函数
此示例说明了支持客户机/服务器模型的程序。
注: 通过使用代码示例，您同意 代码许可证和免责声明信息的条款。
服务器程序
此程序充当客户机程序的服务器 (请参阅 客户机程序)。 缓冲区是共享内存段。 进程同步是使用 semaphores 完成的。
使用 "创建 C 模块" (CRTCMOD) 和 "创建程序" (CRTPGM) 命令来创建此程序。
在调用客户机程序之前，不带任何参数调用此程序。
/*********************************************************************/
/*********************************************************************/
/* */
/* FUNCTION: This program acts as a server to the client program. */
/* */
/* LANGUAGE: ILE C */
/* */
/* APIs USED: semctl(), semget(), semop(), */
/* shmat(), shmctl(), shmdt(), shmget() */
/* ftok() */
/* */
/*********************************************************************/
/*********************************************************************/
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#define SEMKEYPATH "/dev/null" /* Path used on ftok for semget key */
#define SEMKEYID 1 /* Id used on ftok for semget key */
#define SHMKEYPATH "/dev/null" /* Path used on ftok for shmget key */
#define SHMKEYID 1 /* Id used on ftok for shmget key */
#define NUMSEMS 2 /* Num of sems in created sem set */
#define SIZEOFSHMSEG 50 /* Size of the shared mem segment */
#define NUMMSG 2 /* Server only doing two "receives"
on shm segment */
int main(int argc, char *argv[])
{
int rc, semid, shmid, i;
key_t semkey, shmkey;
void *shm_address;
struct sembuf operations[2];
struct shmid_ds shmid_struct;
short sarray[NUMSEMS];
/* Generate an IPC key for the semaphore set and the shared */
/* memory segment. Typically, an application specific path and */
/* id would be used to generate the IPC key. */
semkey = ftok(SEMKEYPATH,SEMKEYID);
if ( semkey == (key_t)-1 )
{
printf("main: ftok() for sem failed\n");
return -1;
}
shmkey = ftok(SHMKEYPATH,SHMKEYID);
if ( shmkey == (key_t)-1 )
{
printf("main: ftok() for shm failed\n");
return -1;
}
/* Create a semaphore set using the IPC key. The number of */
/* semaphores in the set is two. If a semaphore set already */
/* exists for the key, return an error. The specified permissions*/
/* give everyone read/write access to the semaphore set. */
semid = semget( semkey, NUMSEMS, 0666 | IPC_CREAT | IPC_EXCL );
if ( semid == -1 )
{
printf("main: semget() failed\n");
return -1;
}
/* Initialize the first semaphore in the set to 0 and the */
/* second semaphore in the set to 0. */
/* */
/* The first semaphore in the sem set means: */
/* '1' -- The shared memory segment is being used. */
/* '0' -- The shared memory segment is freed. */
/* The second semaphore in the sem set means: */
/* '1' -- The shared memory segment has been changed by */
/* the client. */
/* '0' -- The shared memory segment has not been */
/* changed by the client. */
sarray[0] = 0;
sarray[1] = 0;
/* The '1' on this command is a no-op, because the SETALL command*/
/* is used. */
rc = semctl( semid, 1, SETALL, sarray);
if(rc == -1)
{
printf("main: semctl() initialization failed\n");
return -1;
}
/* Create a shared memory segment using the IPC key. The */
/* size of the segment is a constant. The specified permissions */
/* give everyone read/write access to the shared memory segment. */
/* If a shared memory segment already exists for this key, */
/* return an error. */
shmid = shmget(shmkey, SIZEOFSHMSEG, 0666 | IPC_CREAT | IPC_EXCL);
if (shmid == -1)
{
printf("main: shmget() failed\n");
return -1;
}
/* Attach the shared memory segment to the server process. */
shm_address = shmat(shmid, NULL, 0);
if ( shm_address==NULL )
{
printf("main: shmat() failed\n");
return -1;
}
printf("Ready for client jobs\n");
/* Loop only a specified number of times for this example. */
for (i=0; i < NUMMSG; i++)
{
/* Set the structure passed into the semop() to first wait */
/* for the second semval to equal 1, then decrement it to */
/* allow the next signal that the client writes to it. */
/* Next, set the first semaphore to equal 1, which means */
/* that the shared memory segment is busy. */
operations[0].sem_num = 1;
/* Operate on the second sem */
operations[0].sem_op = -1;
/* Decrement the semval by one */
operations[0].sem_flg = 0;
/* Allow a wait to occur */
operations[1].sem_num = 0;
/* Operate on the first sem */
operations[1].sem_op = 1;
/* Increment the semval by 1 */
operations[1].sem_flg = IPC_NOWAIT;
/* Do not allow to wait */
rc = semop( semid, operations, 2 );
if (rc == -1)
{
printf("main: semop() failed\n");
return -1;
}
/* Print the shared memory contents. */
printf("Server Received : \"%s\"\n", (char *) shm_address);
/* Signal the first semaphore to free the shared memory. */
operations[0].sem_num = 0;
operations[0].sem_op = -1;
operations[0].sem_flg = IPC_NOWAIT;
rc = semop( semid, operations, 1 );
if (rc == -1)
{
printf("main: semop() failed\n");
return -1;
}
} /* End of FOR LOOP */
/* Clean up the environment by removing the semid structure, */
/* detaching the shared memory segment, and then performing */
/* the delete on the shared memory segment ID. */
rc = semctl( semid, 1, IPC_RMID );
if (rc==-1)
{
printf("main: semctl() remove id failed\n");
return -1;
}
rc = shmdt(shm_address);
if (rc==-1)
{
printf("main: shmdt() failed\n");
return -1;
}
rc = shmctl(shmid, IPC_RMID, &shmid_struct);
if (rc==-1)
{
printf("main: shmctl() failed\n");
return -1;
}
return 0;
}
客户机程序
此程序充当服务器程序的客户机 (请参阅 服务器程序)。 程序在消息之后运行Ready for client jobs从服务器程序中显示。
使用 CRTCMOD 和 CRTPGM 命令来创建此程序。
调用服务器程序后调用此程序时不带任何参数。
/*********************************************************************/
/*********************************************************************/
/* */
/* FUNCTION: This program acts as a client to the server program. */
/* */
/* LANGUAGE: ILE C */
/* */
/* APIs USED: semget(), semop(), */
/* shmget(), shmat(), shmdt() */
/* ftok() */
/* */
/*********************************************************************/
/*********************************************************************/
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#define SEMKEYPATH "/dev/null" /* Path used on ftok for semget key */
#define SEMKEYID 1 /* Id used on ftok for semget key */
#define SHMKEYPATH "/dev/null" /* Path used on ftok for shmget key */
#define SHMKEYID 1 /* Id used on ftok for shmget key */
#define NUMSEMS 2
#define SIZEOFSHMSEG 50
int main(int argc, char *argv[])
{
struct sembuf operations[2];
void *shm_address;
int semid, shmid, rc;
key_t semkey, shmkey;
/* Generate an IPC key for the semaphore set and the shared */
/* memory segment. Typically, an application specific path and */
/* id would be used to generate the IPC key. */
semkey = ftok(SEMKEYPATH,SEMKEYID);
if ( semkey == (key_t)-1 )
{
printf("main: ftok() for sem failed\n");
return -1;
}
shmkey = ftok(SHMKEYPATH,SHMKEYID);
if ( shmkey == (key_t)-1 )
{
printf("main: ftok() for shm failed\n");
return -1;
}
/* Get the already created semaphore ID associated with key. */
/* If the semaphore set does not exist, then it will not be */
/* created, and an error will occur. */
semid = semget( semkey, NUMSEMS, 0666);
if ( semid == -1 )
{
printf("main: semget() failed\n");
return -1;
}
/* Get the already created shared memory ID associated with key. */
/* If the shared memory ID does not exist, then it will not be */
/* created, and an error will occur. */
shmid = shmget(shmkey, SIZEOFSHMSEG, 0666);
if (shmid == -1)
{
printf("main: shmget() failed\n");
return -1;
}
/* Attach the shared memory segment to the client process. */
shm_address = shmat(shmid, NULL, 0);
if ( shm_address==NULL )
{
printf("main: shmat() failed\n");
return -1;
}
/* First, check to see if the first semaphore is a zero. If it */
/* is not, it is busy right now. The semop() command will wait */
/* for the semaphore to reach zero before running the semop(). */
/* When it is zero, increment the first semaphore to show that */
/* the shared memory segment is busy. */
operations[0].sem_num = 0;
/* Operate on the first sem */
operations[0].sem_op = 0;
/* Wait for the value to be=0 */
operations[0].sem_flg = 0;
/* Allow a wait to occur */
operations[1].sem_num = 0;
/* Operate on the first sem */
operations[1].sem_op = 1;
/* Increment the semval by one */
operations[1].sem_flg = 0;
/* Allow a wait to occur */
rc = semop( semid, operations, 2 );
if (rc == -1)
{
printf("main: semop() failed\n");
return -1;
}
strcpy((char *) shm_address, "Hello from Client");
/* Release the shared memory segment by decrementing the in-use */
/* semaphore (the first one). Increment the second semaphore to */
/* show that the client is finished with it. */
operations[0].sem_num = 0;
/* Operate on the first sem */
operations[0].sem_op = -1;
/* Decrement the semval by one */
operations[0].sem_flg = 0;
/* Allow a wait to occur */
operations[1].sem_num = 1;
/* Operate on the second sem */
operations[1].sem_op = 1;
/* Increment the semval by one */
operations[1].sem_flg = 0;
/* Allow a wait to occur */
rc = semop( semid, operations, 2 );
if (rc == -1)
{
printf("main: semop() failed\n");
return -1;
}
/* Detach the shared memory segment from the current process. */
rc = shmdt(shm_address);
if (rc==-1)
{
printf("main: shmdt() failed\n");
return -1;
}
return 0;
}