【操作系统D&I】（设计与实现）进程间通信 — Linux System Call 共享内存

已于 2022-04-01 19:40:30 修改
阅读量1.1k 收藏 2
点赞数 2
分类专栏： 操作系统 笔记 基础知识 文章标签： linux c语言 运维
于 2022-04-01 19:39:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52387305/article/details/123905942
版权
基础知识 同时被 3 个专栏收录
27 篇文章 12 订阅
订阅专栏
笔记
15 篇文章 0 订阅
订阅专栏
操作系统
11 篇文章 1 订阅
订阅专栏

Lab Week 07 实验报告

实验内容：进程间通信 — Linux System Call 共享内存

  • 实验内容：建立一个足够大的共享内存空间结构 (lock, M)，逻辑值 lock 用来保证同一时间只有一个进程进入 M；测试在你的系统上 M 的容量上限。
  • 设计一个程序，在 M 上建立一个结点信息结构为 (flag, 学号, 姓名) 的列表 L，逻辑值 flag 用作结点的删除标识；在 L 上建立一个以学号为关键字的二元小顶堆，自行设计结点的控制结构 (如静态指针数据域)。
  • 设计一个程序对上述堆结构的结点实现插入、删除、修改、查找、排序等操作。该程序的进程可以在同一主机的多个终端并发执行。
  • 思考：使用逻辑值 lock 实现的并发机制不能彻底解决访问冲突问题。

I. 实验过程：

1.测试系统上共享内存空间M的容量上限：

通过指令 ipcs -l 查看系统中共享内存空间大小的限制

image-20220328224653258

可以看到，max total shared memory为18014398442373116 kbytes；

接下来通过修改shmget() 函数中指定的共享内存空间大小的参数，来对共享内存进行动态的大小测试。

实验代码：

shmdata.h

#define TEXT_SIZE 1024 /* = PAGE_SIZE, size of each message */
#define TEXT_NUM 5      /* maximal number of mesages */

typedef struct student{
    int flag;
    int id;
    char name[TEXT_SIZE];
}student;

struct shared_struct{
    int lock;
    char mtext[TEXT_SIZE]; /* buffer for message reading and writing */
    
};

#define PERM S_IRUSR|S_IWUSR|IPC_CREAT

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

tester.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/shm.h>
#include <fcntl.h>

#include "shmdata.h"

int main(int argc, char *argv[]){
    struct stat fileattr;

    key_t key;
    int shmid;
    void *shmptr;
    long long shmsize, ret;
    struct shared_struct *shared;

    pid_t childpid1, childpid2;
    char pathname[99],cmd_str[80];

    int bufsize;
    char* buffer;

    shmsize = sizeof(struct shared_struct);
    printf("current shm size = %lld\n",shmsize);

    if(argc <2) {
        printf("Usage: ./a.out pathname\n");
        return EXIT_FAILURE;
    }
    sprintf(cmd_str, "ipcs -m | grep '%d'\n", shmid); 

    strcpy(pathname, argv[1]);

    if(stat(pathname, &fileattr) == -1) {
        ret = creat(pathname, O_RDWR);  
        if (ret == -1) {
            ERR_EXIT("creat()");
        }
        printf("shared file object created\n");
    }

    key = ftok(pathname, 0x27);
    if(key == -1) {
        ERR_EXIT("shmcon: ftok()");
    }
    printf("key generated: IPC key = 0x%x\n", key);
    printf("Testing the maximum capacity of shared memory...\n");

    while(1){
        shmid = shmget((key_t)key, shmsize, 0666|PERM);
        if(shmid == -1) {
            printf("creating shared memory fail, the current size is %lld, which is over the limits.\n",shmsize);
            ERR_EXIT("shmcon: shmget()");
            break;
        }
        printf("creating shared memory success, the current size is %lld\n",shmsize);
        if (shmctl(shmid, IPC_RMID, 0) == -1) {
            ERR_EXIT("shmctl(IPC_RMID)");
        }
       
            shmsize*=2;
    }

    exit(EXIT_SUCCESS);
}

**代码说明：**通过将共享内存空间的大小不断乘2，这样执行下去直到函数shmget() 返回错误信息，可以得到系统中共享内存大小的限制值。

实验结果：

image-20220328225125353

通过不断地将初始定义的共享内存大小的值乘2，探测出共享内存大小的一个上界为275951648768，随后从值137975824384出发，求出其上确界：

image-20220328225703396

通过将值137975824384不断加1000000，得出上确界140019704384。

2.在 M 上建立一个结点信息结构为 (flag, 学号, 姓名) 的列表 L，逻辑值 flag 用作结点的删除标识；在 L 上建立一个以学号为关键字的二元小顶堆

实验代码：

shmdata.h

#define TEXT_SIZE 1024 /* = PAGE_SIZE, size of each message */
#define TEXT_NUM 5      /* maximal number of mesages */
#define CAPACITY 10 //堆的总容量
typedef struct student{ //学生信息
    int flag;
    int id;
    char name[100];
}student;

typedef struct shared_struct{
    int lock; //lock 值为1时，当前调用进程进入休眠状态
    int size; //堆的当前大小
    student data[TEXT_SIZE];
}*Minheap;

#define PERM S_IRUSR|S_IWUSR|IPC_CREAT

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

代码说明：

代码中组织了二元小顶堆的数据结构，结构体student，为学生信息，结构体Minheap作为小顶堆的结构， 其中student类型的data为堆中的结点数据类型。

实验代码：

heap.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/shm.h>
#include <fcntl.h>

#include "shmdata.h"
void swap(student* a, student* b){
    student temp = *a;
    *a = *b;
    *b = temp;
}
void adjust(Minheap heap, int idx,int size){ //将堆向下调整
    int child = 2 * idx + 1;
    while(child < size){
        if(child + 1 < size && heap->data[child + 1].id < heap->data[child].id){
            child++;
        }
        if(heap->data[child].id < heap->data[idx].id){
            swap(&heap->data[child], &heap->data[idx]);
            idx = child;
            child = 2 * idx + 1;
        }
        else{
            break;
        }
    }
}
void adjust_up(Minheap heap, int idx, int size){ //将堆向上调整
    int parent = (idx - 1) / 2;
    while(idx > 0){
        if(heap->data[idx].id < heap->data[parent].id){
            swap(&heap->data[idx], &heap->data[parent]);
            idx = parent;
            parent = (idx - 1) / 2;
        }
        else{
            break;
        }
    }
}
void init_heap(Minheap heap){ //从最后一个非叶子节点开始，不断的向下调整
    for(int i=heap->size/2 - 1; i>=0; i--){
        adjust(heap, i, heap->size);
    }
}
int heap_push(Minheap heap, int flag, int id, char*name){ //向堆中插入元素
    if(heap->size + 1 > CAPACITY){
        return -1;
    }
    heap->data[heap->size].flag = flag;
    heap->data[heap->size].id = id;
    strcpy(heap->data[heap->size].name, name);
    heap->size++;
    return 0;
}
int heap_pop(Minheap heap){ //从堆中弹出元素
    if(heap->size == 0){
        return -1;
    }
    heap->data[0].flag = 1;
    swap(&heap->data[0], &heap->data[heap->size-1]);
    heap->size--;
    adjust(heap, 0, heap->size);
    
    return 0;
}
char* search(Minheap heap, int id){ //从堆中搜索学号对应的学生姓名
    for(int i=0;i<heap->size;i++){
        if(heap->data[i].flag == 0 && heap->data[i].id == id){
            return heap->data[i].name;
        }
    } 
    return "";
}
char* revise(Minheap heap, int id, char*name){ //从堆中修改学号对应的学生姓名
    char*old_name;
    for(int i=0;i<heap->size;i++){
            if(heap->data[i].flag == 0 && heap->data[i].id == id){
                strcpy(old_name, heap->data[i].name);
                strcpy(heap->data[i].name,name);
                return old_name;
            }
    }
    return "";
}
int main(int argc, char *argv[]){
    struct stat fileattr;

    key_t key;
    int shmid;
    void *shmptr;
    long long shmsize, ret;
    struct shared_struct *shared;

    pid_t childpid1, childpid2;
    char pathname[99],cmd_str[80];

    int bufsize;
    char* buffer;

    shmsize = sizeof(struct shared_struct);
    printf("current shm size = %lld\n",shmsize);

    if(argc <2) {
        printf("Usage: ./a.out pathname\n");
        return EXIT_FAILURE;
    }
    sprintf(cmd_str, "ipcs -m | grep '%d'\n", shmid); 

    strcpy(pathname, argv[1]);

    if(stat(pathname, &fileattr) == -1) {
        ret = creat(pathname, O_RDWR);  
        if (ret == -1) {
            ERR_EXIT("creat()");
        }
        printf("shared file object created\n");
    }

    key = ftok(pathname, 0x27);
    if(key == -1) {
        ERR_EXIT("shmcon: ftok()");
    }
    printf("key generated: IPC key = 0x%x\n", key);
    printf("Testing the maximum capacity of shared memory...\n");

    shmid = shmget((key_t)key, shmsize, 0666|PERM);
    if(shmid == -1) {
        ERR_EXIT("shmcon: shmget()");
    }
    printf("creating shared memory success, the current size is %lld\n",shmsize);

    shmptr = shmat(shmid, 0, 0);
    if(shmptr == (void *)-1) {
        ERR_EXIT("shmat()");
    }

    shared = (struct shared_struct *)shmptr;
    Minheap heap = shared;

    heap->size = 0;
    printf("The capacity of the min heap is %d\n", CAPACITY);
    while(1){
        int option;
        printf("Operations: 1:insert, 2:pop, 3:search, 4:revise, 5:sort, 6:display, 7:quit\n");
       // printf("delete and search operation should enter student followed by the indentifier\n");
        printf("Please enter your option\n");
        scanf("%d",&option);

        if(option == 1){
            printf("now, please enter student id and name, enter -1 -1 to quit inserting\n");
            while(1){
                char name[100];
                int id;
                scanf("%d%s",&id,name);
                if(id == -1) break;
                int res = heap_push(heap, 0, id, name);
                if(res == -1) {
                    printf("Push fall, Out of capacity:%d\n", CAPACITY);
                    break;
                }
                printf("You have pushed %d %s, the heap's current size is %d\n", id,name,heap->size);
            }
            printf("You have inserted the following students' information so far:\n");
            for(int i=0;i<heap->size;i++){
                if(!heap->data[i].flag)
                    printf("Student %s's ID is %d\n",heap->data[i].name,heap->data[i].id);
            }
            printf("The min heap is initialized, enter 6 to check it out!\n");
            init_heap(heap);
        }

        else if(option == 2){
            int ret = heap_pop(heap);
            if(ret == -1) printf("pop fail, heap is empty\n");
            else printf("pop success, the heap's current size is %d \n", heap->size);
        }   

        else if(option == 3){
            int id;
            printf("now, please enter the student'id who you want to search\n");
            scanf("%d",&id);
            char* stuname = search(heap, id);
            if(stuname == ""){
                printf("Sorry, the student doesn't exist\n");
            }
            else
                printf("ID %d is corresponding to student %s\n", id,stuname);
        }

        else if(option == 4){
             printf("Please enter the student's ID, and the name you want to revise \n");
                 int id;
                 char name[100];
                 scanf("%d%s",&id,name);
                 char* ret = revise(shared, id, name);
                 if(ret == ""){
                     printf("Operation fail, Student doesn't exist\n");
                 }
                 else{
                     printf("Student %d 's name has been revised from %s to %s\n",id, ret, name);
                 }
             
        }

        else if(option == 5){
            for(int i = heap->size/2-1; i>=0; i--){
                adjust(heap, i, heap->size);
            }
            int end = heap->size - 1;
            while(end > 0){
                swap(&heap->data[0], &heap->data[end]);
                adjust(heap, 0, end);
                end--;
            }
            printf("Sort success, enter 6 to check it out!\n");
        }

        else if(option == 6){
            for(int i=0;i<heap->size;i++){
                if(!heap->data[i].flag)
                    printf("Student %s's ID is %d\n",heap->data[i].name,heap->data[i].id);
            }
        }
        else {
            break;
        }
    }

    if(shmdt(shmptr) == -1) {
        ERR_EXIT("shmwrite: shmdt()");
    }
    if (shmctl(shmid, IPC_RMID, 0) == -1) {
        ERR_EXIT("shmctl(IPC_RMID)");
    }
    else {
        printf("shmid = %d removed \n", shmid);
    }
    exit(EXIT_SUCCESS);
}

**代码说明：**这部分是二元小顶堆的代码，定义了与堆的操作相关的函数（可见代码注释），在命令行中输入操作数可以实现其对应的堆操作。

实验结果：

image-20220329220121460

从打印出的信息可以看到，此时共享内存空间已经成功建立，小顶堆的大小为10，其中输入1~6分别对应6个操作

现在输入1，对小顶堆进行插入操作：

image-20220329221154339

现在，根据格式输入学生的学号和姓名，最后打印出输入的所有信息，并且将堆初始化；随后，输入6查看当前堆初始化的情况。

image-20220329221320458

从输出的信息可以看到，此时小顶堆已经成功建立，其结构如下图：

18861648563378_.pic

可见，该结构符合小顶堆的定义；

接下来对小顶堆进行排序操作，输入5:

image-20220329221837093

排序成功，堆中的元素从大到小进行排序。

接下来对小顶堆进行pop操作，输入2:

image-20220329222011835

从输出的结果来看，最大的ID数19对应的学生已经被pop出堆，从排序后的结果能更清楚地看到。

接下来对学生的姓名进行更改，这时将ID为8的学生的姓名改为NO1，输入4:

image-20220329222323627

从输出结果来看，ID为8的学生的姓名已经成功地改为NO1

接下来进行查找操作，查找ID为10的学生对应的姓名，输入3:

image-20220329222459571

从输出结果来看，ID为10的学生的姓名为NO6，正确。

3.以上程序的进程在同一主机的多个终端并发执行

以上针对二元小顶堆的操作进行验证，这部分针对该程序，在多个终端上并发执行，并观察实验结果：

实验代码：

代码在heap.c的基础上增加了由lock值来对限定进入程序的进程的功能，增加了一个操作数作为休眠操作，目的是使当前正在执行程序的进程进入休眠状态，随后可以让其他进程使用该程序。

heap_multitmnl.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/shm.h>
#include <fcntl.h>

#include "shmdata.h"
void swap(student* a, student* b){
    student temp = *a;
    *a = *b;
    *b = temp;
}
void adjust(Minheap heap, int idx,int size){
    int child = 2 * idx + 1;
    while(child < size){
        if(child + 1 < size && heap->data[child + 1].id < heap->data[child].id){
            child++;
        }
        if(heap->data[child].id < heap->data[idx].id){
            swap(&heap->data[child], &heap->data[idx]);
            idx = child;
            child = 2 * idx + 1;
        }
        else{
            break;
        }
    }
}
void adjust_up(Minheap heap, int idx, int size){
    int parent = (idx - 1) / 2;
    while(idx > 0){
        if(heap->data[idx].id < heap->data[parent].id){
            swap(&heap->data[idx], &heap->data[parent]);
            idx = parent;
            parent = (idx - 1) / 2;
        }
        else{
            break;
        }
    }
}
void init_heap(Minheap heap){ //从最后一个非叶子节点开始，不断的向下调整
    for(int i=heap->size/2 - 1; i>=0; i--){
        adjust(heap, i, heap->size);
    }
}
int heap_push(Minheap heap, int flag, int id, char*name){
    if(heap->size + 1 > CAPACITY){
        return -1;
    }
    heap->data[heap->size].flag = flag;
    heap->data[heap->size].id = id;
    strcpy(heap->data[heap->size].name, name);
    heap->size++;
    return 0;
}
int heap_pop(Minheap heap){
    if(heap->size == 0){
        return -1;
    }
    heap->data[0].flag = 1;
    swap(&heap->data[0], &heap->data[heap->size-1]);
    heap->size--;
    adjust(heap, 0, heap->size);
    
    return 0;
}
char* search(Minheap heap, int id){
    for(int i=0;i<heap->size;i++){
        if(heap->data[i].flag == 0 && heap->data[i].id == id){
            return heap->data[i].name;
        }
    } 
    return "";
}
char* revise(Minheap heap, int id, char*name){
    char*old_name;
    for(int i=0;i<heap->size;i++){
            if(heap->data[i].flag == 0 && heap->data[i].id == id){
                strcpy(old_name, heap->data[i].name);
                strcpy(heap->data[i].name,name);
                return old_name;
            }
    }
    return "";
}
int main(int argc, char *argv[]){
    struct stat fileattr;

    key_t key;
    int shmid;
    void *shmptr;
    long long shmsize, ret;
    struct shared_struct *shared;

    pid_t childpid1, childpid2;
    char pathname[99],cmd_str[80];

    int bufsize;
    char* buffer;

    shmsize = sizeof(struct shared_struct);
    printf("current shm size = %lld\n",shmsize);

    if(argc <2) {
        printf("Usage: ./a.out pathname\n");
        return EXIT_FAILURE;
    }
    sprintf(cmd_str, "ipcs -m | grep '%d'\n", shmid); 

    strcpy(pathname, argv[1]);

    if(stat(pathname, &fileattr) == -1) {
        ret = creat(pathname, O_RDWR);  
        if (ret == -1) {
            ERR_EXIT("creat()");
        }
        printf("shared file object created\n");
    }

    key = ftok(pathname, 0x27);
    if(key == -1) {
        ERR_EXIT("shmcon: ftok()");
    }
    printf("key generated: IPC key = 0x%x\n", key);
    printf("Testing the maximum capacity of shared memory...\n");

    shmid = shmget((key_t)key, shmsize, 0666|PERM);
    if(shmid == -1) {
        ERR_EXIT("shmcon: shmget()");
    }
    printf("creating shared memory success, the current size is %lld\n",shmsize);

    shmptr = shmat(shmid, 0, 0);
    if(shmptr == (void *)-1) {
        ERR_EXIT("shmat()");
    }

    shared = (struct shared_struct *)shmptr;
    Minheap heap = shared;
    printf("lock:%d\n", shared->lock);
    heap->size = 0;
    printf("The capacity of the min heap is %d\n", CAPACITY);

while(shared->size < 6){ //为方便测试，当共享内存空间里二元小顶堆的结点数为6时，结束进程
     if(shared->lock == 1){
            printf("Process locking, please wait other process's termination\n");
    }
    while(shared->lock == 1){
            sleep(1);
    }
    shared->lock = 1;
    
    while(1){
        int option;
        printf("Operations: 1:insert, 2:pop, 3:search, 4:revise, 5:sort, 6:display, 7:stop 8 quit\n");
        printf("Please enter your option\n");
        scanf("%d",&option);

        if(option == 1){
            printf("now, please enter student id and name, enter -1 -1 to quit inserting\n");
            while(1){
                char name[100];
                int id;
                scanf("%d%s",&id,name);
                if(id == -1) break;
                int res = heap_push(heap, 0, id, name);
                if(res == -1) {
                    printf("Push fall, Out of capacity:%d\n", CAPACITY);
                    break;
                }
                printf("You have pushed %d %s, the heap's current size is %d\n", id,name,heap->size);
            }
            printf("You have inserted the following students' information so far:\n");
            for(int i=0;i<heap->size;i++){
                if(!heap->data[i].flag)
                    printf("Student %s's ID is %d\n",heap->data[i].name,heap->data[i].id);
            }
            printf("The min heap is initialized, enter 6 to check it out!\n");
            init_heap(heap);
        }

        else if(option == 2){
            int ret = heap_pop(heap);
            if(ret == -1) printf("pop fail, heap is empty\n");
            else printf("pop success, the heap's current size is %d \n", heap->size);
        }   

        else if(option == 3){
            int id;
            printf("now, please enter the student'id who you want to search\n");
            scanf("%d",&id);
            char* stuname = search(heap, id);
            if(stuname == ""){
                printf("Sorry, the student doesn't exist\n");
            }
            else
                printf("ID %d is corresponding to student %s\n", id,stuname);
        }

        else if(option == 4){
             printf("Please enter the student's ID, and the name you want to revise \n");
                 int id;
                 char name[100];
                 scanf("%d%s",&id,name);
                 char* ret = revise(shared, id, name);
                 if(ret == ""){
                     printf("Operation fail, Student doesn't exist\n");
                 }
                 else{
                     printf("Student %d 's name has been revised from %s to %s\n",id, ret, name);
                 }
             
        }

        else if(option == 5){
            for(int i = heap->size/2-1; i>=0; i--){
                adjust(heap, i, heap->size);
            }
            int end = heap->size - 1;
            while(end > 0){
                swap(&heap->data[0], &heap->data[end]);
                adjust(heap, 0, end);
                end--;
            }
            printf("Sort success, enter 6 to check it out!\n");
        }

        else if(option == 6){
            for(int i=0;i<heap->size;i++){
                if(!heap->data[i].flag)
                    printf("Student %s's ID is %d\n",heap->data[i].name,heap->data[i].id);
            }
        }
        else if(option == 7){
            shared->lock = 0; 
            break;
        }
        else {
            break;
        }
    }

    if(shmdt(shmptr) == -1) {
        ERR_EXIT("shmwrite: shmdt()");
    }
    if (shmctl(shmid, IPC_RMID, 0) == -1) {
        ERR_EXIT("shmctl(IPC_RMID)");
    }
    else {
        printf("shmid = %d removed \n", shmid);
    }
    exit(EXIT_SUCCESS);
}
}

代码说明：

while(shared->size < 6){ //为方便测试，当共享内存空间里二元小顶堆的结点数为6时，结束进程
     if(shared->lock == 1){
            printf("Process locking, please wait other process's termination\n");
    }
    while(shared->lock == 1){
            sleep(1);
    }
    shared->lock = 1;
    
    while(1){
      int option;
      printf("Operations: 1:insert, 2:pop, 3:search, 4:revise, 5:sort, 6:display, 7:stop 8 quit\n");
      //...........
    }

代码中，这部分用于多进程并行运行程序时，保证同一时间只有一个进程进入该程序，为方便测试，当共享内存空间里二元小顶堆的结点数为6时，结束进程；当lock 值为1时，禁止调用进程访问共享内存空间。

实验结果：

image-20220330144009234

实验时，开启了三个终端，分别为T1、T2和T3，其中一个终端对应的进程进入该程序中，而其他终端对应的进程受到阻塞，需要等待第一个终端结束调用程序后才能进入该程序，如果当前调用程序的进程输入7，表示进入休眠状态，此时其他访问该程序但受到阻塞的进程才可以进行访问。

现在对小顶堆进行插入操作，输入1：

image-20220330144251485

向二元小顶堆中插入5个学生的信息后，进行排序，从最后的结果来看，学生的学号从大到小进行排列，此时其他终端的进程仍保持在阻塞状态。

在终端T1中查找学号为50的学生，输入3:

image-20220330144415502

学号50对应的学生姓名为No4，正确。

在终端T1进行Pop操作，输入2:

image-20220330144450156

可见，学号最大的学生，对应学号为50，已经从堆中弹出。

现在将终端T1对应的进程进行休眠，在终端T1中输入7，执行休眠操作：

image-20220330144544240

从结果来看，终端T1对应的进程休眠后，终端T2对应的进程获得了程序的执行权。

在终端T2进行Revise操作，将学号为10的学生姓名改为No4，输入2:

image-20220330144705804

成功将学号为10的学生姓名从No5改为No4。

现在将终端T2对应的进程进行休眠，在终端T2中输入7，执行休眠操作：

image-20220330144801378

现在，终端T3的进程获得程序执行权。

在终端T3进行搜索操作，查找学号为10的学生对应的姓名，输入3：

image-20220330144905155

学号为10的学生对应的姓名为No4，正确。

现在将终端T3对应的进程进行休眠，在终端T3中输入7，执行休眠操作：

image-20220330145027375

这时，从输出的结果可以看到，终端T1对应的进程获得了程序执行权。

以上操作可以反复进行下去，直到进程终止，从以上的运行结果可以看到，不同终端间所用的共享内存是相同的。

4.思考：使用逻辑值 lock 实现的并发机制不能彻底解决访问冲突问题。

这里需要分清并发和并行的区别：

并发(concurrency)： 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。根据时间片读取上下文+执行程序+保存上下文。

并行(parallellism) : 指两个或者多个事件在同一时刻发生，在多道程序环境下，并行性使多个程序同一时刻可在不同CPU上同时执行。

它们虽然都说是"多个进程同时运行"，但是它们的"同时"不是一个概念。并行的"同时"是同一时刻可以多个进程在运行(处于running)，并发的"同时"是经过上下文快速切换，使得看上去多个进程同时都在运行的现象。

回到上述程序，在while循环内，一个进程若要结束程序的执行会将lock值置为0，随后其他退出阻塞状态的进程会争抢执行这个程序，在这个过程中，如果是单处理器则不会出现问题，但在多处理器中，lock的赋值需要经过寄存器，并不是原子性的，所以lock的值有可能被多次访问，从而引起条件冲突。

Maxwell-Wong
关注
专栏目录
深入详解Linux进程间通信之共享内存（Shared Memory）【1】
白马负金羁
11-01 799
在Linux下的多个进程间的通信机制叫做IPC（Inter-Process Communication），它是多个进程之间相互沟通的一种方法。专栏前面的文章中演示过使用pipe、shared memory、unix domain socket进行IPC的方法。彼时，关于共享内存的例子比较简单，仅仅是父子进程间通过system V IPC通信的过程。本文将更进一步探讨Linux进程间通过共享内容进行通信的方法，并演示基于POSIX的共享内存实例
linux获取共享内存失败2,unix/linux共享内存应用与陷阱
weixin_33501543的博客
05-07 1837
共享内存是系统出于多个进程之间通讯的考虑，而预留的的一块内存区。在/proc/sys/kernel/目录下，记录着共享内存的一些限制，如一个共享内存区的最大字节数shmmax，系统范围内最大共享内存区标识符数shmmni等，可以手工对其调整，但不推荐这样做。一、应用共享内存的使用，主要有以下几个API：ftok()、shmget()、shmat()、shmdt()及shmctl()。1)用ftok...
基于java的进程间异步通信系统的设计与实现
12-05
基于java的进程间异步通信系统的设计与实现 基于java的进程间异步通信系统的设计与实现 基于java的进程间异步通信系统的设计与实现
进程间通信 - 动态链接库实现
weixin_33738555的博客
01-03 373
引子 前面介绍的几种用于实现进程之间通信的方法都是比较正统的方式， 像剪贴板，命名管道这些都还是用得比较多的， 而这里将介绍的是一种比较偏门的方法来实现进程间的通信， 所谓偏门呢，自然就是用的少，能够不用就不要使用。 其实这种方法就是通过动态链接库来实现进程间的通信。                             动态链接库（DLL）概述               ...
操作系统实验报告7：进程间通信—共享内存。实现一个带有n个单元的线性表的并发维护。
StuGeek的博客
07-13 1128
操作系统实验报告7 实验内容 实验内容：进程间通信—共享内存。实现一个带有n个单元的线性表的并发维护。 建立一个足够大的共享内存空间(lock, M)，逻辑值lock用来保证同一时间只有一个进程进入M；测试你的系统上M的上限。 设计一个程序在M上建立一个结点信息结构为 (flag, 学号, 姓名) 的静态链表L，逻辑值flag用作结点的删除标识；在L上建立一个以学号为关键字的二元小顶堆，自行设计控制结构(如静态指针数据域)。 设计一个程序对上述堆结构的结点实现插入、删除、修改、查找、重排等操
操作系统实验四进程间共享内存（初学者）.rar
12-05
通过实验了解windows如何通过内存映射文件机制来实现进程间共享内存；
Lab Week 07
KKiseki的博客
03-30 816
lab Week 07. 实验内容： 实验内容：进程间通信 — Linux System Call 共享内存 建立一个足够大的共享内存空间结构 (lock, M)，逻辑值 lock 用来保证同一时间只有一个进程进入 M；测试在你的系统上 M 的容量上限。 设计一个程序，在 M 上建立一个结点信息结构为 (flag, 学号, 姓名) 的列表 L，逻辑值 flag 用作结点的删除标识；在 L 上建立一个以学号为关键字的二元小顶堆，自行设计结点的控制结构 (如静态指针数据域)。 设计一个程序对上述堆结构的结点实现
【Linux操作系统】--System V的共享内存进程通信
qq_53413129的博客
05-06 864
System V起源 共享内存原理 共享内存应用原理 共享内存接口 创建共享内存shmget shmget测试 创建和删除代码 挂载接口shmat 去关联调用接口shmdt 第二个进程与共享内存挂载 两个进程进行通信 共享内存的特性 补充知识 【shmget的第二个参数size】 shmid每次运行的数量会增加问题 system V信号量（非重点）
Linux下semop等待信号时出现Interrupted System Call错误(EINTR)解决方法
09-05
在Linux操作系统中，`semop`函数是用来操作信号量的，它是实现进程间通信（IPC）的一种重要工具，常用于同步和互斥访问共享资源。然而，在使用`semop`时，可能会遇到一种特定的错误——`Interrupted System Call`...
Linux 操作系统编程 系统编程
最新发布
09-15
3. **信号（Signal）**：信号是进程间通信的一种方式，用于通知进程发生了特定事件，如异常、用户中断等。进程可以注册信号处理函数来响应这些信号。 4. **内存管理**：在Linux中，程序员需要关注动态内存分配...
c语言建立一个链表,每个结点包括姓名和成绩,【C++】建立一个学生信息链表，每个结点包括：学号、姓名、成绩。【原创技术】...
weixin_36382073的博客
05-20 6685
题目：建立一个学生信息链表，每个结点包括：学号、姓名、成绩。实现链表的建立、显示和查询。查询是指输入一个学号，如果链表中存在该学号的的结点，则显示此结点的数据。源代码：//科目：C++实验3//题目：建立一个学生信息链表，每个结点包括：学号、姓名、成绩。//语言：C++//作者：武叶//创作时间：2012年3月20日#include using namespace std;static int N...
【数据结构与算法】最小堆 minheap
热门推荐
u010900754的专栏
02-01 1万+
最小堆与最大堆实现思路一样，只不过顺序不同，这里只记录最小堆。 最小堆的定义是，一棵完全二叉树，每一个节点都大于等于其父节点。完全二叉树是叶子都在最后一层，且尽量靠左。 实现方面可以使用链表或者数组，这里使用数组。 如果使用数组，那么下标从0开始，父节点是i，则左子树是2*i+1，右子树是2*i+2。如果子节点是i，则父节点是（i-1)/2。 minheap的操作主要有两个，一个是add，
【操作系统】进程间通信的五种方式
qq_41358574的博客
08-16 8524
引言1.进程对白：管道、记名管道、套接字1.1管道1.2虫洞：套接字1.3.信号4.信号旗语：信号量5.进程拥抱：共享内存 引言 进程作为人类的发明，自然免不了脱离人类的习性，也有通信需求。如果进程之间不进行任何通信，那么进程所能完成的任务就要大打折扣。例如，父进程在创建子进程后，通常需要监督子进程的状态，以便在子进程没有完成给定的任务时，可以再创建一个子进程来继续。这就需要父子进程间通信。 进程之间的交互称为进程间通信（Inter-Process Communication, IPC）。那么进程之间的通.
实验四：进程间共享内存
Einstein·Jun
10-31 1801
1.Windows下的进程间共享内存是如何实现的？ 2.对于读写进程，物理内存是什么时候分配的？ 3.读写进程之间的同步和互斥在共享内存机制中已经存在了，还是需要用户自己来实现？ 4.利用“虚拟内存的检测”程序检测读进程所映射的虚拟地址空间块的信息。
【Linux】进程间通信
mmwwxx123的博客
08-03 422
进程间通信 进程间通信（IPC）是一组编程接口，让程序员能够协调不同的进程，使之能在一个操作系统里同时运行，并相互传递、交换信息。 通信目的 数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。 共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种...
【操作系统】Linux 进程间通信（IPC）—共享内存（System V与POSIX API实现，基于生产者消费者问题）
MaxwellWong
03-23 6388
Linux 进程间通信（IPC）—共享内存
labweek17
zwx54088的博客
06-17 285
实验报告 实验内容 虚拟存储管理: 编写一个 C 程序模拟实现课件 Lecture24 中的请求页面置换算法包括FIFO、LRU (stack and matrix implementation)、Second chance，并设计输入用例验证结果。 实验环境  Ubuntu 20.04.2.0（64位） 基础知识 FIFO: 如果发生缺页中断，需要换出一个页面的时候，总是选择最早进入内存的页面，即选择在内存中驻留时间最久的页面进行换出。 例： LRU：如果发生缺页中断，选择最长时间未使用的页面进行
Linux下进程间通信
qq_56395437的博客
09-03 897
Linux下的进程通信机制基本是从unix平台继承而来的。传统的Unix进程间通信方式包括无名管道、有名管道以及信号。这些通信方式同样适用于Linux，在Linux中又增加了另外一些通信方式，如消息队列、信号量以及共享内存这些进程通信方式称为IPC，现在Linux中使用较多的进程间通信方式主要有以下几种。（1）无名管道（pipe）以及有名管道（fifo）。无名管道可用于具有亲缘关系进程间通信（通过fork函数建立的父子进程通信）；有名管道除此之外还可用于无亲缘关系直接进程的通信使用。（2）信号。
操作系统实验报告6：进程间通信—共享内存
StuGeek的博客
07-13 3145
操作系统实验报告6 实验内容 实验内容：进程间通信—共享内存。 (1)、验证：编译运行课件 Lecture 08 例程代码： Linux 系统调用示例 reader-writer 问题：Algorithms 8-1 ~ 8-3. POSIX API 应用示例 producer-consumer 问题：Algorithms 8-4 ~ 8-5. (2)、设计：Alg.8-1 ~ 8-3 示例只解决单字符串的读写。修改程序将共享空间组织成一个结构类型（比如学号、姓名）的循环队列进行 FIFO 操作，采用
Linux系统调用与多进程多线程编程技术实现指南
1. Linux系统调用：在Linux操作系统中，系统调用(System Call)是操作系统提供给用户程序的一组接口，它允许用户程序请求操作系统内核提供服务。这些服务包括文件操作、进程控制、内存管理等。系统调用是操作系统中最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值