【linux草鞋应用编程系列】_3_ 进程间通信
一、进程间通信
linux下面提供了多种进程间通信的方法， 管道、信号、信号量、消息队列、共享内存、套接字等。下面我们分别
介绍管道、信号量、消息队列、共享内存。
信号和套接字在后续介绍。
1、管道
管道又分为无名管道、命名管道。 无名管道用于父子进程间通信， 而命名管道则可以用于同一计算机上运行的
两个进程间的通信。管道可以用类似“水管”的原理来理解。
1）无名管道
要在父子进程进程间使用管道进行通信，那么先需要创建管道， 在linux中使用 pipe（）创建管道。其原型如下：
PIPE() Linux Programmer’s Manual PIPE()
NAME
pipe - create pipe
SYNOPSIS
#include <unistd.h> int pipe(int filedes[]); //参数为一个长度为2 的整型数组的数组首地址， 为输出参数，
返回值：
成功创建管道返回0； 失败则返回-1；
管道分为两端，一端用来写，另一端则用来读（可以想象为水管，位置高的一端进水，位置低的一端将水流出去） 。
pipe（）函数的输出参数 filedes[0] 用于读取数据， filedes[1] 用于写入数据。
管道的操作和普通文件的操作一样， 但是要注意，读的时候要将写端关闭，写的时候要将读端关闭。
Exp： pipe.c 首先测试从父进程给子进程写数据。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h> int main(int argc,char* argv[])
{
int fd_pipe[];
pid_t pid;
char buf[]; //创建管道
if( pipe(fd_pipe) )
{
perror("create pipe");
exit();
} pid=fork();
if( ==pid )
{
/*close(fd_pipe[1]); //关闭写端*/
read(fd_pipe[], buf,sizeof(buf));
printf("in child process read data from pipe.\n");
printf("the data read from pipe is:%s\n",buf);
exit();
}
/*close(fd_pipe[0]); //关闭读端*/
write(fd_pipe[], "pipe test",sizeof("pipe test"));
sleep();
return ;
}
程序执行情况如下：
[root@localhost ipc]# gcc main.c
[root@localhost ipc]# ./a.out
in child process read data from pipe.
the data read from pipe is:pipe test
利用系统调用 read（）、write（）进行操作的时候管道默认是阻塞的，如果管道没有数据可读，那么read( )函数就
阻塞，直到有数据读才返回。
Exp： pipe.c 子进程写入数据到管道，父进程从管道读取数据
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h> #define CHAR "pipe test from child to parent\n" int main(int argc,char* argv[])
{
int fd_pipe[];
pid_t pid;
char buf[]; //创建管道
if( pipe(fd_pipe) )
{
perror("create pipe");
exit();
} pid=fork();
if( ==pid )
{
close(fd_pipe[]);
write(fd_pipe[],CHAR,sizeof(CHAR));
exit();
} close(fd_pipe[]);
read(fd_pipe[],buf,sizeof(buf));
printf("data from child is: %s",buf); return ;
}
执行结果如下：
[root@localhost ipc]# gcc main.c
[root@localhost ipc]# ./a.out
data from child is: pipe test from child to parent
2）命名管道
命名管道用于系统中两个进程之间通信；命名管道可用于系统中两个没有亲缘关系的进程进行通信（也可以用于父
子进程间的通信） 。
要使用命名管道，则需要创建命名管道，用函数 mkfifo （） 创建命名管道。其原型如下：
MKFIFO() Linux Programmer’s Manual MKFIFO()
NAME
mkfifo - make a FIFO special file (a named pipe)
SYNOPSIS
#include <sys/types.h>
#include <sys/stat.h> int mkfifo( const char *pathname, //生成的管道特殊文件的位置和文件名
mode_t mode); //管道特殊文件的访问权限
返回值：
成功创建管道文件返回0， 失败返回 -1.
创建号管道特殊文件后，就可以和访问普通文件一样访问管道特殊文件。
Exp： 测试命名管道 pipe-w.c 创建命令管道并向管道写入数据
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h> #define CHAR "pipe named\n" int main(int argc,char* argv[])
{
int fd;
int ret; //创建管道
ret=mkfifo("./fifo-pipe",);
if(ret)
{
perror("mkfifo: fifo-pipe");
exit();
} fd=open("./fifo-pipe",O_WRONLY);
write(fd,CHAR,sizeof(CHAR)); close(fd);
return ;
}
pipe-r.c 打开pipe-w.c 文件，并且从命名管道读取数据：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h> int main(int argc,char* argv[])
{
int fd;
int ret;
char buf[]; //打开命名管道文件
fd=open("./fifo-pipe",O_RDONLY);
if(- == fd)
{
perror("open fifo-pipe");
exit();
} ret=read(fd,buf,sizeof(buf));
if(ret<)
{
perror("read fifo-pipe");
exit();
}
printf("the data read from fifo pipe:%s\n",buf); close(fd);
return ;
}
程序的执行结果如下：
pipe-w.c 生成wp ， pipe-r.c 生成rp
[root@localhost pipe]# ll //查看没有 fifo-pipe 的命名管道文件
总计
-rw-r--r-- root root - : pipe_fork.c
-rw-r--r-- root root - : pipe-r.c
-rw-r--r-- root root - : pipe-w.c
-rwxr-xr-x root root - : rp
-rwxr-xr-x root root - : wp
[root@localhost pipe]# ./wp & //wp运行，并且进入后台
[]
[root@localhost pipe]# jobs
[]+ Running ./wp & //wp在后台运行， 等待命名管道的数据被读取， 即wp 阻塞
[root@localhost pipe]# ./rp //rp 读取管道数据，
the data read from fifo pipe:pipe named //数据读取成功 []+ Done ./wp //管道中的数据被读取完后，wp不再阻塞，返回
[root@localhost pipe]# jobs
[root@localhost pipe]# ll
总计
prw-r--r-- root root - : fifo-pipe //生成一个命名管道文件
-rw-r--r-- root root - : pipe_fork.c
-rw-r--r-- root root - : pipe-r.c
-rw-r--r-- root root - : pipe-w.c
-rwxr-xr-x root root - : rp
-rwxr-xr-x root root - : wp
[root@localhost pipe]#
要点：
在进程操作管道的时候， write 和 read 都是阻塞的； 如果写的数据没有被读取走，那么就会写的进程就会
在 write 函数阻塞； 如果读数据的时候，管道没有数据，那么就会等待管道里面别写入数据，进程在read 函数阻塞。
2、消息队列
消息队列也是linux下进程间通信的一种方式， 如果要使用消息队列在进程间进行通信，必须创建一个消息队列
或者打开一个已经存在的消息队列。
要打开一个已经存在的消息队列，或者创建一个新的消息队列，则必须先获取一个关于消息队列的IPC键值；通过函
数 ftok( )获取消息队列的IPC键值。
ftok 的原型如下：
FTOK() Linux Programmer’s Manual FTOK()
NAME
ftok - convert a pathname and a project identifier to a System V IPC key
//由一个特定的工程号和文件生成一个特定的IPC键值，
SYNOPSIS
# include <sys/types.h>
# include <sys/ipc.h> key_t ftok(const char *pathname, //文件名
int proj_id); //工程号
返回值：
成功返回 IPC键值， 失败返回-1.
要点：
如果文件名和工程号一致，内核保证在任何进程中都将得到同样的 IPC 键值。
有了消息队列的IPC键值后，就是创建或者打开消息队列， 通过 msgget( ) 创建或打开一个消息队列， 其原型如下：
MSGGET() Linux Programmer’s Manual MSGGET()
NAME
msgget - get a message queue identifier SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h> int msgget( key_t key, //IPC 键值
int msgflg); //打开或者创建标志， 可以取值 IPC_CREAT
返回值：
如果成功，返回消息队列的ID号， 失败返回 -1。
创建了消息队列或者打开已经消息队列后，就需要完消息队列中添加消息，即发送消息； 发送消息通过函数 msgsnd( )
实现。
当发送完消息后，就可以从消息队列中获取消息，从消息队列中读取消息用函数 msgrcv( )实现。
原型如下：
MSGOP() Linux Programmer’s Manual MSGOP()
NAME
msgop - message operations
SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h> int msgsnd(int msqid, //消息队列ID
const void *msgp, //要发送的消息的消息结构体
size_t msgsz, //消息字符串的大小，或者消息结构的大小
int msgflg); // 消息标志 ssize_t msgrcv(int msqid, //消息队列ID
void *msgp, //接受消息的消息结构体指针
size_t msgsz, //消息结构体的大小
long msgtyp, //指定要接收到消息的类型
int msgflg); //消息标志
要发送或接收消息，还需要定义一个如下格式的结构体：
struct msgbuf {
long mtype; /* message type, must be > 0 */ //消息类型， 这个值必须大于 0
char mtext[]; /* message data */ //要发送的消息数据， 字符数组长度可以根据实际需要定义
};
消息队列使用完后，需要删除消息队列，通过 msgctl 函数实现，这是一个与ioctl 函数类似的函数，其原型如下：
MSGCTL() Linux Programmer’s Manual MSGCTL()
NAME
msgctl - message control operations
SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h> int msgctl(int msqid, //消息队列ID
int cmd, //操作命令， 操作命令有很多，删除消息队列用 IPC_RMID 命令
struct msqid_ds *buf); //输出参数，通过这个结构体可获取消息队列的状态信息，如果不需要获取
//消息队列的信息，那么就设置为NULL
返回值：
成功删除（cmd=IPC_RMID）返回0 ，失败返回-1.
Exp： 发送消息的源文件： msgsnd.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h> typedef struct
{
long type;
char data[];
}msgbuf; int main(void)
{
int ret;
key_t key;
int msgid;
msgbuf msg={
type: ,
data: "this is a message queue test.\n",
}; //获取键值
key=ftok("./msgsnd.c",);
if(- == key)
{
perror("ftok");
exit();
} //打开或创建一个消息队列
msgid=msgget(key,IPC_CREAT);
if(- == msgid )
{
perror("msgget");
exit();
} //发送消息
ret=msgsnd(msgid,&msg,sizeof(msgbuf),);
if(- == ret)
{
perror("msgsnd");
} return ;
}
接收消息的源代码文件： msgrcv.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h> typedef struct
{
long type;
char data[];
}msgbuf; int main(int argc,char* argv[])
{
int ret;
key_t key;
int msgid;
msgbuf msg; //获取键值
key=ftok("./msgsnd.c",);
if(- == key )
{
perror("ftok");
exit();
} //打开消息队列
msgid=msgget(key,);
if(- == msgid )
{
perror("msgget");
exit();
} //接收消息
ret=msgrcv(msgid, &msg, sizeof(msgbuf),,);
if(- == ret)
{
perror("msgrcv");
exit();
}
printf("the recive message is: %s",msg.data); //删除消息队列
msgctl(msgid,IPC_RMID,NULL); return ;
}
测试结果如下：
[root@localhost msg]# gcc msgsnd.c -o snd
[root@localhost msg]# gcc msgrcv.c -o rcv
[root@localhost msg]# ./snd
[root@localhost msg]# ./rcv
the recive message is: this is a message queue test.
[root@localhost msg]#
3、信号量
信号量主要用于两个进程间同步的，一般用于多进程间的同步操作。
例如当两个进程同时要访问声卡的时候，那么就需要控制声卡先由那个进程操作，等第一个进程操作完后，其他进程
才能进行操作； 但是为什么我们可以同时用mplayer 还能同时使用kmplyer播放音乐呢？ 从用户的角度来看，确实是这
样的，但是从硬件的角度来看，在某一时刻声卡就只能为一个应用层程序服务，当两个应用程序同时对声卡进行操作时就
会出现异常，为了防止这种异常，需要进行对两个进程进行控制，当有一个进程获取声卡的控制权后，另外的一个进程就
不能在同一时刻访问声卡，这就是互斥操作。（可以这样测试， 在windows的操作系统上安装VM虚拟机，打开windows
media player， 然后启动虚拟机（设置虚拟机在启动的时候自动挂载声卡设备），这时候声卡就会工作不正常，会出现
一小段时间的异常， 声音不正常，这就是出现两个应用程序同时使用声卡出现的异常）。
信号量就是为解决类似的问题而设计的，信号量用来控制应用程序在同一时刻对某一系统资源的访问（这个系统资源
也称作临界资源，访问临界资源的代码，也称作临界区代码）。
信号量用结构体 struct sembuf 描述，其定义如下：
/* semop system calls takes an array of these. */
struct sembuf {
unsigned short sem_num; /* semaphore index in array */ //信号量集合中的信号量索引值，即表示信号量集合中第几个信号量
short sem_op; /* semaphore operation */ //要对信号量进行的操作，=-1 表示信号量不可获取， =1 表示可以获取信号量
short sem_flg; /* operation flags */ //信号量标志
};
这里有一点需要说明： 通常对信号量进行操作分为 P操作、V操作，当设置 sem_op = -1 时表示进行P操作，
sem_op = 1 时表示要进行V操作。
和消息队列一样，要使用信号量，首先需要获取一个用于信号量到IPC键值， 用 ftok( ) 函数获取。 获取到用于
信号量到IPC键值后，还需要创建或者打开一个已经存在的信号量，通过打开或创建信号量获取一个关于信号量的
信号量ID；然后通过对信号量ID进行操作，就可以使用信号量。
通过semget（）函数创建或打开一个信号量，并获取关于信号量的ID； 原型如下：
SEMGET() Linux Programmer’s Manual SEMGET()
NAME
semget - get a semaphore set identifier //获取一个信号集合的ID SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h> int semget( key_t key, //IPC键值
int nsems, //信号量集合中信号量的个数， 要创建的信号量到个数
int semflg); //信号量的标志， 同OPEN的打开标志类似
在获取信号量集合ID后，需要对信号量进行一些设定（或者说信号量初始化），然后才能操作，通过函数 semctl( )对
信号量进行初始化操作； setctl( )的原型如下：
SEMCTL() Linux Programmer’s Manual SEMCTL()
NAME
semctl - semaphore control operations SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h> int semctl(int semid, //信号量集合ID
int semnum, //信号量集合中的信号量索引值
int cmd, //要对信号量进行的操作，可以使用的命名： IPC_SET、IPC_STAT、IPC_INFO、GETVAL、SETVAL......
...); //最后一个参数根据 操作的不同，可以传递，也可以不传递
返回值：
如果成功返回0 ，失败返回-1.（操作为 IPC_GETVAL， 成功返回信号量到值 ）。
SETVAL: 对信号量进行设置。 这时候，要传递4个参数， 最后一个可变参数，要定义一个类型如下：
union semun {
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO
(Linux specific) */
};
这是一个联合体类型，根据不同的操作命令，传递的值表示不同的意义。
可以通过 semop( )函数来操作信号量，其原型如下：
SEMOP() Linux Programmer’s Manual SEMOP() NAME
semop, semtimedop - semaphore operations SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h> int semop(int semid, //信号量集合ID
struct sembuf *sops, //信号量结构体指针
unsigned nsops); //表示要操作的信号量个数 int semtimedop(int semid, //信号量集合ID
struct sembuf *sops, //信号量结构体指针
unsigned nsops, //表示要操作的信号量个数
struct timespec *timeout); //表示超时等待时间，如果在超时时间内没有获取到可操作的信号量，就返回
Exp： 测试 信号量到代码，
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <fcntl.h>
#include <stdlib.h> int main(void)
{
int i;
int j;
int ret;
int fd;
pid_t pid;
key_t key;
int semid;
char buf[];
int size;
struct sembuf sembuf; /*sembuf=(struct sembuf*)malloc(sizeof (struct sembuf));*/
//打开文件，用来进行操作
fd=open("./test",O_RDWR | O_CREAT | O_TRUNC,);
if(- == fd)
{
perror("open");
exit();
} //IPC键值
key=ftok("./main.c",);
if(- == key)
{
perror("ftok");
exit();
} //获取信号量集合的ID
semid=semget(key,,IPC_CREAT);
if(- == semid )
{
perror("semget");
exit();
} //初始化信号量集合中的第一个信号量，设定信号量的值为0 ， sem.sem_op = 0;
ret=semctl(semid, , SETVAL, ); pid=fork();
if( pid== )
//----------------子进程------------
{
//信号量的P 操作， 即加锁信号量
sembuf.sem_num=;
sembuf.sem_op=-;
sembuf.sem_flg=;
semop(semid,&sembuf,); size=sprintf(buf,"pid=%d, ppid=%d\n",getpid(),getppid());
for(i=;i<;i++)
{
j=;
while(j<size)
{
ret=write(fd,&buf[j++], );
if(- == ret)
{
perror("write");
exit();
}
usleep();
}
}
//信号量的V操作，即解锁信号量
sembuf.sem_num=;
sembuf.sem_op=;
sembuf.sem_flg=;
semop(semid,&sembuf,); exit();
}//---------------子进程结束--------------------- //-----------------------父进程---------------
//信号量的P 操作， 即加锁信号量
sembuf.sem_num=;
sembuf.sem_op=-;
sembuf.sem_flg=;
semop(semid,&sembuf,); size=sprintf(buf,"pid=%d, ppid=%d\n",getpid(),getppid());
for(i=;i<;i++)
{
j=;
while(j<size)
{
ret=write(fd,&buf[j++], );
if(- == ret)
{
perror("write");
exit();
}
usleep();
}
} //信号量的V操作，即解锁信号量
sembuf.sem_num=;
sembuf.sem_op=;
sembuf.sem_flg=;
semop(semid,&sembuf,); semctl(semid,,IPC_RMID);
close(fd); return ;
}
代码执行后生成的test文件内容如下：
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
pid=, ppid=
如果将信号量的加锁和解锁取消， 代码如下：
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <fcntl.h>
#include <stdlib.h> int main(void)
{
int i;
int j;
int ret;
int fd;
pid_t pid;
key_t key;
int semid;
char buf[];
int size;
struct sembuf sembuf; /*sembuf=(struct sembuf*)malloc(sizeof (struct sembuf));*/
//打开文件，用来进行操作
fd=open("./test",O_RDWR | O_CREAT | O_TRUNC,);
if(- == fd)
{
perror("open");
exit();
} //IPC键值
key=ftok("./main.c",);
if(- == key)
{
perror("ftok");
exit();
} //获取信号量集合的ID
semid=semget(key,,IPC_CREAT);
if(- == semid )
{
perror("semget");
exit();
} //初始化信号量集合中的第一个信号量，设定信号量的值为0
ret=semctl(semid, , SETVAL, ); pid=fork();
if( pid== )
//----------------子进程------------
{
//信号量的P 操作， 即加锁信号量
sembuf.sem_num=;
sembuf.sem_op=-;
sembuf.sem_flg=;
/*semop(semid,&sembuf,1);*/ //取消信号量到作用 size=sprintf(buf,"pid=%d, ppid=%d\n",getpid(),getppid());
for(i=;i<;i++)
{
j=;
while(j<size)
{
ret=write(fd,&buf[j++], );
if(- == ret)
{
perror("write");
exit();
}
usleep();
}
}
//信号量的V操作，即解锁信号量
sembuf.sem_num=;
sembuf.sem_op=;
sembuf.sem_flg=;
/*semop(semid,&sembuf,1);*/ //取消信号量到作用 exit();
}//---------------子进程结束--------------------- //-----------------------父进程---------------
//信号量的P 操作， 即加锁信号量
sembuf.sem_num=;
sembuf.sem_op=-;
sembuf.sem_flg=;
/*semop(semid,&sembuf,1);*/ //取消信号量到作用 size=sprintf(buf,"pid=%d, ppid=%d\n",getpid(),getppid());
for(i=;i<;i++)
{
j=;
while(j<size)
{
ret=write(fd,&buf[j++], );
if(- == ret)
{
perror("write");
exit();
}
usleep();
}
} //信号量的V操作，即解锁信号量
sembuf.sem_num=;
sembuf.sem_op=;
sembuf.sem_flg=;
/*semop(semid,&sembuf,1);*/ //取消信号量到作用 semctl(semid,,IPC_RMID);
close(fd); return ;
}
生成的test文件内容如下：
ppiidd==,, ppppiidd== ppiidd==,, ppppiidd==
7p
ipdi=d2=, ,p ppipdi=d7=
3p7i
dp=i2d3=, 8p,p ipdp=i7d1=
3p3i7d
=p2i3d3=, 3p8p,i dp=p7i1d4=
可以发现两个进程同时访问一个文件，而没有互斥机制的话，就会出现乱码。因此在访问临界资源的时候，就需要
采用互斥机制。
4、共享内存
进程都具有自己的虚拟地址空间（即进程空间），进程A不能随意的访问进程B的进程空间； 内核提供了一种机制，
可以在物理内存中开辟一块存储空间，这块存储空间可供进程A或者进程B访问， 这样一块存储空间就是共享内存。
要使用共享内存也需要获取一个IPC键值，通过 ftok（）获取IPC键值。
获取到IPC键值后，就需要向系统申请共享的存储空间，通过函数 shmget( ) 申请共享空间，并获取关于共享内存的
ID标识符。 shmget（）的原型如下所示：
SHMGET() Linux Programmer’s Manual SHMGET()
NAME
shmget - allocates a shared memory segment
SYNOPSIS
#include <sys/ipc.h>
#include <sys/shm.h> int shmget(key_t key, //IPC 键值
size_t size, //要申请的内存空间的大小
int shmflg); //共享内存的空间打开标志 ，与 open 的打开标志类似，
返回值：
申请成功返回共享内存标识ID， 失败返回-。
申请成功后，还不能访问共享内存，因为访问内存需要知道内存的地址或者指针，所以就需要向系统申请返回
共享内存的地址或者指针。通过 shmmat( )向系统申请返回共享内存的首地址或者指针。其原型如下：
SHMOP() Linux Programmer’s Manual SHMOP()
NAME
shmop - shared memory operations
SYNOPSIS
#include <sys/types.h>
#include <sys/shm.h> void *shmat(int shmid, //共享内存标志ID
const void *shmaddr, //传递NULL，表示要系统分配存储缓冲区，传递地址表示指定地址
int shmflg); //打开标志， int shmdt(const void *shmaddr); //删除共享内存
返回值：
成功返回共享内存的首地址（虚拟地址），失败返回NULL。
在成功返回共享内存首地址后，就可以向访问用malloc 分配的内存一样进行操作。
Exp： 申请共享内存，并往共享内存写的文件 shm-w.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h> #define SHM_SIZE 128 int main(int argc,char* argv[])
{
key_t key;
int shm_id;
char* shm_p; //获取IPC 键值
key=ftok("./shm-w.c",);
if(- == key)
{
perror("ftok");
exit();
} //申请共享内存空间,大小为 SHM_SIZE
shm_id=shmget(key,SHM_SIZE,IPC_CREAT);
if(- == shm_id )
{
perror("shmget");
exit();
} //将申请的共享内存映射到用户空间
shm_p=shmat(shm_id,NULL,); //
if(NULL == shm_p )
{
perror("shmat");
exit();
} //将数据写入到共享内存 写入到数据可以在其他进程中读取
memset(shm_p,,SHM_SIZE);
strcpy(shm_p, "this is a sheard memmory.\n"); //这个函数不安全，需要注意 return ;
} 从共享内存中读取数据的文件 shm-r.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h> #define SHM_SIZE 128 int main(int argc,char* argv[])
{
key_t key;
int shm_id;
char* shm_p;
char buf[SHM_SIZE]; //获取IPC 键值
key=ftok("./shm-w.c",);
if(- == key)
{
perror("ftok");
exit();
} //申请共享内存空间,大小为 SHM_SIZE
shm_id=shmget(key,SHM_SIZE,IPC_CREAT);
if(- == shm_id )
{
perror("shmget");
exit();
} //将申请的共享内存映射到用户空间
shm_p=shmat(shm_id,NULL,); //
if(NULL == shm_p )
{
perror("shmat");
exit();
} //从共享内存读取数据
memset(buf,,SHM_SIZE);
strcpy(buf, shm_p); //这个函数不安全，需要注意
printf("the data read from sheard memory is: %s",buf); shmdt(shm_p); //申请撤销共享内存
return ;
}
程序执行的效果如下：
[root@localhost shm]# gcc shm-w.c -o shmw
[root@localhost shm]# gcc shm-r.c -o shmr
[root@localhost shm]# ./shmw
[root@localhost shm]# ./shmr
the data read from sheard memory is: this is a sheard memmory.
[root@localhost shm]#
【Linux草鞋应用编程系列】_3_进程间通信
本系列文章未完，待续。
如果查看的过程中发现错误，请不吝指教，包括错别字、标点符号等。
【linux草鞋应用编程系列】_3_ 进程间通信的更多相关文章
- 【linux草鞋应用编程系列】_4_ 应用程序多线程
一.应用程序多线程 当一个计算机上具有多个CPU核心的时候,每个CPU核心都可以执行代码,此时如果使用单线程,那么这个线程只能在一个 CPU上运行,那么其他的CPU核心就处于空闲状态,浪费了系 ...
- 【linux草鞋应用编程系列】_1_ 开篇_系统调用IO接口与标准IO接口
最近学习linux系统下的应用编程,参考书籍是那本称为神书的<Unix环境高级编程>,个人感觉神书不是写给草鞋看的,而是 写给大神看的,如果没有一定的基础那么看这本书可能会感到有些头重脚轻 ...
- 【linux草鞋应用编程系列】_6_ 重定向和VT100编程
一.文件重定向 我们知道在linux shell 编程的时候,可以使用文件重定向功能,如下所示: [root@localhost pipe]# echo "hello world&q ...
- 【linux草鞋应用编程系列】_5_ Linux网络编程
一.网络通信简介 第一部分内容,暂时没法描述,内容实在太多,待后续专门的系列文章. 二.linux网络通信 在linux中继承了Unix下“一切皆文件”的思想, 在linux中要实现网 ...
- 【linux草鞋应用编程系列】_2_ 环境变量和进程控制
一. 环境变量 应用程序在执行的时候,可能需要获取系统的环境变量,从而执行一些相应的操作. 在linux中有两种方法获取环境变量,分述如下. 1.通过main函数的参数获取环境变量 ...
- Linux C++ 网络编程学习系列（1）——端口复用实现
Linux C++ 网络编程学习系列(1)--端口复用实现 源码地址:https://github.com/whuwzp/linuxc/tree/master/portreuse 源码说明: serv ...
- 《Linux/Unix系统编程手册》读书笔记3
<Linux/Unix系统编程手册>读书笔记 目录 第6章 这章讲进程.虚拟内存和环境变量等. 进程是一个可执行程序的实例.一个程序可以创建很多进程. 进程是由内核定义的抽象实体,内核为此 ...
- Linux下的编程实战【转】
一篇比较不错的文章, 降到了 makefile make , gcc编译器,GDB调试器, Linux文件系统,Linux文件API,.C语言库函数(C库函数的文件操作实际上是独立于具体的操作系统平台 ...
- Linux 高性能服务器编程——多进程编程
问题聚焦: 进程是Linux操作系统环境的基础. 本篇讨论以下几个内容,同时也是面试经常被问到的一些问题: 1 复制进程映像的fork系统调用和替换进程映像的exec系列系统调 ...
随机推荐
- MySQL 启动服务报错解决方案
标签:ERROR! The server quit without updating PID file (/var/lib/mysql/localhost.localdomain.pid) 概述 文章 ...
- 辛巴学院-Unity-剑英陪你零基础学c#系列(四)函数和封装
辛巴学院:正大光明的不务正业. 国庆长假结束了,我的心情是这样的: 你总是起不早,起不早独自一个人沉睡到天亮你无怨无悔的梦着那副本我知道你根本就不想上班你总是起不早,起不早放假总是短暂,上班太难请个病 ...
- springboot之HelloWorld
简介 为了简化开发Spring的复杂度,Spring提供了SpringBoot可以快速开发一个应用,这里就简单介绍下SpringBoot如何快速开发一个J2EE应用 HelloWorld 首先在gra ...
- 【原】Python用例：将指定文件或目录打包成zip文件
#This Demo is used to compress files to .zip file #Base on Windows import os import time #The files ...
- 单独使用jdbc编程问题总结（一）
在学习Mybatis之前,我们先来回顾JDBC编程的相关知识.在此基础上深入的学习Mybatis框架.如有错误,敬请指正. (一)首先我们既然要使用jdbc,当然是要操作数据库了.创建一个名为:myb ...
- 【PRINCE2是什么】PRINCE2认证之七大原则（3）
我们先来回顾一下,PRINCE2七大原则分别是持续的业务验证,经验学习,角色与责任,按阶段管理,例外管理,关注产品,剪裁. 第三个原则:明确定义的角色和职责. 项目离不开人员,错误的人来了,合适的人没 ...
- Android开发学习之路-二维码学习
这个月装逼有点少了,为什么呢,因为去考软件射鸡师了,快到儿童节了,赶紧写篇博纪念一下逝去的青春,唔,请忽略这句话. 二维码其实有很多种,但是我们常见的微信使用的是一种叫做QRCode的二维码,像下面这 ...
- MonogDB初探增加和删除
1.插入并保存文档 在插入数据之前,首先用mongodb Shell命令db.baseUser.find() 查找集合的数据. 想必大家能猜到结果,什么东西都没有,那接着来说说怎 ...
- Java 的设计模式之一装饰者模式
刚开始接触装饰者的设计模式,感觉挺难理解的,不够后来花了一个晚上的时间,终于有头绪了 装饰者设计模式:如果想对已经存在的对象进行装饰,那么就定义一个类,在类中对已经有的对象进行功能的增强或添加另外的行 ...
- Spill data to tempdb
查看Execution Plan时,在Sort Operator上,发现一个Warning:Operator used tempdb to spill data during execution wi ...