描述
编辑
以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开两辆，则又可以放入两辆，如此往复。
在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。
分类
编辑
整型信号量（integer semaphore)：信号量是整数
记录型信号量（record semaphore)：每个信号量s除一个整数值s.value（计数）外，还有一个进程等待队列s.L，其中是阻塞在该信号量的各个进程的标识
二进制信号量(binary semaphore)：只允许信号量取0或1值
每个信号量至少须记录两个信息：信号量的值和等待该信号量的进程队列。它的类型定义如下：（用类PASCAL语言表述）
semaphore = record
value: integer
queue: ^PCB
end
其中PCB是进程控制块，是操作系统为每个进程建立的数据结构。
s.value>=0时，s.queue为空；
s.value<0时，s.value的绝对值为s.queue中等待进程的个数；
特性
编辑
抽象的来讲，信号量的特性如下：信号量是一个非负整数（车位数），所有通过它的线程/进程（车辆）都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待） 和 Release（释放）。当一个线程调用Wait操作时，它要么得到资源然后将信号量减一，要么一直等下去（指放入阻塞队列），直到信号量大于等于一时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。
操作方式
编辑
对信号量有4种操作(include<semaphore>)：
1. 初始化（initialize），也叫做建立（create） int sem_init(sem_t *sem, int pshared, unsigned int value)
2. 等信号（wait），也可叫做挂起（suspend）int sem_wait(sem_t *sem)
3. 给信号（signal）或发信号（post） int sem_post（sem_t *sem）
4.清理（destroy） int sem_destory(sem_t *sem)[1]
创建
编辑
同共享内存一样，系统中同样需要为信号量集定制一系列专有的操作函数（semget，semctl等）。系统命令ipcs可查看当前的系统IPC的状态，在命令后使用-s参数。使用函数semget可以创建或者获得一个信号量集ID，函数原型如下：
#include <sys/shm.h>
int semget( key_t key, int nsems, int flag)
函数中参数key用来变换成一个标识符，每一个IPC对象与一个key相对应。当新建一个共享内存段时，使用参数flag的相应权限位对ipc_perm结构中的mode域赋值，对相应信号量集的shmid_ds初始化的值如表1所示。
shmid_ds结构初始化值表
ipc_perm结构数据
初 值
ipc_perm结构数据
初 值
Sem_otime
0
Sem_nsems
Nsems
Sem_ctime
系统当前值
参数nsems是一个大于等于0的值，用于指明该信号量集中可用资源数（在创建一个信号量时）。当打开一个已存在的信号量集时该参数值为0。函数执行成功，则返回信号量集的标识符（一个大于等于0的整数），失败，则返回–1。函数semop用以操作一个信号量集，函数原型如下：
#include <sys/sem.h>
int semop( int semid, struct sembuf semoparray[], size_t nops )
函数中参数semid是一个通过semget函数返回的一个信号量标识符，参数nops标明了参数semoparray所指向数组中的元素个数。参数semoparray是一个struct sembuf结构类型的数组指针，结构sembuf来说明所要执行的操作，其定义如下：
struct sembuf{
unsigned short sem_num
short sem_op
short sem_flg
}
在sembuf结构中，sem_num是相对应的信号量集中的某一个资源，所以其值是一个从0到相应的信号量集的资源总数（ipc_perm.sem_nsems）之间的整数。sem_op指明所要执行的操作，sem_flg说明函数semop的行为。sem_op的值是一个整数，如表2所示，列出了详细sem_op的值及所对应的操作。
sem_op值详解
Sem_op
操 作
正数
释放相应的资源数，将sem_op的值加到信号量的值上
0
进程阻塞直到信号量的相应值为0，当信号量已经为0，函数立即返回。如果信号量的值不为0，则依据sem_flg的IPC_NOWAIT位决定函数动作。sem_flg指定IPC_NOWAIT，则semop函数出错返回EAGAIN。sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生。信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；此信号量被删除（只有超级用户或创建用户进程拥有此权限），函数smeop出错返回EIDRM；进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
负数
请求sem_op的绝对值的资源。如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。当相应的资源数不能满足请求时，这个操作与sem_flg有关。sem_flg指定IPC_NOWAIT，则semop函数出错返回EAGAIN。sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：当相应的资源数可以满足请求，该信号的值减去sem_op的绝对值。成功返回；此信号量被删除（只有超级用户或创建用户进程拥有此权限），函数smeop出错返回EIDRM：进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
基本流程
编辑
下面实例演示了关于信号量操作的基本流程。程序中使用semget函数创建一个信号量集，并使用semop函数在这个信号集上执行了一次资源释放操作。并在shell中使用命令查看系统IPC的状态。
（1）在vi编辑器中编辑该程序。
程序清单14-10 create_sem.c 使用semget函数创建一个信号量
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
int main( void )
{
int sem_id
int nsems = 1
int flags = 0666
struct sembuf buf
sem_id = semget(IPC_PRIVATE, nsems, flags)/*创建一个新的信号量集*/
if ( sem_id <0 ){
perror( "semget ")
exit (1 )
}
/*输出相应的信号量集标识符*/
printf ( "successfully created a semaphore : %d\n", sem_id )
buf.sem_num = 0/*定义一个信号量操作*/
buf.sem_op = 1/*执行释放资源操作*/
buf.sem_flg = IPC_NOWAIT/*定义semop函数的行为*/
if ( (semop( sem_id, &buf, nsems) ) <0) { /*执行操作*/
perror ( "semop")
exit (1 )
}
system ( "ipcs -s " )/*查看系统IPC状态*/
exit ( 0 )
}
（2）在vmware中编译该程序如下：
gcc -o a.o testc_semaphore.c
（3）在shell中运行该程序如下：
./a3.o
successfully created a semaphore : 0
------ Semaphore Arrays --------
key semid owner perms nsems
0x00000000 0 zcr 666 1
在上面程序中，用semget函数创建了一个信号量集，定义信号量集的资源数为1，接下来使用semop函数进行资源释放操作。在程序的最后使用shell命令ipcs来查看系统IPC的状态。
%注意：命令ipcs参数-s标识查看系统IPC的信号量集状态。
希望能帮到你，满意望采纳哦。
linux中的进程通信分为三个部分：低级通信，管道通信和进程间通信IPC（inter process communication）。linux的低级通信主要用来传递进程的控制信号——文件锁和软中断信号机制。linux的进程间通信IPC有三个部分——①信号量，②共享内存和③消息队列。以下是我编写的linux进程通信的C语言实现代码。操作系统为redhat9.0，编辑器为vi，编译器采用gcc。下面所有实现代码均已经通过测试，运行无误。一.低级通信--信号通信
signal.c
#include
#include
#include
/*捕捉到信号sig之后，执行预先预定的动作函数*/
void sig_alarm(int sig)
{
printf("---the signal received is %d. /n", sig)
signal(SIGINT, SIG_DFL)//SIGINT终端中断信号，SIG_DFL：恢复默认行为，SIN_IGN：忽略信号
}
int main()
{
signal(SIGINT, sig_alarm)//捕捉终端中断信号
while(1)
{
printf("waiting here!/n")
sleep(1)
}
return 0
}
二.管道通信
pipe.c
#include
#define BUFFER_SIZE 30
int main()
{
int x
int fd[2]
char buf[BUFFER_SIZE]
char s[BUFFER_SIZE]
pipe(fd)//创建管道
while((x=fork())==-1)//创建管道失败时，进入循环
/*进入子进程，子进程向管道中写入一个字符串*/
if(x==0)
{
sprintf(buf,"This is an example of pipe!/n")
write(fd[1],buf,BUFFER_SIZE)
exit(0)
}
/*进入父进程，父进程从管道的另一端读出刚才写入的字符串*/
else
{
wait(0)//等待子进程结束
read(fd[0],s,BUFFER_SIZE)//读出字符串，并将其储存在char s[]中
printf("%s",s)//打印字符串
}
return 0
}
三.进程间通信——IPC
①信号量通信
sem.c
#include
#include
#include
#include types.h>
#include ipc.h>
#include sem.h>
/*联合体变量*/
union semun
{
int val//信号量初始值
struct semid_ds *buf
unsigned short int *array
struct seminfo *__buf
}
/*函数声明，信号量定义*/
static int set_semvalue(void)//设置信号量
static void del_semvalue(void)//删除信号量
static int semaphore_p(void)//执行P操作
static int semaphore_v(void)//执行V操作
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)//创建一个信号量,IPC_CREAT表示创建一个新的信号量
/*如果有参数，设置信号量，修改字符*/
if (argc >1)
{
if (!set_semvalue())
{
fprintf(stderr, "Failed to initialize semaphore/n")
exit(EXIT_FAILURE)
}
op_char = 'X'
sleep(5)
}
for(i = 0i <10i++)
{
/*执行P操作*/
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)
/*执行V操作*/
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)
}
/*设置信号量*/
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)
}
/*删除信号量*/
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")
}
/*执行P操作*/
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)
}
/*执行V操作*/
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)
}
②消息队列通信
send.c
#include
#include
#include
#include
#include
#include types.h>
#include ipc.h>
#include msg.h>
#define MAX_TEXT 512
/*用于消息收发的结构体--my_msg_type：消息类型，some_text：消息正文*/
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)
}
receive.c
#include
#include
#include
#include
#include
#include types.h>
#include ipc.h>
#include msg.h>
/*用于消息收发的结构体--my_msg_type：消息类型，some_text：消息正文*/
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//接收消息的类型--0表示msgid队列上的第一个消息
/*创建消息队列*/
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)
{
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)
}
③共享内存通信
share.h
#define TEXT_SZ 2048 //申请共享内存大小
struct shared_use_st
{
int written_by_you//written_by_you为1时表示有数据写入，为0时表示数据已经被消费者提走
char some_text[TEXT_SZ]
}
producer.c
#include
#include
#include
#include
#include types.h>
#include ipc.h>
#include shm.h>
#include "share.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)
}
printf("producer exit./n")
exit(EXIT_SUCCESS)
}
customer.c
#include
#include
#include
#include
#include types.h>
#include ipc.h>
#include shm.h>
#include "share.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)
}
/*将共享内存连接到一个进程的地址空间中*/
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
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 )
shared_stuff->written_by_you = 0
if (strncmp(shared_stuff->some_text, "end", 3) == 0)
{
running = 0
}
}
}
/*该函数用来将共享内存从当前进程中分离,仅使得当前进程不再能使用该共享内存*/
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)
}
摘自：
linux下进程间通信的几种主要手段简介：
一般文件的I/O函数都可以用于管道，如close、read、write等等。
实例1：用于shell
管道可用于输入输出重定向，它将一个命令的输出直接定向到另一个命令的输入。比如，当在某个shell程序（Bourne shell或C shell等）键入who│wc -l后，相应shell程序将创建who以及wc两个进程和这两个进程间的管道。
实例二：用于具有亲缘关系的进程间通信
管道的主要局限性正体现在它的特点上：
有名管道的创建
小结：
管道常用于两个方面：（1）在shell中时常会用到管道（作为输入输入的重定向），在这种应用方式下，管道的创建对于用户来说是透明的；（2）用于具有亲缘关系的进程间通信，用户自己创建管道，并完成读写操作。
FIFO可以说是管道的推广，克服了管道无名字的限制，使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。
管道和FIFO的数据是字节流，应用程序之间必须事先确定特定的传输"协议"，采用传播具有特定意义的消息。
要灵活应用管道及FIFO，理解它们的读写规则是关键。
信号生命周期
信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。
可以从两个不同的分类角度对信号进行分类：（1）可靠性方面：可靠信号与不可靠信号；（2）与时间的关系上：实时信号与非实时信号。
(1) 可靠信号与不可靠信号
不可靠信号 ：Linux下的不可靠信号问题主要指的是信号可能丢失。
可靠信号 ：信号值位于SIGRTMIN和SIGRTMAX之间的信号都是可靠信号，可靠信号克服了信号可能丢失的问题。Linux在支持新版本的信号安装函数sigation（）以及信号发送函数sigqueue()的同时，仍然支持早期的signal（）信号安装函数，支持信号发送函数kill()。
对于目前linux的两个信号安装函数:signal()及sigaction()来说，它们都不能把SIGRTMIN以前的信号变成可靠信号（都不支持排队，仍有可能丢失，仍然是不可靠信号），而且对SIGRTMIN以后的信号都支持排队。这两个函数的最大区别在于，经过sigaction安装的信号都能传递信息给信号处理函数（对所有信号这一点都成立），而经过signal安装的信号却不能向信号处理函数传递信息。对于信号发送函数来说也是一样的。
(2) 实时信号与非实时信号
前32种信号已经有了预定义值，每个信号有了确定的用途及含义，并且每种信号都有各自的缺省动作。如按键盘的CTRL ^C时，会产生SIGINT信号，对该信号的默认反应就是进程终止。后32个信号表示实时信号，等同于前面阐述的可靠信号。这保证了发送的多个实时信号都被接收。实时信号是POSIX标准的一部分，可用于应用进程。非实时信号都不支持排队，都是不可靠信号；实时信号都支持排队，都是可靠信号。
发送信号的主要函数有：kill()、raise()、 sigqueue()、alarm()、setitimer()以及abort()。
调用成功返回 0；否则，返回 -1。
sigqueue()是比较新的发送信号系统调用，主要是针对实时信号提出的（当然也支持前32种），支持信号带有参数，与函数sigaction()配合使用。
sigqueue的第一个参数是指定接收信号的进程ID，第二个参数确定即将发送的信号，第三个参数是一个联合数据结构union sigval，指定了信号传递的参数，即通常所说的4字节值。
sigqueue()比kill()传递了更多的附加信息，但sigqueue()只能向一个进程发送信号。sigqueue()比kill()传递了更多的附加信息，但sigqueue()只能向一个进程发送信号。
inux主要有两个函数实现信号的安装： signal() 、 sigaction() 。其中signal()在可靠信号系统调用的基础上实现, 是库函数。它只有两个参数，不支持信号传递信息，主要是用于前32种非实时信号的安装；而sigaction()是较新的函数（由两个系统调用实现：sys_signal以及sys_rt_sigaction），有三个参数，支持信号传递信息，主要用来与 sigqueue() 系统调用配合使用，当然，sigaction()同样支持非实时信号的安装。sigaction()优于signal()主要体现在支持信号带有参数。
消息队列就是一个消息的链表。可以把消息看作一个记录，具有特定的格式以及特定的优先级。对消息队列有写权限的进程可以向中按照一定的规则添加新消息；对消息队列有读权限的进程则可以从消息队列中读走消息。消息队列是随内核持续的
消息队列的内核持续性要求每个消息队列都在系统范围内对应唯一的键值，所以，要获得一个消息队列的描述字，只需提供该消息队列的键值即可；
消息队列与管道以及有名管道相比，具有更大的灵活性，首先，它提供有格式字节流，有利于减少开发人员的工作量；其次，消息具有类型，在实际应用中，可作为优先级使用。这两点是管道以及有名管道所不能比的。同样，消息队列可以在几个进程间复用，而不管这几个进程是否具有亲缘关系，这一点与有名管道很相似；但消息队列是随内核持续的，与有名管道（随进程持续）相比，生命力更强，应用空间更大。
信号灯与其他进程间通信方式不大相同，它主要提供对进程间共享资源访问控制机制。相当于内存中的标志，进程可以根据它判定是否能够访问某些共享资源，同时，进程也可以修改该标志。除了用于访问控制外，还可用于进程同步。信号灯有以下两种类型：
int semop(int semid, struct sembuf *sops, unsigned nsops) semid是信号灯集ID，sops指向数组的每一个sembuf结构都刻画一个在特定信号灯上的操作。
int semctl(int semid，int semnum，int cmd，union semun arg)
该系统调用实现对信号灯的各种控制操作，参数semid指定信号灯集，参数cmd指定具体的操作类型；参数semnum指定对哪个信号灯操作，只对几个特殊的cmd操作有意义；arg用于设置或返回信号灯信息。
进程间需要共享的数据被放在一个叫做IPC共享内存区域的地方，所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间中去。系统V共享内存通过shmget获得或创建一个IPC共享内存区域，并返回相应的标识符。内核在保证shmget获得或创建一个共享内存区，初始化该共享内存区相应的shmid_kernel结构注同时，还将在特殊文件系统shm中，创建并打开一个同名文件，并在内存中建立起该文件的相应dentry及inode结构，新打开的文件不属于任何一个进程（任何进程都可以访问该共享内存区）。所有这一切都是系统调用shmget完成的。
shmget（）用来获得共享内存区域的ID，如果不存在指定的共享区域就创建相应的区域。shmat()把共享内存区域映射到调用进程的地址空间中去，这样，进程就可以方便地对共享区域进行访问操作。shmdt()调用用来解除进程对共享内存区域的映射。shmctl实现对共享内存区域的控制操作。这里我们不对这些系统调用作具体的介绍，读者可参考相应的手册页面，后面的范例中将给出它们的调用方法。
注：shmget的内部实现包含了许多重要的系统V共享内存机制；shmat在把共享内存区域映射到进程空间时，并不真正改变进程的页表。当进程第一次访问内存映射区域访问时，会因为没有物理页表的分配而导致一个缺页异常，然后内核再根据相应的存储管理机制为共享内存映射区域分配相应的页表。
欢迎分享，转载请注明来源：夏雨云
微信扫一扫
支付宝扫一扫
评论列表（0条）