blp 4th edition-Chapter 14:Semaphores,Shared Memory,and Message Queues.

Semaphore: for managing access to resources

Shared memory:for highly efficient data sharing between programs

Messaging:for an easy way of passing data between programs

 

1.Semaphores

一般来说一个thread可能同时占有多个资源，所以Linux中总是对一组sem进行操作， 不过大部分情况下我们只要对一两个sem进行操作。

#include <sys/sem.h>

int semget(key_t key,int num_sems,int sem_flags);

key_t 像文件名一样表示一个资源

num_sems 信号量的大小

函数返回int型sem_id

实际上semget函数跟fopen函数很类似

key_t类似文件名，是唯一的

sem_id则是fopen函数返回的FILE * file stream

所以可以有不同的process可以用不同的信号量对应同一个资源

 

int semctl(int sem_id,int sem_num,int command,...);

sem_num 是semaphore number,use it when work with arrays of semaphores

如果是0 表示the first and only semphore

第四个参数通常是下面的结构

struct semun{

    int val;

    struct semid_ds * buf;

    unsigned short * array;

}

command 为SETVAL时就初始化sem的值为semun.val

command 为IPC_RMID时删除sem_id如果不再使用

int semop(int sem_id,struct sembuf * sem_ops,size_t num_sem_ops);

struct sembuf{

     short sem_num;

     short sem_op;

     short sem_flay;

}

sem_num一般是0，除非有一组信号量

sem_op  通常是+1 或者-1 表示可以改变的值

sem_flg 通常是SEM_UNDO 这样process 没释放sem就结束的话，操作系统会自动release the semaphore

下面是一个例子

/* After the #includes, the function prototypes and the global variable, we come to the main function. There the semaphore is created with a call to semget, which returns the semaphore ID. If the program is the first to be called (i.e. it's called with a parameter and argc > 1), a call is made to set_semvalue to initialize the semaphore and op_char is set to X. */ #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <sys/sem.h> static int set_semvalue(void); static void del_semvalue(void); static int semaphore_p(void); static int semaphore_v(void); static int sem_id; int main(int argc, char *argv[]) { int i; int pause_time; char op_char = 'O'; srand((unsigned int)getpid()); sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT); if (argc > 1) { if (!set_semvalue()) { fprintf(stderr, "Failed to initialize semaphore/n"); exit(EXIT_FAILURE); } op_char = 'X'; sleep(2); } /* Then we have a loop which enters and leaves the critical section ten times. There, we first make a call to semaphore_p which sets the semaphore to wait, as this program is about to enter the critical section. */ for(i = 0; i < 10; i++) { if (!semaphore_p()) exit(EXIT_FAILURE); printf("%c", op_char);fflush(stdout); pause_time = rand() % 3; sleep(pause_time); printf("%c", op_char);fflush(stdout); /* After the critical section, we call semaphore_v, setting the semaphore available, before going through the for loop again after a random wait. After the loop, the call to del_semvalue is made to clean up the code. */ if (!semaphore_v()) exit(EXIT_FAILURE); pause_time = rand() % 2; sleep(pause_time); } printf("/n%d - finished/n", getpid()); if (argc > 1) { sleep(10); del_semvalue(); } exit(EXIT_SUCCESS); } /* The function set_semvalue initializes the semaphore using the SETVAL command in a semctl call. We need to do this before we can use the semaphore. */ static int set_semvalue(void) { union semun sem_union; sem_union.val = 1; if (semctl(sem_id, 0, SETVAL, sem_union) == -1) return(0); return(1); } /* The del_semvalue function has almost the same form, except the call to semctl uses the command IPC_RMID to remove the semaphore's ID. */ static void del_semvalue(void) { union semun sem_union; if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1) fprintf(stderr, "Failed to delete semaphore/n"); } /* semaphore_p changes the semaphore by -1 (waiting). */ static int semaphore_p(void) { struct sembuf sem_b; sem_b.sem_num = 0; sem_b.sem_op = -1; /* P() */ sem_b.sem_flg = SEM_UNDO; if (semop(sem_id, &sem_b, 1) == -1) { fprintf(stderr, "semaphore_p failed/n"); return(0); } return(1); } /* semaphore_v is similar except for setting the sem_op part of the sembuf structure to 1, so that the semaphore becomes available. */ static int semaphore_v(void) { struct sembuf sem_b; sem_b.sem_num = 0; sem_b.sem_op = 1; /* V() */ sem_b.sem_flg = SEM_UNDO; if (semop(sem_id, &sem_b, 1) == -1) { fprintf(stderr, "semaphore_v failed/n"); return(0); } return(1); }

 

 

---

 

Shared Memory是能在两个Process之间高效的传输数据一种IPC

一个Process创建一块SM，其他Process可以将其作为自己地址空间的一部分访问。当一个Process想SM中写入时，其他的Process都会得知

#include <sys/shm.h>

int shmget(key_t key,size_t size,int shmflg);

size是内存大小

函数返回shm_id

void * shmat(int shm_id,const void *shm_addr,int shmflg);

当创建一个SM后，需要将它加入到其他进程的地址空间中

shm_addr通常为NULL，让系统自动简历映射

shmflg 如果是SHM_RND表示 SHM_RDONLY表示这块SM对于这个进程是只读的

int shmdt(const void *shm_addr);makes that memory unavailable to the current process

int shmctl(int shm_id,int cmd,struct shmid_ds *buf);

shmid_ds{

uid_t shm_perm.uid;

uid_t shm_perm.gid;

mode_t shm_perm.mode;

}

command可以为IPC_STAT IPC_SET IPC_RMID

/* Our first program is a consumer. After the headers the shared memory segment (the size of our shared memory structure) is created with a call to shmget, with the IPC_CREAT bit specified. */ #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <sys/shm.h> #include "shm_com.h" int main() { int running = 1; void *shared_memory = (void *)0; struct shared_use_st *shared_stuff; int shmid; srand((unsigned int)getpid()); shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT); if (shmid == -1) { fprintf(stderr, "shmget failed/n"); exit(EXIT_FAILURE); } /* We now make the shared memory accessible to the program. */ shared_memory = shmat(shmid, (void *)0, 0); if (shared_memory == (void *)-1) { fprintf(stderr, "shmat failed/n"); exit(EXIT_FAILURE); } printf("Memory attached at %X/n", (int)shared_memory); /* The next portion of the program assigns the shared_memory segment to shared_stuff, which then prints out any text in written_by_you. The loop continues until end is found in written_by_you. The call to sleep forces the consumer to sit in its critical section, which makes the producer wait. */ shared_stuff = (struct shared_use_st *)shared_memory; shared_stuff->written_by_you = 0; while(running) { if (shared_stuff->written_by_you) { printf("You wrote: %s", shared_stuff->some_text); sleep( rand() % 4 ); /* make the other process wait for us ! */ shared_stuff->written_by_you = 0; if (strncmp(shared_stuff->some_text, "end", 3) == 0) { running = 0; } } } /* Lastly, the shared memory is detached and then deleted. */ if (shmdt(shared_memory) == -1) { fprintf(stderr, "shmdt failed/n"); exit(EXIT_FAILURE); } if (shmctl(shmid, IPC_RMID, 0) == -1) { fprintf(stderr, "shmctl(IPC_RMID) failed/n"); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); }

/* The second program is the producer and allows us to enter data for consumers. It's very similar to shm1.c and looks like this. */ #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <sys/shm.h> #include "shm_com.h" int main() { int running = 1; void *shared_memory = (void *)0; struct shared_use_st *shared_stuff; char buffer[BUFSIZ]; int shmid; shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT); if (shmid == -1) { fprintf(stderr, "shmget failed/n"); exit(EXIT_FAILURE); } shared_memory = shmat(shmid, (void *)0, 0); if (shared_memory == (void *)-1) { fprintf(stderr, "shmat failed/n"); exit(EXIT_FAILURE); } printf("Memory attached at %X/n", (int)shared_memory); shared_stuff = (struct shared_use_st *)shared_memory; while(running) { while(shared_stuff->written_by_you == 1) { sleep(1); printf("waiting for client.../n"); } printf("Enter some text: "); fgets(buffer, BUFSIZ, stdin); strncpy(shared_stuff->some_text, buffer, TEXT_SZ); shared_stuff->written_by_you = 1; if (strncmp(buffer, "end", 3) == 0) { running = 0; } } if (shmdt(shared_memory) == -1) { fprintf(stderr, "shmdt failed/n"); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); }

---

message queue一般比pipe高效简单，但传递的数据大小仍然有限制

#include <sys/msg.h>

int msgget(key_t key,int msgflg);

int msgsnd(int msqid,const void *msg_ptr,size_t msg_sz,int msgflg);

添加一个message到message queue

int msgrcv(int msqid,void * msg_ptr,size_t msg_sz,long int msgtype,int msgflg);

从message queue中取message

int msgctl(int msqid,int command,struct msqid_ds *buf);

struct msqid_ds{

    uid_t msg_perm.uid;

    uid_t msg_perm.gid;

    mode_t msg_perm.mode;

}

/* Here's the receiver program. */ #include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/msg.h> struct my_msg_st { long int my_msg_type; char some_text[BUFSIZ]; }; int main() { int running = 1; int msgid; struct my_msg_st some_data; long int msg_to_receive = 0; /* First, we set up the message queue. */ msgid = msgget((key_t)1234, 0666 | IPC_CREAT); if (msgid == -1) { fprintf(stderr, "msgget failed with error: %d/n", errno); exit(EXIT_FAILURE); } /* Then the messages are retrieved from the queue, until an end message is encountered. Lastly, the message queue is deleted. */ while(running) { if (msgrcv(msgid, (void *)&some_data, BUFSIZ, msg_to_receive, 0) == -1) { fprintf(stderr, "msgrcv failed with error: %d/n", errno); exit(EXIT_FAILURE); } printf("You wrote: %s", some_data.some_text); if (strncmp(some_data.some_text, "end", 3) == 0) { running = 0; } } if (msgctl(msgid, IPC_RMID, 0) == -1) { fprintf(stderr, "msgctl(IPC_RMID) failed/n"); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); }

/* The sender program is very similar to msg1.c. In the main set up, delete the msg_to_receive declaration and replace it with buffer[BUFSIZ], remove the message queue delete and make the following changes to the running loop. We now have a call to msgsnd to send the entered text to the queue. */ #include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/msg.h> #define MAX_TEXT 512 struct my_msg_st { long int my_msg_type; char some_text[MAX_TEXT]; }; int main() { int running = 1; struct my_msg_st some_data; int msgid; char buffer[BUFSIZ]; msgid = msgget((key_t)1234, 0666 | IPC_CREAT); if (msgid == -1) { fprintf(stderr, "msgget failed with error: %d/n", errno); exit(EXIT_FAILURE); } while(running) { printf("Enter some text: "); fgets(buffer, BUFSIZ, stdin); some_data.my_msg_type = 1; strcpy(some_data.some_text, buffer); if (msgsnd(msgid, (void *)&some_data, MAX_TEXT, 0) == -1) { fprintf(stderr, "msgsnd failed/n"); exit(EXIT_FAILURE); } if (strncmp(buffer, "end", 3) == 0) { running = 0; } } exit(EXIT_SUCCESS); }