linux共享内存通信

❶ linux进程间通信的方式有哪些

第一种：管道通信
两个进程利用管道进行通信时，发送信息的进程称为写进程;接收信息的进程称为读进程。管道通信方式的中间介质就是文件，通常称这种文件为管道文件，它就像管道一样将一个写进程和一个读进程连接在一起，实现两个进程之间的通信。写进程通过写入端往管道文件中写入信息;读进程通过读出端从管道文件中读取信息。两个进程协调不断地进行写和读，便会构成双方通过管道传递信息的流水线。
第二种：消息缓冲通信
多个独立的进程之间可以通过消息缓冲机制来相互通信。这种通信的实现是以消息缓冲区为中间介质，通信双方的发送和接收操作均以消息为单位。在存储器中，消息缓冲区被组织成队列，通常称之为消息队列。消息队列一旦创建后即可由多进程共享，发送消息的进程可以在任意时刻发送任意个消息到指定的消息队列上，并检查是否有接收进程在等待它所发送的消息。若有则唤醒它，而接收消息的进程可以在需要消息的时候到指定的消息队列上获取消息，如果消息还没有到来，则转入睡眠等待状态。
第三种：共享内存通信
针对消息缓冲需要占用CPU进行消息复制的缺点，OS提供了一种进程间直接进行数据交换的通信方式。共享内存，顾名思义这种通信方式允许多个进程在外部通信协议或同步，互斥机制的支持下使用同一个内存段进行通信，它是一种最有效的数据通信方式，其特点是没有中间环节，直接将共享的内存页面通过附接映射到相互通信的进程各自的虚拟地址空间中，从而使多个进程可以直接访问同一个物理内存页面。

❷ 架构师进阶：Linux进程间如何共享内存

共享内存 IPC 原理
共享内存进程间通信机制主要用于实现进程间大量的数据传输，下图所示为进程间使用共享内存实现大量数据传输的示意图：

640

共享内存是在内存中单独开辟的一段内存空间，这段内存空间有自己特有的数据结构，包括访问权限、大小和最近访问的时间等。该数据结构定义如下：

from /usr/include/linux/shm.h
struct shmid_ds {
struct ipc_perm shm_perm; /* operation perms 操作权限 */
int shm_segsz; /* size of segment (bytes) 段长度大小 */
__kernel_time_t shm_atime; /* last attach time 最近attach时间 */
__kernel_time_t shm_dtime; /* last detach time 最近detach时间 */
__kernel_time_t shm_ctime; /* last change time 最近change时间 */
__kernel_ipc_pid_t shm_cpid; /* pid of creator 创建者pid */
__kernel_ipc_pid_t shm_lpid; /* pid of last operator 最近操作pid */
unsigned short shm_nattch; /* no. of current attaches */
unsigned short shm_unused; /* compatibility */
void *shm_unused2; /* ditto - used by DIPC */
void *shm_unused3; /* unused */|
};
两个进程在使用此共享内存空间之前，需要在进程地址空间与共享内存空间之间建立联系，即将共享内存空间挂载到进程中。

系统对共享内存做了以下限制：

#define SHMMAX 0x2000000 /* max shared seg size (bytes) 最大共享段大小 */

#define SHMMIN 1 /* min shared seg size (bytes) 最小共享段大小 */

#define SHMMNI 4096 /* max num of segs system wide */

#define SHMALL (SHMMAX/getpagesize()*(SHMMNI/16))|

define SHMSEG SHMMNI /* max shared segs per process */

Linux 共享内存管理
1.创建共享内存

#include <sys/ipc.h> #include <sys/shm.h>
/*
* 第一个参数为 key 值，一般由 ftok() 函数产生
* 第二个参数为欲创建的共享内存段大小(单位为字节)
* 第三个参数用来标识共享内存段的创建标识
*/

int shmget(key_t key, size_t size, int shmflg);
2.共享内存控制

#include <sys/ipc.h> #include <sys/shm.h>
/*
* 第一个参数为要操作的共享内存标识符
* 第二个参数为要执行的操作
* 第三个参数为 shmid_ds 结构的临时共享内存变量信息
*/

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
3.映射共享内存对象

系统调用 shmat() 函数实现将一个共享内存段映射到调用进程的数据段中，并返回内存空间首地址，其函数声明如下：

#include <sys/types.h>

#include <sys/shm.h>
/*
* 第一个参数为要操作的共享内存标识符
* 第二个参数用来指定共享内存的映射地址，非0则为此参数，为0的话由系统分配
* 第三个参数用来指定共享内存段的访问权限和映射条件
*/

void *shmat(int shmid, const void *shmaddr, int shmflg);
4.分离共享内存对象

在使用完毕共享内存空间后，需要使用 shmdt() 函数调用将其与当前进程分离。函数声明如下：

#include <sys/types.h>

#include <sys/shm.h>
/*
* 参数为分配的共享内存首地址
*/

int shmdt(const void *shmaddr);

共享内存在父子进程间遵循的约定
1.使用 fork() 函数创建一个子进程后，该进程继承父亲进程挂载的共享内存。

2.如果调用 exec() 执行一个新的程序，则所有挂载的共享内存将被自动卸载。

3.如果在某个进程中调用了 exit() 函数，所有挂载的共享内存将与当前进程脱离关系。

程序实例
申请一段共享内存，父进程在首地址处存入一整数，子进程读出。

#include

#include <sys/ipc.h>

#include <sys/shm.h>

#include <sys/types.h>

#include

#include

#define SHM_SIZE 1024

int main()

{

int shm_id, pid;

int *ptr = NULL;
/* 申请共享内存 */

shm_id = shmget((key_t)1004, SHM_SIZE, IPC_CREAT | 0600);
/* 映射共享内存到进程地址空间 */

ptr = (int*)shmat(shm_id, 0, 0);

printf("Attach addr is %p ", ptr);

*ptr = 1004;

printf("The Value of Parent is : %d ", *ptr);

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

perror("fork Err");

exit(0);

}

else if(!pid){
printf("The Value of Child is : %d ", *ptr);
exit(0);
}else{
sleep(1);
/* 解除映射 */

shmdt(ptr);
/* 删除共享内存 */

shmctl(shm_id, IPC_RMID, 0);
}
return 0;
}
输出结果：

640

❸ LINUX 信号量共存 共享内存通信

/***Msginput.c***/
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>
#include"Mysem.h"

int main(){
FILE *fp;
int empty;
int full;
int mutex;
char * shm;
int shmid;
fp = fopen("shmid","r");
fread(&shmid,sizeof(int), 1, fp);
fread(&empty,sizeof(int), 1, fp);
fread(&full,sizeof(int), 1, fp);
fread(&mutex,sizeof(int), 1, fp);

fclose(fp);
shm = shmat(shmid, NULL, 0);

while(1){

P(&empty);
P(&mutex);

scanf("%s", shm);

if(strcmp(shm, "END") == 0){

V(&mutex);
V(&full);
break;
}

V(&mutex);
V(&full);

}
return 0;
}

/****Mysem.c*****/
#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/shm.h>

#include<sys/sem.h>

#include<unistd.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include "Mysem.h"

#define BUFFER_SIZE 512

int main(){

char *shm;

int empty;

int full;

int mutex;

int shmid;

int pid;

int i;

FILE *fp;

// int init_sem_value = 0;

empty = semget(IPC_PRIVATE, 1, (0600|IPC_CREAT));

if(empty == -1){

perror("semget");

exit(1);

}

if(semctl(empty, 0, SETVAL, 1)<0){

perror("semctl");

exit(1);

}

full = semget(IPC_PRIVATE, 1, (0600|IPC_CREAT));

if(full == -1){

perror("semget");

exit(1);

}

if(semctl(full, 0, SETVAL, 0)<0){

perror("semctl");

exit(1);

}

mutex = semget(IPC_PRIVATE, 1, (0600|IPC_CREAT));

if(mutex == -1){

perror("semget");

exit(1);

}

if(semctl(mutex, 0, SETVAL, 1)<0){

perror("semctl");

exit(1);

}

shmid = shmget(IPC_PRIVATE, (BUFFER_SIZE*sizeof(char)),(IPC_CREAT|0600));

if(shmid == -1){

perror("shmget");

exit(1);

}

shm = shmat(shmid, NULL, 0);

if(shm == (char*)-1){

perror("shmat");

exit(1);

}

fp = fopen("shmid","w");

fwrite(&shmid, sizeof(int), 1, fp);

fwrite(&empty, sizeof(int), 1, fp);

fwrite(&full, sizeof(int), 1, fp);

fwrite(&mutex, sizeof(int), 1, fp);

fclose(fp);

pid = fork();

if(pid == 0){

execlp("./Msginput", "./Msginput",0);

perror("execlp");

exit(1);

}else{

while(1){

P(&full);

P(&mutex);

printf("%s\n", shm);

if(strcmp(shm,"END") == 0){

V(&mutex);

V(&empty);

break;

}

V(&mutex);

V(&empty);

}

}

wait(0);

if(semctl(full, 0, IPC_RMID, 1) == -1){

perror("semctl");

exit(1);

}

if(semctl(empty, 0, IPC_RMID, 1) == -1){

perror("semctl");

exit(1);

}

if(semctl(mutex, 0, IPC_RMID, 1) == -1){

perror("semctl");

exit(1);

}

if(shmctl(shmid, IPC_RMID, NULL) == -1){

perror("shmctl");

exit(1);

}

exit(0);

}

/****Mysem.h*****/
void P(int *s);
void V(int *s);

extern void *shmat (int __shmid, __const void *__shmaddr, int __shmflg);

void P(int *s){
struct sembuf sembuffer, *sops;
sops=&sembuffer;
sops->sem_num = 0;
sops->sem_op = -1;
sops->sem_flg = 0;
if(semop(*s, sops, 1)<0){
perror("semop");
exit(1);
}
return ;
}
void V(int *s){
struct sembuf sembuffer, *sops;
sops = &sembuffer;
sops->sem_num = 0;
sops->sem_op = 1;
sops->sem_flg = 0;
if(semop(*s, sops, 1)<0){
perror("semop");
exit(1);
}
return;
}

❹ 一般来说，在linux中使用共享内存的流程应该怎样

可以使用samba协议。Samba是在Linux和UNIX系统上实现SMB协议的一个免费软件，由服务器及客户端程序构成。SMB是一种在局域网上共享文件和打印机的一种通信协议，它为局域网内的不同计算机之间提供文件及打印机等资源的共享服务。具体配置步骤如下：
步骤1：安装samba
sudo apt-get install samba samba-common-bin
步骤2：新建共享目录并设置权限
sudo mkdir /home/share
sudo chmod 777 /home/share
步骤3：修改配置文件
sudo nano /etc/samba/smb.conf
在smb.conf最后添加：
[share]
path = /home/share
browseable = yes
writable = yes
comment = smb share test
public = no#yes无需密码 no需要密码
步骤4：添加远程访问用户
sudo useradd smbuser
sudo smbpasswd -a smbuser
步骤5：重新启动服务
sudo service samba restart
对于windows操作系统，在资源管理器里输入\\Linux的IP地址，会提示输入上述步骤设置的用户名和密码，输入正确后即可访问分享内容。

❺ linux共享内存的介绍

共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。

❻ linux共享内存的本地通信

因为所有进程共享同一块内存，共享内存在各种进程间通信方式中具有最高的效率。访问共享内存区域和访问进程独有的内存区域一样快，并不需要通过系统调用或者其它需要切入内核的过程来完成。同时它也避免了对数据的各种不必要的复制。
因为系统内核没有对访问共享内存进行同步，您必须提供自己的同步措施。例如，在数据被写入之前不允许进程从共享内存中读取信息、不允许两个进程同时向同一个共享内存地址写入数据等。解决这些问题的常用方法是通过使用信号量进行同步。不过，我们的程序中只有一个进程访问了共享内存，因此在集中展示了共享内存机制的同时，我们避免了让代码被同步逻辑搞得混乱不堪。

❼ linux两个进程间共享内存通信都需要调用shmget函数么

两个进程都需要调用shmget函数，是根据key值来实现访问同一个共享内存的。
函数原型：int shmget(key_t key, size_t size, int shmflg)
由于是两个进程访问，最好是做两手准备：
1，先创建，若创建成功，可以直接使用。
2，若创建失败--此时，很可能另一个进程已经创建成功了，就不能再创建了。此时，就改为只是获取。
示例代码如下：
int mid = shmget(key, size, IPC_CREAT | 0660);
if(mid < 0){
mid = shmget(key, 0, 0);
}

❽ LINUX共享内存如何实现

首先，美化Linux并启动桥接器。SAMBA服务可以在Linux环境中共享。

❾ linux共享内存的优点缺点

共享内存块提供了在任意数量的进程之间进行高效双向通信的机制。每个使用者都可以读取写入数据，但是所有程序之间必须达成并遵守一定的协议，以防止诸如在读取信息之前覆写内存空间等竞争状态的出现。不幸的是，Linux无法严格保证提供对共享内存块的独占访问，甚至是在您通过使用IPC_PRIVATE创建新的共享内存块的时候也不能保证访问的独占性。 同时，多个使用共享内存块的进程之间必须协调使用同一个键值。

❿ linux共享内存使用的过程

Linux共享内存使用的过程？

一、什么是共享内存
顾名思义，共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一样。而如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。

特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取。所以我们通常需要用其他的机制来同步对共享内存的访问，例如前面说到的信号量。

二、共享内存的使用
与信号量一样，在Linux中也提供了一组函数接口用于使用共享内存，而且使用共享共存的接口还与信号量的非常相似，而且比使用信号量的接口来得简单。它们声明在头文件 sys/shm.h中。
1、shmget函数
该函数用来创建共享内存，它的原型为：
int shmget(key_t key, size_t size, int shmflg);
第一个参数，与信号量的semget函数一样，程序需要提供一个参数key（非0整数），它有效地为共享内存段命名，shmget函数成功时返回一个与key相关的共享内存标识符（非负整数），用于后续的共享内存函数。调用失败返回-1.

不相关的进程可以通过该函数的返回值访问同一共享内存，它代表程序可能要使用的某个资源，程序对所有共享内存的访问都是间接的，程序先通过调用shmget函数并提供一个键，再由系统生成一个相应的共享内存标识符（shmget函数的返回值），只有shmget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。

第二个参数，size以字节为单位指定需要共享的内存容量

第三个参数，shmflg是权限标志，它的作用与open函数的mode参数一样，如果要想在key标识的共享内存不存在时，创建它的话，可以与IPC_CREAT做或操作。共享内存的权限标志与文件的读写权限一样，举例来说，0644,它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据，同时其他用户创建的进程只能读取共享内存。