IPC-信号量实现同步和互斥

最新推荐文章于 2023-07-07 16:44:43 发布
最新推荐文章于 2023-07-07 16:44:43 发布
阅读量653 收藏
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sandrew0916/article/details/106564358
版权

信号量

1.创建或获取一个信号量集标识符
int semget(key_t key, int nsems, int semflg)
key:同上
nsems:信号量集中信号量个数
semflg：0664|IPC_CREAT
返回值：成功：返回信号量集的标识符；失败返回-1，错误原因存于error中

2.初始化信号量集
int semctl(int semid, int semnum, int cmd, union semun arg)
semid：信号量集标识符
semnum：信号量集数组上的下标，表示某一个信号量
cmd：控制选项，IPC_RMID和SETVAL最常用
IPC_STAT、IPC_SET、IPC_RMID 都与消息队列和共享内存类似。
SETVAL：通过第四个参数，给集合中semnum编号的信号量设置一个int初值。

需要自己定义;
union semun {
   short val;          /*SETVAL用的值*/
   struct semid_ds* buf; /*IPC_STAT、IPC_SET用的semid_ds结构**/
   unsigned short* array; /*SETALL、GETALL用的数组值*/
   struct seminfo *buf;   /*为控制IPC_INFO提供的缓存*/
  } arg;

联合体使用实例：

1.当需要指定struct semid_ds缓存时：
union semun sem_un;
struct semid_ds buff;
sem_un.buf = &buff;
semctl(semid, 0, IPC_STAT, sem_un);

2.当需要指定信号量的int初始值时：
union semun sem_un;
sem_un.val = 1;
semctl(semid, 0, IPC_STAT, sem_un);

设置初始值：
semctl(semid, semnum, SETVAL, val);

删除信号量：
for(int i = 0; i < nsems; i++)
semctl(semid, i, IPC_RMID);

3.完成对信号量的P(-1)操作或V(+1)操作
int semop(int semid, struct sembuf *sops, unsigned nsops)
semid：信号量集标识符
sops：等价于struct sembuf sops[]
nsops:指定数组元素个数

//不需要自己定义，包含在semop头文件中
struct sembuf {
	unsigned short sem_num;//信号量编号
	short sem_op;//为-1，p操作；+1，V操作
	short sem_flg;//IPC_NOWAIT不阻塞，SEM_UNDO：防止死锁
}

利用信号量实现同步：

#include <stdio.h>
#include "securec.h"
#include <stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<errno.h>
#include<strings.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<signal.h>
#include<strings.h>
#include<string.h>

#define NSEMS 3
#define SEM_FILE "./semfile"
int semid;
union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
    struct seminfo *_buf;
};

void print_err(char *str){
    perror(str);
    exit(-1);
}

void signal_fun(int signo) {
    del_sem(semid, NSEMS);
    exit(-1);
}

int create_or_get_sem(int nsems) {
    int semid = -1;
    int fd = -1;
    key_t key = 0;

    fd = open(SEM_FILE, O_RDWR|O_CREAT, 0664);
    if (fd == -1) print_err("open fail");

    key = ftok(SEM_FILE， 'a');
    if (key == -1) print_err("ftok fail");

    semid = semget(key, nsems, 0664|IPC_CREAT);
    if (semid == -1) print_err("semget fail");

    return semid;
}


void init_sem(int semid, int semnum, int val) {
    int ret = -1;
    union semun sem_un;
    /* semnum：信号量编号
       SETVAL:设置信号量初始值cmd
       sem_un:初始值
    */
    sem_un.val = val;
    ret = semctl(semid, semnum, SETVAL, sem_un.val);
    if (ret == -1) print_err("semctl fail");
}

void del_sem(int semid, int nsems) {
    int ret = -1;

    ret = semctl(semid, i, IPC_RMID); //调用一次就会把信号量集合删除
    if (ret == -1) print_err("semctl fail");
    
}

void p_sem (int semid, int semnum_buf[], int nsops) {
    /*int semop(int semid, struct sembuf *sops, unsigned nsops)
      semid：信号量集标识符
      sops：等价于struct sembuf sops[]
      nsops:指定数组元素个数*/

    /*//不需要自己定义，包含在semop头文件中
        struct sembuf {
            unsigned short sem_num;//信号量编号
            short sem_op;//为-1，p操作；+1，V操作
            short sem_flg;//IPC_NOWAIT不阻塞，SEM_UNDO：防止死锁
        }*/
    int i =0;
    int ret = -1;
    struct sembuf sops[nsops];
    for (int i = 0; i < nsops; i++) {
        sops[i].sem_num = semnum_buf[i];//信号量编号
        sops[i].sem_op = -1;//p操作
        sops[i].sem_flg = SEM_UNDO;//SEM_UNDO：防止死锁
    }

    ret = semop(semid, sops, nsops);
    if (ret == -1) print_err("semop fail");

}

void v_sem (int semid, int semnum_buf[], int nsops) {
    /*int semop(int semid, struct sembuf *sops, unsigned nsops)
      semid：信号量集标识符
      sops：等价于struct sembuf sops[]
      nsops:指定数组元素个数*/

    /*//不需要自己定义，包含在semop头文件中
        struct sembuf {
            unsigned short sem_num;//信号量编号
            short sem_op;//为-1，p操作；+1，V操作
            short sem_flg;//IPC_NOWAIT不阻塞，SEM_UNDO：防止死锁
        }*/
    int i =0;
    int ret = -1;
    struct sembuf sops[nsops];
    for (int i = 0; i < nsops; i++) {
        sops[i].sem_num = semnum_buf[i];//信号量编号
        sops[i].sem_op = 1;//V操作
        sops[i].sem_flg = SEM_UNDO;//SEM_UNDO：防止死锁
    }

    ret = semop(semid, sops, nsops);
    if (ret == -1) print_err("semop fail");

}

int main()
{
    int i = 0;
    int ret = -1;
    int semnum_buf[1] = {0}; //每次只操作一个信号，所以元素个数为1

    // 创建信号量集合
    semid = create_or_get_sem(NSEMS);
 
    // 初始化信号量集合中的每个信号量
    // 只需要一个进程来初始化，此处由父进程初始化
    for (i = 0; i < NSEMS; i++) {
        if (i == 0) {
            init_sem(semid, i, 1);
        } else {
            init_sem(semid, i, 0);
        }
    }

    ret = fork();
    if (ret > 0) {
        ret = fork();
        if (ret > 0) {
            // 父进程
            signal(SIGINT, signal_fun);
            while(1) {
                semnum_buf[0] = 2;
                p_sem(semid, semnum_buf, 1);
                printf("333333\n");
                sleep(1);
                semnum_buf[0] = 1;
                v_sem(semid, semnum_buf, 1);
            }

        } else if (ret == 0) {
            // 子进程2
            while(1) {
                semnum_buf[0] = 1;
                p_sem(semid, semnum_buf, 1);
                printf("222222\n");
                sleep(1);
                semnum_buf[0] = 2;
                v_sem(semid, semnum_buf, 1);
            }
        }

    } else if (ret == 0) {
        // 子进程1
        while(1) {
            semnum_buf[0] = 0;
            p_sem(semid, semnum_buf, 1);
            printf("111111\n");
            sleep(1);
            semnum_buf[0] = 1
            v_sem(semid, semnum_buf, 1);
        }    
    }
    return 0;
}

sem1.c:

#include <stdio.h>
#include "securec.h"
#include <stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<errno.h>
#include<strings.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<signal.h>
#include<strings.h>
#include<string.h>

#define SHM_FILE "./file.txt"
#define SHM_SIZE 4096//一页为4k，即4096
#define NSEMS 2

int shmid = -1;
void *shmaddr = NULL;
int semid;

void print_err(char *str) {
    perror(str);
    exit(-1);
}
void signal_fun(int signo) {
    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, NULL);
    remove("./fifo.txt");
    remove(SHM_FILE);

    exit(-1);
}
int get_peer_PID() {
    int ret = -1;
    int fifofd = -1;

    /* 创建有名管道文件 */
    ret = mkfifo("./fifo.txt", 0664);
    if(ret == -1 && errno == EEXIST) print_err("mkfifo fail");

    /* 以只读方式打开管道 */
    fifofd = open("./fifo.txt", O_RDONLY);
    if(fifofd == -1) print_err("open fail");

    /* 读管道，获取读共享内存进程的PID */
    int peer_pid;
    ret = read(fifofd, &peer_pid, sizeof(peer_pid));
    if (ret == -1) print_err("read fail");

    return peer_pid;
}

void create_or_open_shm(void) {
    key_t key = -1;
    int fd = 0;

    fd = open(SHM_FILE, O_RDWR|O_CREAT, 0664);
    if (fd == -1) print_err("open fail");

    /*利用存在的文件路径名和八位整形数，计算出key*/
    key = ftok(SHM_FILE, 'b');
    if (key == -1) print_err("ftok fail");

    /*利用key创建、或者获取共享内存*/
    shmid = shmget(key, SHM_SIZE, 0664|IPC_CREAT);
    if (shmid == -1) print_err("shmget fail");

}
char buf[300] = {"aaaaaaaaaaaaaaasdddddddddddddddfffffffffffffggggggggggggg"};
int main(int argc, char **argv)
{
    int peer_id = -1;
    int semnum_buf[1] = {0}; //P和V操作时只需要操作一个信号量。

    /* 给SIGINT信号注册捕获函数，用于删除共享内存、管道、文件等 */
    signal(SIGINT, signal_fun);    

    semid = create_or_get_sem(NSEMS);

    /* 创建或者获取共享内存 */
    create_or_open_shm();

    /* 建立映射 */
    shmaddr = shmat(shmid, NULL, 0);
    if (shmaddr == (void *)-1) print_err("shmat error");

    //写内存
    while(1) {

        /*写内容到共享内存*/
        // p sem 0
        semnum_buf[0] = 0;
        p_sem(semid, semnum_buf, 1);

        memcpy(shmaddr, buf, sizeof(buf));
        sleep(1);

        // v sem 1
        semnum_buf[0] = 1;
        v_sem(semid, semnum_buf, 1);
        
    }

    return 0;
}

sem2.c

#include <stdio.h>
#include "securec.h"
#include <stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<errno.h>
#include<strings.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<signal.h>
#include<strings.h>
#include<string.h>

#define SHM_FILE "./file.txt"
#define SHM_SIZE 4096//一页为4k，即4096
#define NSEMS 2

int shmid = -1;
void *shmaddr = NULL;
int semid;

void print_err(char *str) {
    perror(str);
    exit(-1);
}
void signal_fun(int signo) {

    if (SIGINT == signo) {
        shmdt(shmaddr);
        shmctl(shmid, IPC_RMID, NULL);
        remove("./fifo.txt");
        remove(SHM_FILE);

        exit(-1);
    } else if (SIGUSR1 == signo) {

    }    
}

void snd_self_PID() {
    int ret = -1;
    int fifofd = -1;

    ret = mkfifo("./fifo.txt", 0664);
    if (ret == -1 && errno == EEXIST) print_err("mkfifo fail");

    /* 以只写方式打开文件 */
    fifofd = open("./fifo.txt", O_WRONLY);
    if (fifofd == -1) print_err("open fail");

    int pid = getpid();
    ret = write(fifofd, &pid, sizeof(pid));//发送PID
    if (ret == -1) print_err("write fail");
}

void create_or_open_shm(void) {
    key_t key = -1;
    int fd = 0;

    fd = open(SHM_FILE, O_RDWR|O_CREAT, 0664);
    if (fd == -1) print_err("open fail");

    /*利用存在的文件路径名和八位整形数，计算出key*/
    key = ftok(SHM_FILE, 'b');
    if (key == -1) print_err("ftok fail");

    /*利用key创建、或者获取共享内存*/
    shmid = shmget(key, SHM_SIZE, 0664|IPC_CREAT);
    if (shmid == -1) print_err("shmget fail");

}

int main(int argc, char **argv)
{
    int semnum_buf[1] = {0};
    /* 给SIGUSR1注册一个空捕获函数，用于唤醒pause函数 */
    signal(SIGUSR1, signal_fun);
    signal(SIGINT, signal_fun); 

    
    semid = create_or_get_sem(NSEMS);

    /* 创建或者获取共享内存 */
    create_or_open_shm();
    
    /* 建立映射 */
    shmaddr = shmat(shmid, NULL, 0);
    if (shmaddr == (void *)-1) print_err("shmat error");

    //读内存
    while(1) {
        
        // p sem 1
        semnum_buf[0] = 1;
        p_sem(semid, semnum_buf, 1);

        printf("%s\n", (char*)shmaddr);
        bzero(shmaddr, SHM_SIZE);

        // v sem 0
        semnum_buf[0] = 0;
        v_sem(semid, semnum_buf, 1);

        //这里写内存有缺陷：如果没有数据会一直判断  
        //改进：同步！！！当共享内存没有数据时，读进程休眠，当写进程把数据写完后，将读进程唤醒。
        //实现同步的方法：（1）信号；（2）信号量
        /*
        if (strlen((char*)shmaddr) != 0) {
            printf("%s\n", (char*)shmaddr);
            bzero(shmaddr, sizeof(shmaddr));
        }*/
    }
    return 0;
}
幸运小猴子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实训报告进程同步和互斥
12-24
操作系统实训报告进程同步和互斥通过实现哲学家进餐问题的同步深入了解和掌握进程同步和互斥的原理。哲学家有N个，也定全体到达后开始讨论：在讨论的间隙哲学家进餐，每人进餐时都需使用刀、叉各一把，所有哲学家刀和叉都拿到后才能进餐。哲学家的人数、餐桌上的布置自行设定，实现刀和叉的互斥使用算法的程序实现。
【操作系统】同步互斥机制（二）：管程与进程间通信机制（IPC）
热门推荐
少侠露飞的学习笔记
02-09 1万+
1 管程 1.1 管程的定义 管程（Monitor）是关于共享资源的数据结构及在其上操作的一组过程组成。进程只能通过调用管程中的过程来间接的访问管程中的数据结构。 1.2 管程需要解决的两个基本问题 1.2.1 互斥 管程是互斥进入的，有一个进程调用管程时，其他进程将不能再调用管程，这么设计主要是为了保证数据完整性。管程的互斥是由编译器保证的。 1.2.2 同步 管程中设置条件变量及等待/唤醒操作...
【linux】linux随记--system-V 信号量
olllp的博客
04-15 124
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cisJsmd9-1681526676132)(C:\Users\嘻嘻_略\AppData\Roaming\Typora\typora-user-images\image-20230415104413452.png)]//信号量行为，SEM_UNDO。//信号量P/V操作。功能：获取或设置信号量的相关属性。semnum：信号量编号。功能：获取信号量的ID。semid：信号量ID。semid：信号量ID。
RT-Thread 学习记录之 IPC （线程间同步）
m0_46430715的博客
09-04 826
RT-Thread IPC机制的一些学习记录
进程间的7种通讯方式
qq_42843172的博客
09-21 1042
进程间的7种通讯方式 管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。 共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，
linux ipc 带有信号量同步互斥方式的进程间通信
04-14
本案例，增加同步互斥院里的 linux间进程之间的通信代码，很有学习的意义
Linux System V信号量(互斥操作)
01-03
System V信号量与System V其他两种通信机制（消息队列、共享内存）不同，其用来实现同步、互斥进程动作，通过semget函数创建一个信号集或打开一个信号量集，信号集又包括多个信号量，信号量的值要大于等于0，小于0，...
利用同步互斥解决理发师问题
05-06
分为顾客进程与理发师进程，将PV原语解决操作系统中的经典问题——理发...编程环境为Microsoft Vitual Studio.NET 2003，C#语言，用Mutex类实现互斥信号量的创建，WaitOne()方法实现P操作， ReleaseMutex()实现V操作。
操作系统实验：进程通信与进程同步（CTGU）
最新发布
11-23
(1)加强对进程同步和互斥的理解，学会使用信号量解决资源共享问题。 (2)熟悉Linux 进程同步原语。 (3)掌握信号量wait/signal 原语的使用方法，理解信号量的定义、赋初值及wait/signal操作 二. 实验内容 ■实验4.1 ...
【RT‐Thread 作品秀】基于RT‐Thread的网络照相机-电路方案
04-19
RT-Thread使用情况概述内核部分:调度器，信号量，互斥锁，内存管理 调度器:多任务调度 信号量:用于唤醒对应任务 互斥锁:用于互斥资源独占访问 内存管理:动态内存申请与释放 组件部分:虚拟文件系统，IPC，I2C，RTC，...
Linux系统编程之信号量
hyw15019042884的博客
10-21 561
一、什么是信号量 为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占式地执行。而信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。 信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。最简单的信号量是只能取0和1的
Linux进程间通信(IPC)_同步（1）：互斥锁和条件变量（《Unix高级编程》《Unix网络编程-卷2》学习总结）
jnxhz2008的博客
07-23 610
目录 一、互斥和同步 1.1 互斥和同步的概念 二、同步方式 2.1互斥锁 2.1.1介绍 2.1.2 注意 2.1.3 函数说明 2.1.4 程序：用于保护结构体的引用计数锁（互斥量） 一、互斥和同步 1.1 互斥和同步的概念 1、互斥：一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。这样的公共资源也成为临界资源。 2、同步：两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。比如 A 线程的运行依赖于 B 线程产生的数据。 ..
IPC-核间通讯
xiandang8023的博客
07-07 5873
IPC通讯是AUTOSAR体系结构中的核心组成部分，它使得不同的软件组件可以相互通信、协同工作，从而实现整车系统的功能。IPC可以理解为核间通讯在多核处理器系统中，不同的处理器核之间可以通过共享内存、消息传递等方式进行IPC核间通讯。共享内存是指多个处理器核共享同一块物理内存，通过在内存中设置标志位或锁等机制来控制对共享数据的访问。消息传递是指不同处理器核之间通过发送和接收消息来进行通信，其中消息可以是数据、信号等。
Linux进程间通信(IPC)介绍：详细解析IPC的执行流程、状态和通信机制
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-02 1292
linux posix ipc介绍
Linux的信号量
肖肖的博客
10-31 1606
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。 ** 1、特点 ** 1、信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。 2、信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。 3、每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。 4、支持信号量组。 例子：就像一个房间，信号量相当于开门的钥匙，房间相当于连接资源（一次仅允许一个进程使用的资源；如
经典IPC问题实现与思考
crazy_scott的博客
04-11 1712
本文介绍多种同步方法来解决进程间通信问题，并给出模型的代码实现。 代码介绍 本文主要侧重于代码实现，若对互斥（mutex）以及死锁问题还不够熟悉，可以参考我这篇文章。 ​ include &lt;pthread.h&gt; - pthread_mutex_t - 用于创建互斥（mutex）变量 - pthread_mutex_lock ...
用于同步进程的信号量代码示例
cyllsy的博客
10-22 336
注：本文章代码示例以及知识点来自《Linux高性能服务器编程》一书 ，对应章节13.5——信号量。 一、父、子进程间使用一个IPC_PRIVATE信号量来同步 Linux信号量的API都定义在sys/sem.h头文件中，主要包含3个系统调用：semget、semop、semctl。它们都被设计为操作一组信号量，即信号量集，而不是单个信号。 可以结合对比线程同步中的互斥锁来进行学习。 #include <sys/sem.h> #include <cstdio> #include &lt
信号量机制实现进程的互斥、同步、前驱
kkyh28的博客
12-05 4823
1965年，荷兰学者Dijkstra提出了一种卓有成效的实现进程互斥、同步的方法——信号量机制 信号量其实就是一个变量（可以是一个整数，也可以是一个更复杂的变量），可以用信号量来表示系统中某种资源的数量。比如：系统中只有一台打印机，就可以设置一个初值为1的信号量。 P、V操作： P表示通过，V表示释放 1.整型信号量： 整型信号量与普通的信号量的区别： 对信号量的操作只有：初始化、P操作、V操作 缺点：不满足“让权等待”原...
进程间通信IPC-消息队列/共享内存
qq_45778079的博客
07-26 196
消息队列 消息队列是由消息的链表，存放在内核中并一个消息队列由一个标识符（即队列ID）来标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。 1、特点 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。 2、原型 // 创建或打开消息队列：成功返回队列ID..
Linux共享内存和有名信号灯实现进程同步
05-24
3. 在多个进程中对共享内存进行读写操作，需要使用互斥锁或信号量来保证进程的同步性和互斥性 4. 对信号灯进行P操作（等待信号灯的值大于0），以保证只有一个进程访问共享内存 5. 对共享内存进行读写操作 6. 对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值