通信的方式有多种,假设需要在Linux系

通信的方式有多种,假设需要在Linux系,第1张

进程间的通信方式:

1.管道(pipe)及有名管道(named pipe):

管道可用于具有亲缘关系进程间的通信,有名管道除了具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。

2.信号(signal):

信号是在软件层次上对中断机制的一种模拟,它是比较复杂的通信方式,用于通知进程有某事件发生,一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致得。

3.消息队列(message queue):

消息队列是消息的链接表,它克服了上两种通信方式中信号量有限的缺点,具有写权限得进程可以按照一定得规则向消息队列中添加新信息;对消息队列有读权限得进程则可以从消息队列中读取信息。

消息缓冲通信技术是由Hansen首先提出的,其基本思想是:根据”生产者-消费者”原理,利用内存中公用消息缓冲区实现进程之间的信息交换.

内存中开辟了若干消息缓冲区,用以存放消息.每当一个进程向另一个进程发送消息时,便申请一个消息缓冲区,并把已准备好的消息送到缓冲区,然后把该消息缓冲区插入到接收进程的消息队列中,最后通知接收进程.接收进程收到发送里程发来的通知后,从本进程的消息队列中摘下一消息缓冲区,取出所需的信息,然后把消息缓冲区不定期给系统.系统负责管理公用消息缓冲区以及消息的传递.

一个进程可以给若干个进程发送消息,反之,一个进程可以接收不同进程发来的消息.显然,进程中关于消息队列的操作是临界区.当发送进程正往接收进程的消息队列中添加一条消息时,接收进程不能同时从该消息队列中到出消息:反之也一样.

消息缓冲区通信机制包含以下列内容:

(1) 消息缓冲区,这是一个由以下几项组成的数据结构:

1、 消息长度

2、 消息正文

3、 发送者

4、 消息队列指针

(2)消息队列首指针m-q,一般保存在PCB中。

(1) 互斥信号量m-mutex,初值为1,用于互斥访问消息队列,在PCB中设置。

(2) 同步信号量m-syn,初值为0,用于消息计数,在PCB中设置。

(3) 发送消息原语send

(4) 接收消息原语receive(a)

4.共享内存(shared memory):

可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间,不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作,如互斥锁和信号量等。

这种通信模式需要解决两个问题:第一个问题是怎样提供共享内存;第二个是公共内存的互斥关系则是程序开发人员的责任。

5.信号量(semaphore):

主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。

6.套接字(socket);

这是一种更为一般得进程间通信机制,它可用于网络中不同机器之间的进程间通信,应用非常广泛。

http://blog.csdn.net/eroswang/archive/2007/09/04/1772350.aspx

linux下的进程间通信-详解

详细的讲述进程间通信在这里绝对是不可能的事情,而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步,所以在这一节的开头首先向大家推荐著 名作者Richard Stevens的著名作品:《Advanced Programming in the UNIX Environment》,它的中文译本《UNIX环境高级编程》已有机械工业出版社出版,原文精彩,译文同样地道,如果你的确对在Linux下编程有浓 厚的兴趣,那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情,言归正传,在这一节里,我们将介绍进程间通信最最初步和最 最简单的一些知识和概念。

首先,进程间通信至少可以通过传送打开文件来实现,不同的进程通过一个或多个文件来传递信息,事实上,在很多应用系统里,都使用了这种方法。但一般说来, 进程间通信(IPC:InterProcess Communication)不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多,而且不幸的是,极少方法能在所有的Unix系 统中进行移植(唯一一种是半双工的管道,这也是最原始的一种通信方式)。而Linux作为一种新兴的操作系统,几乎支持所有的Unix下常用的进程间通信 方法:管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。

2.3.1 管道

管道是进程间通信中最古老的方式,它包括无名管道和有名管道两种,前者用于父进程和子进程间的通信,后者用于运行于同一台机器上的任意两个进程间的通信。

无名管道由pipe()函数创建:

#include <unistd.h>

int pipe(int filedis[2]);

参数filedis返回两个文件描述符:filedes[0]为读而打开,filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。

#define INPUT 0

#define OUTPUT 1

void main() {

int file_descriptors[2]

/*定义子进程号 */

pid_t pid

char buf[256]

int returned_count

/*创建无名管道*/

pipe(file_descriptors)

/*创建子进程*/

if((pid = fork()) == -1) {

printf("Error in fork\n")

exit(1)

}

/*执行子进程*/

if(pid == 0) {

printf("in the spawned (child) process...\n")

/*子进程向父进程写数据,关闭管道的读端*/

close(file_descriptors[INPUT])

write(file_descriptors[OUTPUT], "test data", strlen("test data"))

exit(0)

} else {

/*执行父进程*/

printf("in the spawning (parent) process...\n")

/*父进程从管道读取子进程写的数据,关闭管道的写端*/

close(file_descriptors[OUTPUT])

returned_count = read(file_descriptors[INPUT], buf, sizeof(buf))

printf("%d bytes of data received from spawned process: %s\n",

returned_count, buf)

}

}

在Linux系统下,有名管道可由两种方式创建:命令行方式mknod系统调用和函数mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道:

方式一:mkfifo("myfifo","rw")

方式二:mknod myfifo p

生成了有名管道后,就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。下面即是一个简单的例子,假设我们已经创建了一个名为myfifo的有名管道。

/* 进程一:读有名管道*/

#include <stdio.h>

#include <unistd.h>

void main() {

FILE * in_file

int count = 1

char buf[80]

in_file = fopen("mypipe", "r")

if (in_file == NULL) {

printf("Error in fdopen.\n")

exit(1)

}

while ((count = fread(buf, 1, 80, in_file)) >0)

printf("received from pipe: %s\n", buf)

fclose(in_file)

}

/* 进程二:写有名管道*/

#include <stdio.h>

#include <unistd.h>

void main() {

FILE * out_file

int count = 1

char buf[80]

out_file = fopen("mypipe", "w")

if (out_file == NULL) {

printf("Error opening pipe.")

exit(1)

}

sprintf(buf,"this is test data for the named pipe example\n")

fwrite(buf, 1, 80, out_file)

fclose(out_file)

}

2.3.2 消息队列

消息队列用于运行于同一台机器上的进程间通信,它和管道很相似,是一个在系统内核中用来保存消息的队列,它在系统内核中是以消息链表的形式出现。消息链表中节点的结构用msg声明。

事实上,它是一种正逐渐被淘汰的通信方式,我们可以用流管道或者套接口的方式来取代它,所以,我们对此方式也不再解释,也建议读者忽略这种方式。

2.3.3 共享内存

共享内存是运行在同一台机器上的进程间通信最快的方式,因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区,其余进程对这块内存区进行 读写。得到共享内存有两种方式:映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销,但在现实中并不常用,因为它控制存取的将是 实际的物理内存,在Linux系统下,这只有通过限制Linux系统存取的内存才可以做到,这当然不太实际。常用的方式是通过shmXXX函数族来实现利 用共享内存进行存储的。

首先要用的函数是shmget,它获得一个共享存储标识符。

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/shm.h>

int shmget(key_t key, int size, int flag)

这个函数有点类似大家熟悉的malloc函数,系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数 的标识符,这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的,这个关键字,就是上面第一个函数的 key。数据类型key_t是在头文件sys/types.h中定义的,它是一个长整形的数据。在我们后面的章节中,还会碰到这个关键字。

当共享内存创建后,其余进程可以调用shmat()将其连接到自身的地址空间中。

void *shmat(int shmid, void *addr, int flag)

shmid为shmget函数返回的共享存储标识符,addr和flag参数决定了以什么方式来确定连接的地址,函数的返回值即是该进程数据段所连接的实际地址,进程可以对此进程进行读写操作。

使用共享存储来实现进程间通信的注意点是对数据存取的同步,必须确保当一个进程去读取数据时,它所想要的数据已经写好了。通常,信号量被要来实现对共享存 储数据存取的同步,另外,可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。

2.3.4 信号量

信号量又称为信号灯,它是用来协调不同进程间的数据对象的,而最主要的应用是前一节的共享内存方式的进程间通信。本质上,信号量是一个计数器,它用来记录对某个资源(如共享内存)的存取状况。一般说来,为了获得共享资源,进程需要执行下列操作:

(1) 测试控制该资源的信号量。

(2) 若此信号量的值为正,则允许进行使用该资源。进程将信号量减1。

(3) 若此信号量为0,则该资源目前不可用,进程进入睡眠状态,直至信号量值大于0,进程被唤醒,转入步骤(1)。

(4) 当进程不再使用一个信号量控制的资源时,信号量值加1。如果此时有进程正在睡眠等待此信号量,则唤醒此进程。

维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件/usr/src/linux/include /linux /sem.h 中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合,用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget,用以获 得一个信号量ID。

struct sem {

short sempid/* pid of last operaton */

ushort semval/* current value */

ushort semncnt/* num procs awaiting increase in semval */

ushort semzcnt/* num procs awaiting semval = 0 */

}

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

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

key是前面讲过的IPC结构的关键字,flag将来决定是创建新的信号量集合,还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新 集合(一般在服务器中),则必须指定nsems;如果是引用一个现有的信号量集合(一般在客户机中)则将nsems指定为0。

semctl函数用来对信号量进行操作。

int semctl(int semid, int semnum, int cmd, union semun arg)

不同的操作是通过cmd参数来实现的,在头文件sem.h中定义了7种不同的操作,实际编程时可以参照使用。

semop函数自动执行信号量集合上的操作数组。

int semop(int semid, struct sembuf semoparray[], size_t nops)

semoparray是一个指针,它指向一个信号量操作数组。nops规定该数组中操作的数量。

下面,我们看一个具体的例子,它创建一个特定的IPC结构的关键字和一个信号量,建立此信号量的索引,修改索引指向的信号量的值,最后我们清除信号量。在下面的代码中,函数ftok生成我们上文所说的唯一的IPC关键字。

#include <stdio.h>

#include <sys/types.h>

#include <sys/sem.h>

#include <sys/ipc.h>

void main() {

key_t unique_key/* 定义一个IPC关键字*/

int id

struct sembuf lock_it

union semun options

int i

unique_key = ftok(".", 'a')/* 生成关键字,字符'a'是一个随机种子*/

/* 创建一个新的信号量集合*/

id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666)

printf("semaphore id=%d\n", id)

options.val = 1/*设置变量值*/

semctl(id, 0, SETVAL, options)/*设置索引0的信号量*/

/*打印出信号量的值*/

i = semctl(id, 0, GETVAL, 0)

printf("value of semaphore at index 0 is %d\n", i)

/*下面重新设置信号量*/

lock_it.sem_num = 0/*设置哪个信号量*/

lock_it.sem_op = -1/*定义操作*/

lock_it.sem_flg = IPC_NOWAIT/*操作方式*/

if (semop(id, &lock_it, 1) == -1) {

printf("can not lock semaphore.\n")

exit(1)

}

i = semctl(id, 0, GETVAL, 0)

printf("value of semaphore at index 0 is %d\n", i)

/*清除信号量*/

semctl(id, 0, IPC_RMID, 0)

}

semget()

可以使用系统调用semget()创建一个新的信号量集,或者存取一个已经存在的信号量集:

系统调用:semget()

原型:intsemget(key_t key,int nsems,int semflg)

返回值:如果成功,则返回信号量集的IPC标识符。如果失败,则返回-1:errno=EACCESS(没有权限)

EEXIST(信号量集已经存在,无法创建)

EIDRM(信号量集已经删除)

ENOENT(信号量集不存在,同时没有使用IPC_CREAT)

ENOMEM(没有足够的内存创建新的信号量集)

ENOSPC(超出限制)

系统调用semget()的第一个参数是关键字值(一般是由系统调用ftok()返回的)。系统内核将此值和系统中存在的其他的信号量集的关键字值进行比较。打开和存取操作与参数semflg中的内容相关。IPC_CREAT如果信号量集在系统内核中不存在,则创建信号量集。IPC_EXCL当和 IPC_CREAT一同使用时,如果信号量集已经存在,则调用失败。如果单独使用IPC_CREAT,则semget()要么返回新创建的信号量集的标识符,要么返回系统中已经存在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用,则要么返回新创建的信号量集的标识符,要么返回-1。IPC_EXCL单独使用没有意义。参数nsems指出了一个新的信号量集中应该创建的信号量的个数。信号量集中最多的信号量的个数是在linux/sem.h中定义的:

#defineSEMMSL32/*<=512maxnumofsemaphoresperid*/

下面是一个打开和创建信号量集的程序:

intopen_semaphore_set(key_t keyval,int numsems)

{

intsid

if(!numsems)

return(-1)

if((sid=semget(mykey,numsems,IPC_CREAT|0660))==-1)

{

return(-1)

}

return(sid)

}

}

==============================================================

semop()

系统调用:semop()

调用原型:int semop(int semid,struct sembuf*sops,unsign ednsops)

返回值:0,如果成功。-1,如果失败:errno=E2BIG(nsops大于最大的ops数目)

EACCESS(权限不够)

EAGAIN(使用了IPC_NOWAIT,但操作不能继续进行)

EFAULT(sops指向的地址无效)

EIDRM(信号量集已经删除)

EINTR(当睡眠时接收到其他信号)

EINVAL(信号量集不存在,或者semid无效)

ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)

ERANGE(信号量值超出范围)

第一个参数是关键字值。第二个参数是指向将要操作的数组的指针。第三个参数是数组中的操作的个数。参数sops指向由sembuf组成的数组。此数组是在linux/sem.h中定义的:

/*semop systemcall takes an array of these*/

structsembuf{

ushortsem_num/*semaphore index in array*/

shortsem_op/*semaphore operation*/

shortsem_flg/*operation flags*/

sem_num将要处理的信号量的个数。

sem_op要执行的操作。

sem_flg操作标志。

如果sem_op是负数,那么信号量将减去它的值。这和信号量控制的资源有关。如果没有使用IPC_NOWAIT,那么调用进程将进入睡眠状态,直到信号量控制的资源可以使用为止。如果sem_op是正数,则信号量加上它的值。这也就是进程释放信号量控制的资源。最后,如果sem_op是0,那么调用进程将调用sleep(),直到信号量的值为0。这在一个进程等待完全空闲的资源时使用。

===============================================================

semctl()

系统调用:semctl()

原型:int semctl(int semid,int semnum,int cmd,union semunarg)

返回值:如果成功,则为一个正数。

如果失败,则为-1:errno=EACCESS(权限不够)

EFAULT(arg指向的地址无效)

EIDRM(信号量集已经删除)

EINVAL(信号量集不存在,或者semid无效)

EPERM(EUID没有cmd的权利)

ERANGE(信号量值超出范围)

系统调用semctl用来执行在信号量集上的控制操作。这和在消息队列中的系统调用msgctl是十分相似的。但这两个系统调用的参数略有不同。因为信号量一般是作为一个信号量集使用的,而不是一个单独的信号量。所以在信号量集的操作中,不但要知道IPC关键字值,也要知道信号量集中的具体的信号量。这两个系统调用都使用了参数cmd,它用来指出要操作的具体命令。两个系统调用中的最后一个参数也不一样。在系统调用msgctl中,最后一个参数是指向内核中使用的数据结构的指针。我们使用此数据结构来取得有关消息队列的一些信息,以及设置或者改变队列的存取权限和使用者。但在信号量中支持额外的可选的命令,这样就要求有一个更为复杂的数据结构。

系统调用semctl()的第一个参数是关键字值。第二个参数是信号量数目。

参数cmd中可以使用的命令如下:

·IPC_STAT读取一个信号量集的数据结构semid_ds,并将其存储在semun中的buf参数中。

·IPC_SET设置信号量集的数据结构semid_ds中的元素ipc_perm,其值取自semun中的buf

他把答案删除了,所以我也得改下了。

--------------------------

semop() 这是个信号函数。

系统调用:semop()

调用原型:int semop(int semid,struct sembuf*sops,unsign ednsops)

返回值:0,如果成功。-1,如果失败:errno=E2BIG(nsops大于最大的ops数目)

EACCESS(权限不够)

EAGAIN(使用了IPC_NOWAIT,但操作不能继续进行)

EFAULT(sops指向的地址无效)

EIDRM(信号量集已经删除)

EINTR(当睡眠时接收到其他信号)

EINVAL(信号量集不存在,或者semid无效)

ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)

ERANGE(信号量值超出范围)

第一个参数是关键字值。第二个参数是指向将要操作的数组的指针。第三个参数是数组中的操作的个数。参数sops指向由sembuf组成的数组。此数组是在linux/sem.h中定义的:

/*semop systemcall takes an array of these*/

structsembuf{

ushortsem_num/*semaphore index in array*/

shortsem_op/*semaphore operation*/

shortsem_flg/*operation flags*/

sem_num将要处理的信号量的个数。

sem_op要执行的操作。

sem_flg操作标志。

如果sem_op是负数,那么信号量将减去它的值。这和信号量控制的资源有关。如果没有使用IPC_NOWAIT,那么调用进程将进入睡眠状态,直到信号量控制的资源可以使用为止。如果sem_op是正数,则信号量加上它的值。这也就是进程释放信号量控制的资源。最后,如果sem_op是0,那么调用进程将调用sleep(),直到信号量的值为0。这在一个进程等待完全空闲的资源时使用。

--------------------------

还比如: Semget(),semctl() 等。如有需要解释这些函数,你等加加分哦,我就一一讲解。

信号量:一个整数;

大于或等于0时代表可供并发进程使用的资源实体数;

小于0时代表正在等待使用临界区的进程数;

用于互斥的信号量初始值应大于0;

只能通过P、V原语操作而改变;

信号量元素组成:

1、表示信号量元素的值;

2、最后操作信号量元素的进程ID

3、等待信号量元素值+1的进程数;

4、等待信号量元素值为0的进程数;

二、主要函数

1.1 创建信号量

int semget(

key_t key, //标识信号量的关键字,有三种方法:1、使用IPC——PRIVATE让系统产生,

// 2、挑选一个随机数,3、使用ftok从文件路径名中产生

int nSemes, //信号量集中元素个数

int flag //IPC_CREAT;IPC_EXCL 只有在信号量集不存在时创建

)

成功:返回信号量句柄

失败:返回-1

1.2 使用ftok函数根据文件路径名产生一个关键字

key_t ftok(const char *pathname,int proj_id)

路径名称必须有相应权限

1.3 控制信号量

int semctl(

int semid, //信号量集的句柄

int semnum, //信号量集的元素数

int cmd, //命令

/*union senum arg */... //

)

成功:返回相应的值

失败:返回-1

命令详细说明:

cmd: IPC_RMID 删除一个信号量

IPC_EXCL 只有在信号量集不存在时创建

IPC_SET 设置信号量的许可权

SETVAL 设置指定信号量的元素的值为 agc.val

GETVAL 获得一个指定信号量的值

GETPID 获得最后操纵此元素的最后进程ID

GETNCNT 获得等待元素变为1的进程数

GETZCNT 获得等待元素变为0的进程数

union senum 定义如下:

union senum{

int val

struct semid_ds *buf

unsigned short * array

}agc

其中 semid_ds 定义如下:

struct semid_ds{

struct ipc_pem sem_pem //operation pemission struct

time_t sem_otime //last semop()time

time_t sem_ctime //last time changed by semctl()

struct sem *sembase //ptr to first semaphore in array

struct sem_queue *sem_pending//pending operations

struct sem_queue *sem_pending_last//last pending operations

struct sem_undo *undo //undo requests on this arrary

unsigned short int sem_nsems//number of semaphores in set

}

1.4 对信号量 +1 或 -1 或测试是否为0

int semop(

int semid,

struct sembuf *sops, //指向元素操作数组

unsigned short nsops //数组中元素操作的个数

)

结构 sembuf 定义

sembuf{

short int sem_num//semaphore number

short int sem_op//semaphore operaion

short int sem_flg //operation flag

}

三、例子:

2.1 服务器

#include <sys/sem.h>

#include <sys/ipc.h>

#define SEGSIZE 1024

#define READTIME 1

union semun {

int val

struct semid_ds *buf

unsigned short *array

} arg

//生成信号量

int sem_creat(key_t key)

{

union semun sem

int semid

sem.val = 0

semid = semget(key,1,IPC_CREAT|0666)

if (-1 == semid){

printf("create semaphore error\n")

exit(-1)

}

semctl(semid,0,SETVAL,sem)

return semid

}

//删除信号量

void del_sem(int semid)

{

union semun sem

sem.val = 0

semctl(semid,0,IPC_RMID,sem)

}

//p

int p(int semid)

{

struct sembuf sops={0,+1,IPC_NOWAIT}

return (semop(semid,&sops,1))

}

//v

int v(int semid)

{

struct sembuf sops={0,-1,IPC_NOWAIT}

return (semop(semid,&sops,1))

}

int main()

{

key_t key

int shmid,semid

char *shm

char msg[7] = "-data-"

char i

struct semid_ds buf

key = ftok("/",0)

shmid = shmget(key,SEGSIZE,IPC_CREAT|0604)

if (-1 == shmid){

printf(" create shared memory error\n")

return -1

}

shm = (char *)shmat(shmid,0,0)

if (-1 == (int)shm){

printf(" attach shared memory error\n")

return -1

}

semid = sem_creat(key)

for (i = 0i <= 3i++){

sleep(1)

p(semid)

sleep(READTIME)

msg[5] = '0' + i

memcpy(shm,msg,sizeof(msg))

sleep(58)

v(semid)

}

shmdt(shm)

shmctl(shmid,IPC_RMID,&buf)

del_sem(semid)

return 0

//gcc -o shm shm.c -g

}

2.2 客户端

#include <sys/sem.h>

#include <time.h>

#include <sys/ipc.h>

#define SEGSIZE 1024

#define READTIME 1

union semun {

int val

struct semid_ds *buf

unsigned short *array

} arg

// 打印程序执行时间

void out_time(void)

{

static long start = 0

time_t tm

if (0 == start){

tm = time(NULL)

start = (long)tm

printf(" now start ...\n")

}

printf(" second: %ld \n",(long)(time(NULL)) - start)

}

//创建信号量

int new_sem(key_t key)

{

union semun sem

int semid

sem.val = 0

semid = semget(key,0,0)

if (-1 == semid){

printf("create semaphore error\n")

exit(-1)

}

return semid

}

//等待信号量变成0

void wait_v(int semid)

{

struct sembuf sops={0,0,0}

semop(semid,&sops,1)

}

int main(void)

{

key_t key

int shmid,semid

char *shm

char msg[100]

char i

key = ftok("/",0)

shmid = shmget(key,SEGSIZE,0)

if(-1 == shmid){

printf(" create shared memory error\n")

return -1

}

shm = (char *)shmat(shmid,0,0)

if (-1 == (int)shm){

printf(" attach shared memory error\n")

return -1

}

semid = new_sem(key)

for (i = 0i <3i ++){

sleep(2)

wait_v(semid)

printf("Message geted is: %s \n",shm + 1)

out_time()

}

shmdt(shm)

return 0

// gcc -o shmc shmC.c -g

}


欢迎分享,转载请注明来源:夏雨云

原文地址:https://www.xiayuyun.com/zonghe/211234.html

(0)
打赏 微信扫一扫微信扫一扫 支付宝扫一扫支付宝扫一扫
上一篇 2023-04-04
下一篇2023-04-04

发表评论

登录后才能评论

评论列表(0条)

    保存