Linux共享内存示例，使用信号量同步

最新推荐文章于 2024-05-11 15:24:08 发布
最新推荐文章于 2024-05-11 15:24:08 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 用户态编程 文章标签： 共享内存 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chr620/article/details/50057971
版权

1、shm_test1.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stddef.h>
#include <errno.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/socket.h>

#define SEM_KEY     100
#define SHM_KEY     101
#define TOTAL_SEM   10
#define UNIX_DOMAIN "/tmp/unix_sock"

typedef struct shared_use {
    int pktlen;
    unsigned char pkt[1528];
} shared_use_t;

static unsigned char ucast_pkt[] = {
  0x00, 0xd0, 0xf8, 0x00, 0x99, 0x22, 0x00, 0x00,
  0x00, 0x01, 0x01, 0x07, 0x08, 0x06, 0x00, 0x01,
  0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xbc, 0x30,
  0x00, 0x00, 0x00, 0x01, 0x01, 0x07, 0xc0, 0xa8,
  0xcc, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xc0, 0xa8, 0xcc, 0x64, 0x01, 0x02, 0x03, 0x04,
  0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
  0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14};

static int sem_id = 0;
static int com_fd = 0;
static void *shm = NULL;

/* 获取信号量资源 */
static int semaphore_v(void)
{
    struct sembuf sem_b;

    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        return -1;
    }

    return 0;
}

/* 释放信号量资源 */
static int semaphore_p(void)
{
    struct sembuf sem_b;

    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        return -1;
    }

    return 0;
}

/* 初始化信号量 */
static int semaphore_init(void)
{
    union semun sem_union;

    sem_id = semget((key_t)SEM_KEY, 1, 0666 | IPC_CREAT);
    if (sem_id == -1) {
        return -1;
    }

    sem_union.val = 1;
    if (semctl(sem_id, 0, SETVAL, sem_union) == -1) {
        return -1;
    }

    return 0;
}

/* 初始化共享内存 */
static int sharemmy_init(void)
{
    int shmid;

    /* 创建共享内存区域块 */
    shmid = shmget((key_t)SHM_KEY, sizeof(shared_use_t), 0666 | IPC_CREAT);
    if (shmid == -1) {
        return shmid;
    }

    /* 将本进程的虚拟内存映射到共享内存 */
    shm = shmat(shmid, (void *)0, 0);
    if (shm == (void *)-1) {
        return -1;
    }

    return shmid;
}

static int sharemmy_destroy(int shmid, void *shm)
{
    int rv;

    /* 删除本进程与共享内存的映射 */
    rv = shmdt(shm);
    if (rv == -1) {
        return rv;
    }

    /* 删除创建的共享内存块 */
    rv = shmctl(shmid, IPC_RMID, 0);
    if (rv == -1) {
        return rv;
    }

    return 0;
}

static int domain_server(void)
{
    int rv;
    int listen_fd;
    socklen_t len;
    struct sockaddr_un srv_un;
    struct sockaddr_un clt_un;

    listen_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    if (listen_fd < 0) {
        perror("socket: ");
        return -1;
    }

    memset(&srv_un, 0, sizeof(srv_un));
    srv_un.sun_family = AF_UNIX;
    strncpy(srv_un.sun_path, UNIX_DOMAIN, sizeof(srv_un.sun_path) - 1);
    unlink(UNIX_DOMAIN);
    rv = bind(listen_fd, (struct sockaddr *)&srv_un, sizeof(srv_un));
    if (rv < 0) {
        perror("bind: ");
        close(listen_fd);
        unlink(UNIX_DOMAIN);
        return -1;
    }

    rv = listen(listen_fd, 1);
    if (rv < 0) {
        perror("listen: ");
        close(listen_fd);
        unlink(UNIX_DOMAIN);
        return -1;
    }

    len = sizeof(clt_un);
    while (1) {
        com_fd = accept(listen_fd, (struct sockaddr *)&clt_un, &len);
        if (errno == EINTR && com_fd == -1) {
            continue;
        }
        break;
    }

    return 0;
}

static void print_cmd_help(void)
{
    printf("CAMMAND NOT SUPPORT!.\n");
    printf("********** Help Info **********\n");
    printf("  1. Send -------- send a packet to commad.\n");
    printf("  2. Quit -------- quit the program.\n");
    printf("**********    End    **********\n");
}

static int shmwrite(void *shm)
{
    int rv;
    shared_use_t *shared;

    rv = semaphore_p();
    if (rv < 0) {
        return -1;
    }

    shared = (shared_use_t *)shm;
    shared->pktlen = sizeof(ucast_pkt);
    memcpy(shared->pkt, ucast_pkt, sizeof(ucast_pkt));

    rv = semaphore_v();
    if (rv < 0) {
        return -1;
    }

    return 0;
}

int main()
{
    int rv;
    int shmid;
    char cmd[10];

    rv = semaphore_init();
    if (rv < 0) {
        printf("Init a semaphore fail.\n");
        return 0;
    }

    shmid = sharemmy_init();
    if (shmid == -1) {
        printf("Init a share memory fail.\n");
        return 0;
    }

    rv = domain_server();
    if (rv < 0) {
        printf("Create domain server socket fail.\n");
        return 0;
    }
    printf("Server init success!\n");
    printf("\n");

    while (1) {
        memset(cmd, 0, sizeof(cmd));
        printf("Enter a command:");
        scanf("%s", cmd);
        if (cmd[9] != 0) {
            printf("Error : Command is too long, at most 9 char allowed!!!\n");
            continue;
        } else if (strstr(cmd, "send") != NULL || strstr(cmd, "Send") != NULL) {
            rv = shmwrite(shm);
            if (rv < 0) {
                printf("Write packet to share memory fail.\n");
                break;
            }
            rv = send(com_fd, cmd, sizeof(cmd), 0);
            if (rv < 0) {
                printf("Send command send fail.\n");
                continue;
            }
        } else if (strstr(cmd, "quit") != NULL || strstr(cmd, "Quit") != NULL) {
            printf("**********Stop Send Packet To Client.***********\n");
            rv = send(com_fd, cmd, sizeof(cmd), 0);
            if (rv < 0) {
                printf("Quit commadn send fail.\n");
            }
            break;
        } else {
            print_cmd_help();
        }
        printf("\n");
    }

    usleep(1000);
    rv = sharemmy_destroy(shmid, shm);
    if (rv < 0) {
        printf("Destroy share memory fail.\n");
        return 0;
    }

    return 1;
}

2、shm_test2.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/un.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/socket.h>

#define SEM_KEY     100
#define PRINT_TIMES 10
#define SHM_KEY     101
#define UNIX_DOMAIN "/tmp/unix_sock"

typedef struct shared_use {
    int pktlen;
    unsigned char pkt[1528];
} shared_use_t;

static int sem_id = 0;
static int connect_fd = 0;
static void *shm = NULL;

static int semaphore_v()
{
    struct sembuf sem_b;

    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        return -1;
    }

    return 0;
}

static int semaphore_p()
{
    struct sembuf sem_b;

    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        return -1;
    }

    return 0;
}

static int semaphore_init()
{
    sem_id = semget((key_t)SEM_KEY, 0, 0666 | IPC_CREAT);
    if (sem_id == -1) {
        return -1;
    }

    return 0;
}

static int sharemmy_init(void)
{
    int shmid;

    shmid = shmget((key_t)SHM_KEY, sizeof(shared_use_t), 0666 | IPC_CREAT);
    if (shmid == -1) {
        return shmid;
    }

    shm = shmat(shmid, (void *)0, 0);
    if (shm == (void *)-1) {
        return -1;
    }

    return shmid;
}

static int sharemmy_destroy(int shmid, void *shm)
{
    int rv;

    rv = shmdt(shm);
    if (rv == -1) {
        return rv;
    }

    return 0;
}

static int domain_client(void)
{
    int rv;
    struct sockaddr_un srv_un;

    connect_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (connect_fd < 0) {
        perror("client socket: ");
        return -1;
    }

    memset(&srv_un, 0, sizeof(srv_un));
    srv_un.sun_family = AF_UNIX;
    strncpy(srv_un.sun_path, UNIX_DOMAIN, sizeof(srv_un.sun_path) - 1);
    rv = connect(connect_fd, (struct sockaddr *)&srv_un, sizeof(srv_un));
    if (rv < 0) {
        perror("connect: ");
        close(connect_fd);
        return -1;
    }

    return 0;
}

static int shmread(shared_use_t *shared)
{
    int rv;

    rv = semaphore_p();
    if (rv < 0) {
        return -1;
    }

    shared->pktlen = ((shared_use_t *)shm)->pktlen;
    memcpy(shared->pkt, ((shared_use_t *)shm)->pkt, shared->pktlen);

    rv = semaphore_v();
    if (rv < 0) {
        return -1;
    }

    return 0;
}

static void print_pkt(shared_use_t shared_pkt)
{
    int i;

    printf("********** RECV PACKET **********\n");
    for (i = 0; i < shared_pkt.pktlen; i++) {
        printf("0x%02x ", shared_pkt.pkt[i]);
        if ((i + 1) % 16 == 0) {
            printf("\n");
        }
    }
    printf("**********     END     **********\n");
    printf("\n");
}

int main()
{
    int rv;
    int shmid;
    char cmd[10];
    shared_use_t shared_pkt;

    rv = semaphore_init();
    if (rv < 0) {
        printf("Init a semaphore fail.\n");
    }

    shmid = sharemmy_init();
    if (shmid == -1) {
        printf("Init a share memory fail.\n");
        return 0;
    }

    usleep(10*1000);
    rv = domain_client();
    if (rv < 0) {
        printf("Create domain client socket fail.\n");
        return 0;
    }
    printf("Client init success.\n");

    while (1) {
        memset(cmd, 0, 10);
        rv = recv(connect_fd, cmd, sizeof(cmd), 0);
        if (rv < 0) {
            printf("Recv cmd from server fail.\n");
            close(connect_fd);
            break;
        }
        if (strstr(cmd, "send") != NULL || strstr(cmd, "Send") != NULL) {
            rv = shmread(&shared_pkt);
            if (rv < 0) {
                printf("Read packet from share memory fail.\n");
                break;
            }
            print_pkt(shared_pkt);
            continue;
        } else if (strstr(cmd, "quit") != NULL || strstr(cmd, "Quit") != NULL) {
            printf("Quit the packet recv client.\n");
            break;
        } else {
            printf("Unrecognized command for client.\n");
            break;
        }
    }

    rv = sharemmy_destroy(shmid, shm);
    if (rv < 0) {
        printf("Destroy share memory fail.\n");
        return 0;
    }
    close(connect_fd);

    return 1;
}

以上两个程序实现的功能：shm_test1接收用户输入命令，如果是send则将向共享内存区域写入一个报文，并发送socket消息通知进程shm_test2从共享内存中读出报文并打印出来。

今沧落
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用共享内存及信号量实现进程间通信例子
03-28
本示例代码着重于使用共享内存和信号量来解决进程间的通信和同步问题，这是一种高效且灵活的方法，特别是在多处理器和多线程环境中。下面我们将详细探讨这些概念以及它们在Linux系统中的实现。 **共享内存** 是一种...
Linux 进程间通信编程
qq_46186025的博客
03-05 1244
Linux 进程间通信编程（单机）一、进程间通信概述二、管道通信（默认无名管道）1.创建无名管道函数pipe（）2.使用无名管道读取的代码练习三、命名管道1.创建有名管道函数mkfifo（）四、信号通信五、共享内存六、消息队列七、信号量 一、进程间通信概述 1、目的： 1）数据传输： 一个进程需要将它的数据发送给另一个进程 2）资源共享 多个进程之间共享同样的资源 3）通知事件 一个进程需要向另一个或一组进程发送消息，通知他们发生了某种事件 4）进程控制 有些进程希望完全控制另一个进程的执行，此时控制进程希
Linux编程期末复习
m0_52307297的博客
12-21 2845
下列命令哪个是创建线程私有数据命令（A） A pthread_key_create() B pthread_setspecific() C pthread_getspecific() D pthread_key_delete(); 2. 下面哪种通信方式适用于不同机器之间的进程通信。（D ） A．消息队列 B．共享内存 C．信号量 D．套接字 3. 创建或打开消息队列的函数为（A ） A．msgget() B．msgsnd() ...
#include ＜stdio.h＞#include ＜stdlib.h＞#include ＜unistd.h＞#include ＜sys/types.h＞#include ＜sys/ipc.
最新发布
sunflowers_JIN的博客
05-11 309
printf("写入： %d。printf("读取： %d。// 将共享内存区附加到进程地址空间。// 子进程（写进程）// 父进程（读进程）// 等待子进程结束。// 分离共享内存区并删除它。// 创建共享内存区。
进程间共享内存通信（信号量同步）（pyhton发 c++收）
LW_12345的博客
11-27 303
【代码】进程间共享内存通信（信号量同步）（pyhton发 c++收）
Linux内核编程 共享内存使用案例
m0_56051805的博客
07-15 790
Linux内核编程 共享内存使用案例
Linux使用共享内存
lyq_csdn的博客
10-24 1082
转自：http://blog.csdn.net/ljianhui/article/details/10253345 https://www.cnblogs.com/52php/p/5851570.html 下面将讲解进程间通信的另一种方式，使用共享内存。   一、什么是共享内存 顾名思义，共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据...
详解Linux多线程使用信号量同步
09-15
【Linux多线程使用信号量同步】在多线程编程中，为了确保资源的安全访问和线程间的协作，常常需要采用同步机制。信号量是一种有效的工具，尤其在Linux环境中，可以用于控制线程对共享资源的访问。本文将详细介绍...
ipc.rar_共享内存 封装_进程信号量
09-23
总之，这个压缩包提供的示例代码可能涉及了创建、操作共享内存和信号量的函数，帮助程序员在多进程环境中实现高效的数据交换和同步。通过学习和理解这些代码，开发者可以更好地掌握共享内存和信号量在实际项目中的...
Linux多进程通信－信号量，共享内存示例
12-09
本示例通过信号量和共享内存这两种IPC机制，展示了如何在多个进程中有效地协同工作。信号量用于同步对共享资源的访问，而共享内存则提供了进程间直接读写的共享数据区域。 信号量是一种同步机制，它是一个整型变量...
sem_syn.rar_linux syn_信号量_线程 同步
09-19
- 在给定的示例中，可能有两个线程通过信号量同步执行。一个线程在访问临界区（即共享资源）前先执行`sem_wait()`，确保没有其他线程正在使用；访问完成后执行`sem_post()`，允许其他线程进入。 - 通过这种方式，...
信号量实现共享内存读写同步
05-16
C语言编写程序，用信号量和共享内存实现读写同步，程序中父进程为读进程，子进程为写进程。开启共享内存空间和二值信号量，子进程占用信号量，父进程无法执行读，等待子进程写完释放信号量后父进程进行读操作。依次类推。
C语言案例总结
wangzun233的博客
03-14 459
pid #include <stdio.h> #include <unistd.h> int main(){ pid_t pid = getpid();//获取当前程序的进程号 pid_t ppid = getppid();//获取当前进程的父进程 printf("当前进程ID%d,父进程ID%d\n",pid,ppid); while(1); return 0; } fork #include <stdio.h> #includ
LinuxC应用开发学习笔记（八）—系统调用I/O
梅山
12-21 938
UNIX环境高级编程（APUE） 文件系统 四、六、七章 I/0 3-5章、14章 文件I/O 标准I/O 并发 信号10章节 多进程并发 多线程并发10-11章节 IPC：进程间通信 8章节 进程基础（涉及到多进程） 13章 守护进程 15-16章 注意事项： 1、弃用root用户 2、重构代码 3、课堂重点：项目，课堂代码，面试题，实验性题目，推荐书籍课后题 I/O：input & output，是一切实现的基础 标准io：stdio 依赖于sysio 系统调用io：sysio（文件IO） 优先
linux高级程序设计——进程
qq_45745843的博客
11-30 491
进程的定义 程序： 程序是存放在存储介质上的一个可执行文件。 进程： 进程是程序的执行实例，包括程序计数器，寄存器和变量的当前值。程序是静态的，进程是动态的。 程序是一些指令的有序集合，而进程是程序执行的过程。进程是程序的一次执行过程。进程的状态是变化的，其包括进程的创建，调度和消亡。 只要程序运行，此时就是进程，程序每运行一次，就会创建一个进程。 在linux系统中，进程是管理事务的基本单元。 进程拥有自己独立的处理环境和系统资源（处理器，存储器，I/O设备，数据，程序）。 可用exec函数由内核将程序读
Linux进程通信——信号量详解 共享内存与信号量配合使用
嵌入式小白 记录学习过程
12-25 697
LInux通信信号量的讲解与例程，共享内存和信号量的配合使用
Liunx系统编程篇—进程通信（四）共享内存（原理、创建、实战）
阿——波罗的博客
01-26 842
消息队列 信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。 特点 信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。 信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。 每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。 支持信号量组。 原理 创建 实例 ...
Linux 进程同步实战入门（共享内存、信号量）
Zheng__Huang的博客
05-27 996
  为了共同完成某项任务，不同进程间需要有一种协作的方式。其中最简单的一种，就是两个进程共享一块物理内存区域。多个进程都可以在其中读写数据，这样就完成了数据从一个进程传送到另一个进程的功能。但单纯使用共享内存还不够，当多个进程并发执行，一同访问共享数据区域，就可能产生数据错误。（关于并发和竞争条件，本文不详细展开，读者可以查阅其他资料）**所以，我们还需要一种同步这些进程行为的方式。**本文我们将采用信号量实现进程同步。 生产者-消费者问题   让我们来考虑这种场景：有n台电脑，m台打印机。n台电脑分别.
进程间的通信终章之【消息队列，信号量，共享内存】
oorik的博客
08-07 691
消息队列概述:特点:消息队列的创建与使用函数接口：使用：ipcs和ipcrm用法：信号量概述:相关概念的认识：（一）进程关系（二）临界资源和临界区（三）原子操作（四）PV操作信号量接口的介绍:信号量的使用：封装系统调用:案例使用：思考：三个进程a.b,c分别输出"A","B","C",要求输出结果必须为"ABCABCABC....."共享内存概述:特点：共享内存的使用与创建共享内存接口介绍 ：案例使用：进程间的通信上节讲解：进程之间的通信(管道详解)消息队列是消息的链表，存放在内存中，由内核维护。消息队列提
semop实现多进程读写共享内存，使用信号量同步
05-26
在多进程读写共享内存时，我们可以使用信号量来保证进程之间的同步。信号量是一种系统资源，它可以用来控制进程的访问和使用共享资源的次数。 在Linux系统中，使用semget函数创建一个信号量集合，使用semop函数对...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值