Linux--進程間通信（信號量，共享內存）（轉）

一. 信號量　　

l信號量: 解決進程之間的同步與互斥的IPC機制

 

多個進程同時運行，之間存在關聯

　　•同步關系

　　•互斥關系

互斥與同步關系存在的根源在於臨界資源

　　•臨界資源是在同一個時刻只允許有限個（通常只有一個）進程可以訪問（讀）或修改（寫）的資源

　　　　–硬件資源（處理器、內存、存儲器以及其他外圍設備等）

　　　　–軟件資源（共享代碼段，共享結構和變量等）

　　•臨界區，臨界區本身也會成為臨界資源

 

 

一個稱為信號量的變量

　　•信號量對應於某一種資源，取一個非負的整型值

　　•信號量值指的是當前可用的該資源的數量，若它等於0則意味着目前沒有可用的資源

在該信號量下等待資源的進程等待隊列

對信號量進行的兩個原子操作(PV操作)

　　•P操作

　　•V操作

 

最簡單的信號量是只能取0 和1 兩種值，叫做二維信號量

 

編程步驟：

　　創建信號量或獲得在系統已存在的信號量

　　　　•調用semget()函數

　　　　•不同進程使用同一個信號量鍵值來獲得同一個信號量

　　初始化信號量

　　　　•使用semctl()函數的SETVAL操作

　　　　•當使用二維信號量時，通常將信號量初始化為1

　　進行信號量的PV操作

　　　　•調用semop()函數

　　　　•實現進程之間的同步和互斥的核心部分

　　如果不需要信號量，則從系統中刪除它

　　　　•使用semclt()函數的IPC_RMID操作

　　　　•在程序中不應該出現對已被刪除的信號量的操作

 

 

 eg. 通過對信號量PV操作，消除父子進程間的競爭條件，使得其調用順序可控。

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

// 將信號量sem_id設置為init_value
int init_sem(int sem_id,int init_value) {
    union semun sem_union;
    sem_union.val=init_value;
    if (semctl(sem_id,0,SETVAL,sem_union)==-1) {
        perror("Sem init");
        exit(1);
    }
    return 0;
}
// 刪除sem_id信號量
int del_sem(int sem_id) {
    union semun sem_union;
    if (semctl(sem_id,0,IPC_RMID,sem_union)==-1) {
        perror("Sem delete");
        exit(1);
    }
    return 0;
}
// 對sem_id執行p操作
int sem_p(int sem_id) {
    struct sembuf sem_buf;
    sem_buf.sem_num=0;//信號量編號
    sem_buf.sem_op=-1;//P操作
    sem_buf.sem_flg=SEM_UNDO;//系統退出前未釋放信號量，系統自動釋放
    if (semop(sem_id,&sem_buf,1)==-1) {
        perror("Sem P operation");
        exit(1);
    }
    return 0;
}
// 對sem_id執行V操作
int sem_v(int sem_id) {
    struct sembuf sem_buf;
    sem_buf.sem_num=0;
    sem_buf.sem_op=1;//V操作
    sem_buf.sem_flg=SEM_UNDO;
    if (semop(sem_id,&sem_buf,1)==-1) {
        perror("Sem V operation");
        exit(1);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include "sem_com.c"

#define DELAY_TIME 3

int main() {
    pid_t pid;
//    int sem_id;
//    key_t sem_key;

//    sem_key=ftok(".",'a');
//    以0666且create mode創建一個信號量，返回給sem_id
//    sem_id=semget(sem_key,1,0666|IPC_CREAT);
//    將sem_id設為1
//    init_sem(sem_id,1);

    if ((pid=fork())<0) {
        perror("Fork error!\n");
        exit(1);
    } else if (pid==0) {
//        sem_p(sem_id); //    P操作
        printf("Child running...\n");
        sleep(DELAY_TIME);
        printf("Child %d,returned value:%d.\n",getpid(),pid);
//        sem_v(sem_id); //    V操作
        exit(0);
    } else {
//        sem_p(sem_id); //    P操作
        printf("Parent running!\n");
        sleep(DELAY_TIME);
        printf("Parent %d,returned value:%d.\n",getpid(),pid);
//        sem_v(sem_id); //    V操作
//        waitpid(pid,0,0);
//        del_sem(sem_id);
        exit(0);
    }

}

在以上程序注釋//未去掉時，即沒用信號量機制時，其結果為：

顯然，此處存在競爭條件。

 

在以上程序注釋//去掉后，即使用信號量機制，其結果為：

由於父子進程采用同一信號量且均執行各自PV操作，故必先等一個進程的V操作后，另一個進程才能工作。

 

 

二. 共享內存

最為高效的進程間通信方式

 

進程直接讀寫內存，不需要任何數據的拷貝

　　•為了在多個進程間交換信息，內核專門留出了一塊內存區

　　•由需要訪問的進程將其映射到自己私有地址空間

　　•進程直接讀寫這一內存區而不需要進行數據的拷貝，提高了效率

 

多個進程共享一段內存，需要依靠某種同步機制，如互斥鎖和信號量等

 

l共享內存編程步驟：

　　1. 創建共享內存

　　　　•函數shmget()

　　　　•從內存中獲得一段共享內存區域

 

　　2. 映射共享內存

　　　　•把這段創建的共享內存映射到具體的進程空間中

　　　　•函數shmat()

 

　　3. 使用這段共享內存

　　　　•可以使用不帶緩沖的I/O讀寫命令對其進行操作

 

　　4. 撤銷映射操作: 函數shmdt()

 

　　5. 刪除共享內存: 函數shctl()

 

 

eg. 下面這個例子完成：父進程從stdin讀取字符串並保存到共享內存中，子進程從共享內存中讀出數據並輸出到stdout

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define BUFFER_SIZE 2048

int main() {
    pid_t pid;
    int shmid;
    char *shm_addr;
    char flag[]="Parent";
    char buff[BUFFER_SIZE];
//    創建當前進程的私有共享內存
    if ((shmid=shmget(IPC_PRIVATE,BUFFER_SIZE,0666))<0) {
        perror("shmget");
        exit(1);
    } else 
        printf("Create shared memory: %d.\n",shmid);

//    ipcs 命令往標准輸出寫入一些關於活動進程間通信設施的信息
//    -m 表示共享內存
    printf("Created shared memory status:\n");
    system("ipcs -m");

    if((pid=fork())<0) {
        perror("fork");
        exit(1);
    }else if (pid==0) {
//    自動分配共享內存映射地址，為可讀可寫，映射地址返回給shm_addr
        if ((shm_addr=shmat(shmid,0,0))==(void*)-1) {
            perror("Child:shmat");
            exit(1);
        }else
            printf("Child: Attach shared-memory: %p.\n",shm_addr);

        printf("Child Attach shared memory status:\n");
        system("ipcs -m");
//    比較shm_addr,flag的長度為strlen(flag)的字符
//    當其內容相同時，返回0
//    否則返回（str1[n]-str2[n]）
        while (strncmp(shm_addr,flag,strlen(flag))) {
            printf("Child: Waiting for data...\n");
            sleep(10);
        }

        strcpy(buff,shm_addr+strlen(flag));
        printf("Child: Shared-memory: %s\n",buff);
//    刪除子進程的共享內存映射地址
        if (shmdt(shm_addr)<0) {
            perror("Child:shmdt");
            exit(1);
        }else
            printf("Child: Deattach shared-memory.\n");

        printf("Child Deattach shared memory status:\n");
        system("ipcs -m");

    }else{
        sleep(1);
//    自動分配共享內存映射地址，為可讀可寫，映射地址返回給shm_addr
        if ((shm_addr=shmat(shmid,0,0))==(void*)-1) {
            perror("Parent:shmat");
            exit(1);
        }else
            printf("Parent: Attach shared-memory: %p.\n",shm_addr);

        printf("Parent Attach shared memory status:\n");
        system("ipcs -m");
//    shm_addr為flag+stdin
        sleep(1);
        printf("\nInput string:\n");
        fgets(buff,BUFFER_SIZE-strlen(flag),stdin);
        strncpy(shm_addr+strlen(flag),buff,strlen(buff));
        strncpy(shm_addr,flag,strlen(flag));
//    刪除父進程的共享內存映射地址
        if (shmdt(shm_addr)<0) {
            perror("Parent:shmdt");
            exit(1);
        }else
            printf("Parent: Deattach shared-memory.\n");

        printf("Parent Deattach shared memory status:\n");
        system("ipcs -m");
//    保證父進程在刪除共享內存前，子進程能讀到共享內存的內容        
        waitpid(pid,NULL,0);
//    刪除共享內存
        if (shmctl(shmid,IPC_RMID,NULL)==-1) {
            perror("shmct:IPC_RMID");
            exit(1);
        }else
            printf("Delete shared-memory.\n");

        printf("Child Delete shared memory status:\n");
        system("ipcs -m");

        printf("Finished!\n");
    }
    
    exit(0);
}