[转自: http://blog.csdn.net/Paradise_for_why/article/details/5550619]

这一章就是著名的IPC,这个东西实际的作用和它的名字一样普及。例如我们浏览网页,打印文章,等等。

IPC总共有五种类型:

  1. 共享内存(Shared Memory):最容易理解的一种,就像一个特工把情报放在特定地点(内存),另一个特工再过来取走一样。

  2. 内存映射(Mapped Memory):和共享内存几乎相同,除了特工们把地点从内存改成了文件系统。

  3. 管道(Pipes):从一个进程到另一个进程的有序通信,用电话来比喻再恰当不过了。

  4. FIFOs:和管道和类似,唯一的区别是FIFOs比管道更神通一些,允许没有关系的进程之间的有序通信。

  5. 套接字(Sockets):为什么说浏览网页也是IPC?就是因为它。

5.1 共享内存(Shared Memory)

  • 共享内存是最快捷的进程间通信方式。访问共享内存的效率和访问进程自己的非共享内存的效率是相同的,而且这种通信方式不需要任何额外的系统调用。
  • 系统不会自动为共享内存处理同步问题,这个问题必须由用户自己解决。
  • 共享内存的步骤通常是:
    • 一个进程申请一块共享内存,即在它的页表中加入新的一项
    • 所有进程Attach该共享内存,即从申请内存的进程中拷贝对应的页表
    • 使用该内存进行通讯
    • 结束后所有进程detach该共享内存
    • 申请共享内存的进程在确定所有进程都detach后,释放该内存
  • 由于共享内存是通过页表来实现的,我们可以得出一个结论:共享内存的大小是页面大小的整数倍,页面的大小可以通过getpagesize()来得到,通常在Linux下该值是4KB
  • 相关的API函数:
    • 申请共享内存:shmget,返回共享内存segment的id
    • Attach,Detach函数:shmat,shmdt。需要共享内存segment的id
    • 释放申请的内存:shmctl。一定要记得释放!调用exit和exec会自动detach,但不会自动释放。
  • 使用 ipcs -m来观看当前系统存在的共享内存

  例子:原程序链接,依据这个例子进行简单修改一下

 /*
* =============================================================================
*
* Filename: sharememory_read.c
*
* Description:
*
* Version: 1.0
* Created: 2014年11月04日 19时52分28秒
* Revision: none
* Compiler: gcc
*
* Author: lwq (28120), scue@vip.qq.com
* Organization:
*
* =============================================================================
*/
#include <stdlib.h> /**********************************************************
*实验要求: 创建两个进程,通过共享内存进行通讯。
*功能描述: 本程序申请和分配共享内存,然后轮训并读取共享中的数据,直至
* 读到“end”。
*日 期: 2010-9-17
*作 者: 国嵌
**********************************************************/
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <getopt.h>
#include "sharememory.h" void read_shm(struct shared_use_st *shared_stuff);
void write_shm(struct shared_use_st *shared_stuff);
void del_shm(); void usage(){
fprintf(stderr, "\nusage: %s -r|-w\n\n"
"-r read mode\n"
"-w write mode\n"
"\n", "shared_memory");
exit();
} #define READ (1)
#define WRITE (2)
#define OPTNONE (0) // 全局变量
void *shared_memory=(void *); /*
* 程序入口
* */
int main(int argc, char **argv)
{
int running=RUNNING;
struct shared_use_st *shared_stuff;
int shmid;
int operation=OPTNONE; /* 读/写操作 */ /*-----------------------------------------------------------------------------
* getopt start
*----------------------------------------------------------------------------*/
int choice;
while ()
{
static struct option long_options[] =
{
/* Use flags like so:
{"verbose", no_argument, &verbose_flag, 'V'}*/
/* Argument styles: no_argument, required_argument, optional_argument */
{"version", no_argument, , 'v'},
{"help", no_argument, , 'h'},
{"read", no_argument, , 'r'},
{"write", no_argument, , 'w'},
{,,,}
}; int option_index = ; /* Argument parameters:
no_argument: " "
required_argument: ":"
optional_argument: "::" */ choice = getopt_long( argc, argv, "vhrw",
long_options, &option_index); if (choice == -)
break; switch( choice )
{
case 'v': break; case 'h':
usage();
break; case 'r':
operation=READ;
break; case 'w':
operation=WRITE;
break; case '?':
/* getopt_long will have already printed an error */
usage();
break; default:
/* Not sure how to get here... */
return EXIT_FAILURE;
}
}
if (operation == OPTNONE) {
usage();
}
/*-----------------------------------------------------------------------------
* getopt end
*----------------------------------------------------------------------------*/ /*创建共享内存*/
shmid=shmget((key_t),sizeof(struct shared_use_st),|IPC_CREAT);
if(shmid==-) {
fprintf(stderr,"shmget failed\n");
exit(EXIT_FAILURE);
} /*映射共享内存*/
shared_memory=shmat(shmid,(void *),);
if(shared_memory==(void *)-) {
fprintf(stderr,"shmat failed\n");
exit(EXIT_FAILURE);
} printf("Memory attached at 0%08x\n",(int)((intptr_t)shared_memory)); /*让结构体指针指向这块共享内存*/
shared_stuff=(struct shared_use_st *)shared_memory; /*控制读写顺序*/
// lwq: 使之能读取上一条消息
if (operation == READ && shared_stuff->written_by_you != HADWROTE)
shared_stuff->written_by_you=HADREAD; switch(operation) {
case READ:
read_shm(shared_stuff);
break; case WRITE:
write_shm(shared_stuff);
break; default:
usage();
break;
} del_shm();
exit(EXIT_SUCCESS);
} // 读取共享内存
void read_shm(struct shared_use_st *shared_stuff){
while() {
if(shared_stuff->written_by_you == HADWROTE) {
printf("You wrote:%s",shared_stuff->some_text);
shared_stuff->written_by_you=HADREAD;
if(strncmp(shared_stuff->some_text,"end",)==) {
break;
}
}
else {
usleep();
}
}
} // 写入共享内存
void write_shm(struct shared_use_st *shared_stuff){
char buffer[BUFSIZ] = {};
while() {
while(shared_stuff->written_by_you!=HADREAD); /* 等待读写完成 */
printf("Enter some text:");
fgets(buffer,BUFSIZ,stdin);
strncpy(shared_stuff->some_text,buffer,TEXT_SZ); /* 复制进去 */
shared_stuff->written_by_you=HADWROTE;
if(strncmp(buffer,"end",)==) {
break;
}
}
} // 删除共享内存
void del_shm(){
/*删除共享内存*/
if(shmdt(shared_memory)==-) {
fprintf(stderr,"\nshmdt failed\n");
exit(EXIT_FAILURE);
}
else {
fprintf(stderr, "\ndelete shared_memory: 0x%08x\n", (int)((intptr_t)shared_memory));
}
}

sharememory.c

  编译:gcc sharememory.c -o sharememory

  执行:

    1. 以读取模式打开程序(进程1): ./sharememory -r

    2. 以写入模式打开程序(进程2): ./sharememory -w

  更新介绍:http://www.cs.cf.ac.uk/Dave/C/node27.html

5.2 进程信号量

  • 信号量(Semaphore)的概念前面已经介绍过了。Linux对用来同步进程的信号量采取了一种特别的实现方式。这些信号量也就被称为进程信号量(Process Semaphore)。(这一节下面所提到的所有信号量默认都是指进程信号量)
  • 相关的API函数:
    • 申请:semget
    • 释放:semctl。需要注意的是信号量不会被自动释放,我们必须显式释放它。
    • Wait和Post:semop
  • 使用ipcs -s来观看当前系统存在的信号量

  例子:原程序链接

 /*
* =============================================================================
*
* Filename: semaphore_simple.c
*
* Description:
*
* Version: 1.0
* Created: 2014年11月04日 21时21分25秒
* Revision: none
* Compiler: gcc
*
* Author: lwq (28120), scue@vip.qq.com
* Organization:
*
* =============================================================================
*/
#include <stdlib.h> #include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sem.h> union semun
{
int val;
struct semid_ds *buf;
unsigned short *arry;
}; static int sem_id = ; static int set_semvalue();
static void del_semvalue();
static int semaphore_p();
static int semaphore_v(); int main(int argc, char *argv[])
{
char msg[] = {};
int i = ;
int mypid=getpid(); //创建信号量
sem_id = semget((key_t), , | IPC_CREAT); if(argc > )
{
//程序第一次被调用,初始化信号量
if(!set_semvalue()) {
fprintf(stderr, "Failed to initialize semaphore\n");
exit(EXIT_FAILURE);
}
}
for(i = ; i < ; ++i) {
//进入临界区
if(!semaphore_p())
exit(EXIT_FAILURE);
//向屏幕中输出数据
snprintf(msg, sizeof(msg)-, "%s, index: %03d, pid: %05d", argv[], i, mypid);
printf("%s\n", msg);
fflush(stdout);
usleep();
//离开临界区,休眠随机时间后继续循环
if(!semaphore_v())
exit(EXIT_FAILURE);
} if(argc > )
{
//如果程序是第一次被调用,则在退出前删除信号量
sleep();
del_semvalue();
}
exit(EXIT_SUCCESS);
} static int set_semvalue()
{
//用于初始化信号量,在使用信号量前必须这样做
union semun sem_union; sem_union.val = ;
if(semctl(sem_id, , SETVAL, sem_union) == -)
return ;
return ;
} static void del_semvalue()
{
//删除信号量
union semun sem_union; if(semctl(sem_id, , IPC_RMID, sem_union) == -)
fprintf(stderr, "Failed to delete semaphore\n");
} static int semaphore_p()
{
//对信号量做减1操作,即等待P(sv)
struct sembuf sem_b;
sem_b.sem_num = ;
sem_b.sem_op = -;//P()
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id, &sem_b, ) == -)
{
fprintf(stderr, "semaphore_p failed\n");
return ;
}
return ;
} static int semaphore_v()
{
//这是一个释放操作,它使信号量变为可用,即发送信号V(sv)
struct sembuf sem_b;
sem_b.sem_num = ;
sem_b.sem_op = ;//V()
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id, &sem_b, ) == -)
{
fprintf(stderr, "semaphore_v failed\n");
return ;
}
return ;
}

semaphore_simple.c

  编译:gcc semaphore_simple.c -o semaphore_simple

  执行:./semaphore_simple XXX &; ./semaphore_simple YYY

5.3 内存映射

  • 内存映射使得不同的进程可以通过一个共享文件来互相通信。
  • 相关的API函数:
    • 映射:mmap
    • 同步:msync。用来指定对文件的修改是否被buffer。
    • 释放:munmap。在程序结束的时候会自动unmap
  • mmap的其他用法:
    • 可以替代read和write,有时使用内存映射后的效率比单纯使用I/O操作来的更快
    • 在内存映射文件中构建structure,修改structure再次将文件映射到内存中可以快速的将structure恢复到原来的状态
    • 把/dev/zero文件映射到内存中。该文件可以提供无限的0,并且写到该文件的所有内容将被直接丢弃

5.4 管道(Pipes)

  • 管道是单向的,即一个线程写,另一个线程读,无法互换
  • 如果写的速度太快,造成管道满了,那么写的线程就会被block;如果读的速度太快,造成管道空了,那么读的进程就会被block。因此事实上我们可以说管道自动实现了同步机制
  • 我们可以通过调用pipe函数来生成一对pipe file description。(为什么是一对?因为一个读一个写)。可是,生成的pipe file description无法传送给不相关的进程(因为做为file descriptor即使它拿到了也没法用)。但是我们注意到fork之后父进程所有的file descriptor在子进程中依然有效,因此管道最大的作用是在父子进程之间通信。或者更确切的说,是在有共同祖先的进程之间通信。
  • 典型的创建管道的流程如下:
    • 用pipe生成2个pipe file description(简称fds)。然后调用fork
    • 在父进程关闭fds[0](或fds[1]),并以只读(或只写)方式打开fds[1](或fds[0])。在子进程中关闭fds[1](或fds[0]),并以只写(或只读)方式打开fds[0](或fds[1])。打开的函数是fdopen。
    • 开始通信。结束后用close函数关闭剩下的fds。
  • 这里有一个技巧:可以利用管道来达成重定向stdin, stdout和stderr。注意到dup2这个API可以把一个file descriptor复制到另一个上。
  • 事实上,我们有一对更为简洁的函数popen/pclose来完成上面的一系列复杂的操作。popen有两个参数:
    • 第一个参数接受一个exec,子进程将执行这个exec
    • 第二个参数为”w”或者”r”,”w”表示父进程写子进程读,”r”则反之
    • 返回值为管道的一端,也就是一个file descriptor
    • pclose用来关闭popen返回的file descriptor
  • FIFO(First In First Out)文件事实上是一个有名字的管道,换句话说,他可以用来让“不相干”的程序互相通信。
    • 我们使用mkfifo函数来创建一个FIFO文件
    • 我们可以使用任何的低级I/O函数(open, write, read, close等)以及C库I/O函数(fopen, fprintf, fscanf, fclose等)来操作FIFO文件。
  • Linux的管道和Windows下的命名管道(Named Pipes)的区别
    • Windows的命名管道更像一个套接字(sockets),它可以通过网络让不同主机上的程序进行通信
    • Linux的管道允许有多个reader和writer,每个reader和writer进行读/写的最大容量为 PIPE_BUF(4KB),如果有多个writer同时写,他们写的东西会被分为一个一个的chunk(每个4KB)并允许交错写。(例如进程A有两个 chunk,A1,A2。进程B也有两个chunk,B1,B2。A和B同时写,则顺序可能为A1,B1,A2,B2) Windows的管道允许在同一个管道上有多个reader/writer对,他们之间读写的数据没有交叉。

5.5 套接字(Sockets)

  • 套接字的特点:

    • 它是双向通信的
    • 它是进程间通信的,包括其他机器上的进程
  • 套接字有三个参数:
    • 通讯类型(communication style)

      • 连接(connection)类型:保证所有的包按发送的顺序到达接受方。(类似于电话)如果包丢失或者抵达顺序错误,会自动重发。
      • datagram类型:所有包单独发送,可能会出现丢失或者晚发早到的现象。(类似于邮寄)
    • 命名空间(namespace):描述套接字的地址是如何表示的,例如本地就是文件名,internet上就是ip地址。
    • 协议(protocol):通讯协议,常用的有TCI/IP,AppleTalk等。
  • 相关的API(套接字也是通过file descriptor来表示的):
    • socket:创建一个socket
    • closes:销毁一个socket
    • connect:在两个socket之间创建一个连接。这个API通常由客户端调用。
    • bind:给服务器的一个套接字绑定一个地址,服务器端调用。
    • listen:让一个套接字开始侦听,准备接受请求,服务器端调用。
    • accept:接受一个连接请求,并且为该连接创建一个新的套接字,服务器端调用。
  • 服务器端的生命流程:
    • 创建一个connection类型的socket
    • 给该socket绑定一个地址
    • 调用listen来enable该socket(listen可以指定最多有多少个请求在等待队列中,如果等待队列满了,又有新的请求到达的时候,则该请求被拒绝)
    • 对于收到的连接请求调用accept来接受
    • 关闭socket
  • 本地socket(local socket)
    • 如果是同一台电脑上的两个进程需要通信的话,可以使用本地socket。这种情况下socket的地址是文件路径。注意进程必须对该路径拥有可写权限,否则无法建立连接
    • 完成之后使用unlink来关闭一个socket

〖Linux〗Linux高级编程 - 进程间通信(Interprocess Communication)的更多相关文章

  1. Linux环境高级编程--介绍

    从今天開始.将开启Linux环境高级编程(Advanced Programming Of Linux Enviroment)的学习笔记或者说总结,我将持续和大家分享自己的学习成果.本系列博客依托于li ...

  2. Linux C高级编程——文件操作之系统调用

    Linux C高级编程文件操作之系统调用 宗旨:技术的学习是有限的,分享的精神是无限的.           库函数是一些完毕特定功能的函数.一般由某个标准组织制作公布,并形成一定的标准.使用库函数编 ...

  3. linux 之进程间通信-------------InterProcess Communication

    进程间通信至少可以通过传送打开文件来实现,不同的进程通过一个或多个文件来传递信息,事实上,在很多应用系统里,都使用了这种方法.但一般说来,进程间 通信(IPC:InterProcess Communi ...

  4. Linux C高级编程——网络编程基础(1)

    Linux高级编程--BSD socket的网络编程 宗旨:技术的学习是有限的,分享的精神是无限的. 一网络通信基础 TCP/IP协议簇基础:之所以称TCP/IP是一个协议簇,是由于TCP/IP包括T ...

  5. Linux C高级编程——网络编程之以太网(2)

    Linux网络编程--以太网 宗旨:技术的学习是有限的,分享的精神是无限的. 1.以太网帧格式 源地址和目的地址是指网卡的硬件地址(也叫MAC地址),长度是48位,是在网卡出厂时固化的.用ifconf ...

  6. Linux Shell 高级编程技巧3----运行级别脚本介绍

    3.运行级别脚本介绍    3.1.运行级别        运行级别介绍:            0    关机            1    单用户模式            2    多用户模式 ...

  7. Linux Shell 高级编程技巧4----几个常用的shell脚本例子

    4.几个常用的shell脚本例子    4.0.在写脚本(同样适用在编程的时候),最好写好完善的注释    4.1.kill_processes.sh(一个杀死进程的脚本) #!/bin/bash c ...

  8. linux下socket编程-进程间通信

    一.什么是Socket Socket接口是TCP/IP网络通信的API,Socket接口定义了许多函数或例程,可以用它们来开发TCP/IP网络上的应用程序. Socket类型有两种:流式Socket ...

  9. Linux Shell 高级编程技巧2----shell工具

    2.shell工具    2.1.日志文件        简介            创建日志文件是很重要的,记录了重要的信息.一旦出现错误,这些信息对于我们排错是非常有用的:监控的信息也可以记录到日 ...

随机推荐

  1. 关于mysql中information_schema.tables

    项目中出现这样一个SQL语句,现记录如下: @Select("select table_name tableName, engine, table_comment tableComment, ...

  2. [Web 前端] CSS篇之 4. position 和 display 的取值和各自的意思和用法

    讲一讲CSS的position/float/display都有哪些取值,它们相互叠加时的行为都是什么?  列出display的值,说明他们的作用.position的值, relative和absolu ...

  3. 自适应尺寸变化的meanshift跟踪

    近期在看meanshift方面的文章,看了一篇博文对这篇文章<Robust scale-adaptive meanshift for tracking>寄予非常高的评价,所以把这篇文章简要 ...

  4. [数学] 将长为L的木棒随机折成3段,则3段构成三角形的概率

    1.题目 如题,将长为L的木棒随机折成3段,则3段构成三角形的概率是多少? 2.解析 这个与其说是编程题目,倒不如说是个数学题目.可能是你没有见过,或者没有过这种解题思想.(还是那句,一回生两回熟,类 ...

  5. 《UNIX环境高级编程》笔记--环境变量

    ISO C定义了一个函数getenv,可以用其取环境变量值. #include <stdlib.h> char* getenv(const char* name); //返回与name关联 ...

  6. go语言之进阶篇定时器Timer的使用

    1.Timer的使用 示例: #创建一个定时器,设置时间为2s,2s后,往time通道写内容(当前时间) package main import ( "fmt" "tim ...

  7. Service 简介 启动方式 生命周期 MD

    Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina ...

  8. SpringBoot-Mybatis_Plus学习记录之公共字段自动填充

    一.应用场景 平时在建对象表的时候都会有最后修改时间,最后修改人这两个字段,对于这些大部分表都有的字段,每次在新增和修改的时候都要考虑到这几个字段有没有传进去,很麻烦.mybatisPlus有一个很好 ...

  9. C#,深入浅出全接触(一)

    一.什么是 C#? C# 是由Microsoft开发的一种新型编程语言,由于它是从C和C++ 中派生出来的,因此具有C++的功能.同时,由于是Microsoft公司的产品,它又同 VB一样简单.对于w ...

  10. 交互软件Axure—高保真原型

    在上一篇文章中跟大家分享了Axure7.0 的简介.基本操作和原型图的制作,主要是应用元件库里的原件进行界面元素的搭建,直至完成原型图,在最后给大家展示了高保真原型图效果.而在本次分享中,主要带领大家 ...