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,它表示允許一個進程創建的共享內存被內存創建者所擁有的進程向共享內存讀取和寫入數據，同時其他用戶創建的進程只能讀取共享內存。