Linux软件编程（Day8）-进程通信，管道

已于 2024-08-09 18:33:38 修改
阅读量772 收藏 9
点赞数 9
文章标签： linux 运维 服务器
于 2024-08-09 18:33:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43344188/article/details/141068614
版权

Linux进程间通信的方式：
    管道、信号 
    消息队列、共享内存、信号灯
    套接字 

1.管道： 
    1.无名管道
        只能用于具有亲缘关系的进程间通信

        无名管道创建后，进程会获得操作管道的两个文件描述符,创建子进程时,子进程会拷贝得到父进程的操作无名管道的两个文件描述符，
        两个进程任务操作同一管道实现通信。

        int pipe(int pipefd[2]);
        功能：
            创建一个用来通信的管道
        参数:
            pipefd:存放管道两端(读写)的文件描述符数组
        成功返回0 
        失败返回-1 

        1.如果管道中至少有一个写端：
            如果管道中有数据,直接读出
            如果管道中没有数据，会阻塞等待直到有数据写入后读出
        
        2.如果管道中没有写端：
            如果管道中有数据，直接读出 
            如果管道中没有数据，不会阻塞直接继续向下执行

        3.如果管道中至少有一个读端：
            如果管道没有写满，直接写入
            如果管道中写满（64k），则阻塞等待,等有数据读出才能继续写入

        4.如果管道中没有读端：
            向管道中写入数据会产生管道破裂信号

进程管道通信代码如下：表示为父子进程通过管道实现数据交换。 --无名管道

#include "../head.h"

char tmpbuff[4096] = {0};

int main(void)
{
    pid_t pid;
    int pipefd[2];
    ssize_t nsize = 0;

    pipe(pipefd);

    pid = fork();
    if (-1 == pid)
    {
        perror("fail to fork");
        return -1;
    }
    if (0 == pid)
    {
        close(pipefd[0]);
#if 0
        strcpy(tmpbuff, "hello world");
        write(pipefd[1], tmpbuff, strlen(tmpbuff));
        read(pipefd[0], tmpbuff, sizeof(tmpbuff));
        
#endif
        while (1)
        {
            
        }
    }
    else if (pid > 0)
    {
        int cnt = 0;
        sleep(2);
        close(pipefd[0]);

        while (1)
        {
            printf("write前!\n");
            write(pipefd[1], tmpbuff, sizeof(tmpbuff));
            printf("write后!\n");
            cnt++;
            printf("cnt = %d\n", cnt);
        }
#if 0
        nsize = read(pipefd[0], tmpbuff, sizeof(tmpbuff));
        printf("读到 %ld 个字节,内容为: %s\n", nsize, tmpbuff);
#endif
    }

    return 0;
}

 2.有名管道 
        通过管道在文件系统中的路径找到管道名,两个进程以读写的方式打开同一管道完成通信

        mkfifo：
        int mkfifo(const char *pathname, mode_t mode);
        功能:
            创建一个管道 
        参数：
            pathname:管道文件的路径 
            mode:权限
        返回值：
            成功返回0 
            失败返回-1 

        有名管道必须读写两端同时加入后,才能继续向下执行

read.c
#include "../head.h"

extern int errno;

int main(void)
{
    int ret = 0;
    int fd = 0;
    ssize_t nsize = 0;
    char tmpbuff[4096] = {0};

    ret = mkfifo("/tmp/myfifo", 0664);
    if (-1 == ret && errno != EEXIST)
    {
        perror("fail to mkfifo");
        return -1;
    }

    fd = open("/tmp/myfifo", O_RDONLY);
    if (-1 == fd)
    {
        perror("fail to open");
        return -1;
    }

    printf("打开管道成功!\n");

    nsize = read(fd, tmpbuff, sizeof(tmpbuff));
    printf("读取到 %ld 个字节, 内容: %s\n", nsize, tmpbuff);

    close(fd);
    
    return 0;
}
write.c
#include "../head.h"

extern int errno;

int main(void)
{
    int ret = 0;
    int fd = 0;

    ret = mkfifo("/tmp/myfifo", 0664);
    if (-1 == ret && errno != EEXIST)
    {
        perror("fail to mkfifo");
        return -1;
    }

    fd = open("/tmp/myfifo", O_WRONLY);
    if (-1 == fd)
    {
        perror("fail to open");
        return -1;
    }

    printf("打开管道成功!\n");

    write(fd, "hello world", 11);

    close(fd);
    
    return 0;
}

        上述表示两个文件执行不同操作，通过有名管道，就是创建了一个内核文件，这个文件在内核中，这段缓存区。最多存储64kb的大小，通过文件IO实现打开写入，其他文件的读取，实现不同进程之间的通信。上述代码的描述。

        实现对播放器的控制的实验。

        mplayer -slave -input file=/tmp/myfifo 视频路径          //将mplayer作为管道文件的从属文件，实现对播放器的控制。

#include "../head.h"

extern int errno;

int main(int argc, const char *argv[])
{
    int ret = 0;
    int fd = 0;
    char commandbuf[256] = {0};

    if (argc < 2)
    {
        fprintf(stderr, "Usage:./a.out command arg\n");
        return -1;
    }

    ret = mkfifo("/tmp/myfifo", 0664);
    if (-1 == ret && errno != EEXIST)
    {
        perror("fail to mkfifo");
        return -1;
    }

    fd = open("/tmp/myfifo", O_RDWR);
    if (-1 == fd)
    {
        perror("fail to open");
        return -1;
    }   

    sprintf(commandbuf, "%s %s\n", argv[1], argv[2]);
    write(fd, commandbuf, strlen(commandbuf));

    close(fd);

    return 0;
}

作业： 1.创建3个线程任务,线程1负责循环打印A 线程2负责循环打印B 线程3负责循环打印C 要求打印出来的内容总是 ABC

同步问题，线程执行，定义全局变量信号量

#include "../head.h"

sem_t sem_a;
sem_t sem_b;
sem_t sem_c;

void *threadafun(void *arg)
{
    while (1)
    {
        sem_wait(&sem_a);
        printf("A");
        sem_post(&sem_b);
    }

    return NULL;
}

void *threadbfun(void *arg)
{
    while (1)
    {
        sem_wait(&sem_b);
        printf("B");
        sem_post(&sem_c);
    }
    
    return NULL;
}

void *threadcfun(void *arg)
{
    while (1)
    {
        sem_wait(&sem_c);
        printf("C");
        sem_post(&sem_a);
    }
    
    return NULL;
}

int main(void)
{
    pthread_t tida;
    pthread_t tidb;
    pthread_t tidc;

    sem_init(&sem_a, 0, 1);
    sem_init(&sem_b, 0, 0);
    sem_init(&sem_c, 0, 0);

    pthread_create(&tida, NULL, threadafun, NULL);
    pthread_create(&tidb, NULL, threadbfun, NULL);
    pthread_create(&tidc, NULL, threadcfun, NULL);

    pthread_join(tida, NULL);
    pthread_join(tidb, NULL);
    pthread_join(tidc, NULL);

    sem_destroy(&sem_a);
    sem_destroy(&sem_b);
    sem_destroy(&sem_c);

    return 0;
}

2.创建以下4个线程任务， 线程1 负责循环间隔1s打印"采集线程正在执行" 线程2 负责循环间隔2s打印"存储线程正在执行" 线程3 负责循环间隔5s打印"告警线程正在执行" 线程4 负责循环间隔10s打印"日志线程正在执行" 主进程负责从终端接收'A'、'B'、'C'、'D'

实现对线程1、2、3、4的打印控制 根据标志位做控制  点击一下实现执行，再次点击实现关闭。

定义全局变量标志位和四把锁，四把锁用于防止同一个信号下锁的互斥问题，进入线程1的If中，返回执行判断语句，导致关闭标志位后，仍然打印任务数据。

#include "../head.h"

pthread_mutex_t CollectLock;
pthread_mutex_t StorageLock;
pthread_mutex_t AlarmLock;
pthread_mutex_t LogLock;

int IsCollectThreadWork = 0;
int IsStorageThreadWork = 0;
int IsAlarmThreadWork = 0;
int IsLogThreadWork = 0;
int IsExist = 0;

void *CollectMainThread(void *arg)
{
    while (!IsExist)
    {
        pthread_mutex_lock(&CollectLock);
        if (IsCollectThreadWork)
        {
            printf("采集线程正在执行\n");
            pthread_mutex_unlock(&CollectLock);
            sleep(1);
        }
        else 
        {
            pthread_mutex_unlock(&CollectLock);
        }
    }

    return NULL;
}

void *StorageMainThread(void *arg)
{
    while (!IsExist)
    {
        pthread_mutex_lock(&StorageLock);
        if (IsStorageThreadWork)
        {
            printf("存储线程正在执行\n");
            pthread_mutex_unlock(&StorageLock);
            sleep(2);
        }
        else 
        {
            pthread_mutex_unlock(&StorageLock);
        }
    }

    return NULL;
}

void *AlarmMainThread(void *arg)
{
    while (!IsExist)
    {
        pthread_mutex_lock(&AlarmLock);
        if (IsAlarmThreadWork)
        {
            printf("告警线程正在执行\n");
            pthread_mutex_unlock(&AlarmLock);
            sleep(5);
        }
        else 
        {
            pthread_mutex_unlock(&AlarmLock);
        }
    }

    return NULL;
}

void *LogMainThread(void *arg)
{
    while (!IsExist)
    {   
        pthread_mutex_lock(&LogLock);
        if (IsLogThreadWork)
        {
            printf("日志线程正在执行\n");
            pthread_mutex_unlock(&LogLock);
            sleep(10);
        }
        else 
        {
            pthread_mutex_unlock(&LogLock);
        }
    }

    return NULL;
}

int main(void)
{
    pthread_t tid[4];
    void *(*p[4])(void *) = {CollectMainThread, StorageMainThread, AlarmMainThread, LogMainThread};
    int i = 0;
    char ch = 0;

    pthread_mutex_init(&CollectLock, NULL);
    pthread_mutex_init(&StorageLock, NULL);
    pthread_mutex_init(&AlarmLock, NULL);
    pthread_mutex_init(&LogLock, NULL);

    for (i = 0; i < 4; i++)
    {
        pthread_create(&tid[i], NULL, p[i], NULL);
    }

    while (1)
    {
        ch = getchar();
        if ('a' == ch || 'A' == ch)
        {
            pthread_mutex_lock(&CollectLock);
            IsCollectThreadWork = !IsCollectThreadWork;
            pthread_mutex_unlock(&CollectLock);
        }
        else if ('b' == ch || 'B' == ch)
        {
            pthread_mutex_lock(&StorageLock);
            IsStorageThreadWork = !IsStorageThreadWork;
            pthread_mutex_unlock(&StorageLock);
        }
        else if ('c' == ch || 'C' == ch)
        {
            pthread_mutex_lock(&AlarmLock);
            IsAlarmThreadWork = !IsAlarmThreadWork;
            pthread_mutex_unlock(&AlarmLock);
        }
        else if ('d' == ch || 'D' == ch)
        {
            pthread_mutex_lock(&LogLock);
            IsLogThreadWork = !IsLogThreadWork;
            pthread_mutex_unlock(&LogLock);
        }
        else if ('q' == ch || 'Q' == ch)
        {
            IsExist = 1;
            break;
        }
    }

    for (i = 0; i < 4; i++)
    {
        pthread_join(tid[i], NULL);
    }

    pthread_mutex_destroy(&CollectLock);
    pthread_mutex_destroy(&StorageLock);
    pthread_mutex_destroy(&AlarmLock);
    pthread_mutex_destroy(&LogLock);

    return 0;
}

        对于上述问题的解决，远古程序员才会这样写，累死你个龟孙。以下为一种结构体方案实现方法，参考即可。下图参考：

#include "../head.h"

int IsExit = 0;

#define TASKLIST_MAXNUM             10

/* 线程任务类型 */
typedef struct task 
{
    char TaskName[256];             //任务名称
    void *(*pTaskFun)(void *);      //任务入口地址
    int WorkFlag;                   //工作状态标志
    pthread_mutex_t Lock;           //锁
    pthread_t tid;                  //线程ID
    int second;                     //工作间隔
}task_t;

/* 所有线程任务列表 */
typedef struct tasklist 
{
    task_t tasklist[TASKLIST_MAXNUM];       //所有任务列表
    int curtaskcnt;                         //当前任务个数
}tasklist_t;

/* 添加任务 */
int AddTask(tasklist_t *ptasklist, char *pThreadName, void *(*pThreadFun)(void *), int seconds)
{
    task_t *ptask = NULL;

    ptask = &ptasklist->tasklist[ptasklist->curtaskcnt];
    strcpy(ptask->TaskName, pThreadName);
    ptask->pTaskFun = pThreadFun;
    ptask->WorkFlag = 0;
    ptask->second = seconds;

    pthread_mutex_init(&ptask->Lock, NULL);
    pthread_create(&ptask->tid, NULL, ptask->pTaskFun, ptask);

    ptasklist->curtaskcnt++;

    return 0;
}

/* 任务线程 */
void *MainThread(void *arg)
{   
    task_t *ptask = arg;

    while (!IsExit)
    {
        pthread_mutex_lock(&ptask->Lock);
        if (ptask->WorkFlag)
        {
            printf("%s 线程正在执行\n", ptask->TaskName);
            pthread_mutex_unlock(&ptask->Lock);
            sleep(ptask->second);
        }
        else 
        {
            pthread_mutex_unlock(&ptask->Lock);
        }
    }

    return NULL;
}

int SwitchWorkMode(tasklist_t *ptasklist, char *pThreadName)
{   
    int i = 0;

    for (i = 0; i < ptasklist->curtaskcnt; i++)
    {
        if (0 == strcmp(ptasklist->tasklist[i].TaskName, pThreadName))
        {
            pthread_mutex_lock(&ptasklist->tasklist[i].Lock);
            ptasklist->tasklist[i].WorkFlag = !ptasklist->tasklist[i].WorkFlag;
            pthread_mutex_unlock(&ptasklist->tasklist[i].Lock);
            break;
        }
    }

    return 0;
}

int WaitAllTaskEnd(tasklist_t *plist)
{
    int i = 0;

    for (i = 0; i < plist->curtaskcnt; i++)
    {
        pthread_join(plist->tasklist[i].tid, NULL);
    }

    return 0;
}

int main(void)
{
    tasklist_t list;
    char ch = 0;

    AddTask(&list, "采集线程", MainThread, 1);
    AddTask(&list, "存储线程", MainThread, 2);
    AddTask(&list, "告警线程", MainThread, 5);
    AddTask(&list, "日志线程", MainThread, 10);

    while (1)
    {
        ch = getchar();
        if ('A' == ch || 'a' == ch)
        {
            SwitchWorkMode(&list, "采集线程");
        }
        else if ('B' == ch || 'b' == ch)
        {
            SwitchWorkMode(&list, "存储线程");
        }
        else if ('C' == ch || 'c' == ch)
        {
            SwitchWorkMode(&list, "告警线程");
        }
        else if ('D' == ch || 'd' == ch)
        {
            SwitchWorkMode(&list, "日志线程");
        }
        else if ('Q' == ch || 'q' == ch)
        {
            IsExit = 1;
            break;
        }
    }

    WaitAllTaskEnd(&list);

    return 0;
}

        定义了两种结构体类型，第一个为具体结构体，第二个为结构体的集合和记录数量。

qq_43344188
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
happyday08-进程地址空间.xmind
04-29
happyday08-进程地址空间.xmind
day06(进程间通信).rar
02-13
linux进程间通信代码部分，Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在...
嵌入式学习Day26---Linux软件编程---进程间的通信
m0_65301172的博客
08-09 798
2024年8月9日，第26天。今天主要学习了进程间的通信之管道，要区分清楚无名管道和管道的应用场景。无名管道用于进程和子进程，共享内核，通过建立无名管道，也就在内核的缓存区，建立读与写的管道，进程与子进程通过文件IO写入读出管道来进行通信。有名管道，需要通过建立管道文件，来将无关联的进程联系起来，使用文件io操作管道文件进程通信。前途光明，未来可期！加油！
嵌入式学习Day27---Linux软件编程---进程间的通信
m0_65301172的博客
08-11 488
2024年8月10日，学习第27天。今天学习的信号通信比管道实现起来比较复杂！加油！
linux软件编程-day(8) 进程通信
最新发布
qq_43344188的博客
08-15 215
/SEM_UNDO 操作结束后,信号量的值会恢复到原来的值。//对信号量的操作 +1(释放信号量) -1(申请信号量)read.c 创建共享内存 -> 映射 -> 从共享内存中读取数据 -> 显示到终端。write.c 创建共享内存 -> 映射 -> 从终端接收数据写入共享内存中。recv.c 创建消息队列 -> 接收消息 -> 销毁消息队列。ipcrm -q/m/s 消息队列ID/共享内存ID/信号灯ID。IPC_CREAT：创建一个信号量数组。IPC_CREAT：创建一个消息队列。
Linux系统编程 day06 进程间通信
月仙儿的博客
11-28 897
进程间通信的概念、匿名管道pipe、命名管道FIFO、内存映射区mmap
嵌入式学习Day24---Linux软件编程---线程基本概念
m0_65301172的博客
08-07 990
线程是轻量级的进程.今天是2024年8月7日，学习的第24天。今天算是把进程线程学完啦，综合来说感觉比较抽象，有待深刻理解，还有各种的函数接口，必须掌握，进程线程很重要很重要！加油！
【Linux-Day8- 进程替换和信号】
高性价比服务器就选：蓝易云
02-21 304
信号是一种在Linux系统中用于通信的机制，它允许进程之间或者用户与进程之间进行交互。Linux定义了多种信号，如SIGINT（中断信号，通常由Ctrl+C产生）、SIGKILL（终止信号，不能被进程捕获或忽略）和SIGSTOP（停止信号，用于暂停进程的执行）。进程替换是一种在Linux shell中创建新进程的方法，它允许一个进程“取代”另一个进程。例如，你可以使用进程替换将一个命令的输出作为另一个命令的输入，而不需要使用管道或临时文件。命令发送信号给进程，或者在你的程序中处理接收到的信号。
linux 进程通信 管道,linux下有名管道进程通信
weixin_35455673的博客
05-02 231
一、任务1、学习mkfifo等函数；2、了解有名管道的特点、阻塞打开与非阻塞打开等；3、编写一个关于有名管道进程通信的程序，并运行。二、相关概念1、相关函数创建有名管道的函数是mkfifo,函数原型是：int mkfifo (const char *__path, __mode_t __mode)功能：创建新的带命名路径的FIFO参数：path — 命名管道路径mode — 模式权限返回值：成功返...
Linux系统编程——09-linux-day06(进程间通信)
Alliswell_WP
07-01 181
在学习Linux系统课程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day06(进程间通信) 一、学习目标 1、熟练使用pipe进行父子进程间通信 2、熟练使用pipe进行兄弟进程间通信 3、熟练使用fifo进行无血缘关系的进程间通信 4、熟练掌握mmap函数的使用 5、掌握mmap创建匿名映射区的方法 6、使用mm...
Linux软件编程Day(9)-信号
qq_43344188的博客
08-12 272
自定义的函数的函数名(指向函数的指针)9号SIGKILL和19号信号SIGSTOP不能被忽略和捕捉。间隔seconds秒后给进程发送SIGALRM信号。SIGINT ctrl+c 打断。SIG_IGN 忽略信号。handler:信号对应的处理方式。成功返回之前注册的信号的处理方式。signum:信号的编号。SIGCHLD：表示该进程有一个子进程结束了。SIGUSR1：用户可以使用该信号实现通信。成功返回上次定时剩余的秒数。按照默认的方式处理信号。按照指定的方式处理信号。
计算机前端-核心编程day2-11扩展.mp4
06-05
计算机前端-核心编程day2-11扩展.mp4
高级软件人才培训专家-day04-Maven
03-10
高级软件人才培训专家-day04-Maven
五：Day01-Linux虚拟机
10-08
8. **包管理器**：Linux发行版通常配备包管理器，如Ubuntu的`apt`，CentOS的`yum`或`dnf`，用于安装、更新和卸载软件。使用包管理器可以方便地查找和安装软件，同时自动解决依赖关系。 9. **网络配置**：学会配置IP...
Linux日常运维小结
lza20001103的博客
08-14 516
Linux日常运维小结
系统控制和管理接口：在Linux中利用电源和性能域进行平台资源抽象
csdnsqst0046的博客
08-09 877
在本文中，您可以了解到如何利用我们的方法将复杂性从Linux驱动程序（需要为每个平台编写不同的开发程序）转移到固件。由于固件已经适配了平台，因此固件知道需要采取哪些手段来配置外设。您可以了解我们如何定义逻辑性能和电源域，而不是单独处理每个平台资源。您还可以了解到我们如何努力实现这一目标，以及您如何进行尝试并做出贡献。
Linux Day1 系统编程和文件操作
qq_63145217的博客
08-12 1030
1）使用标准库函数如fopen, fclose, fread, fwrite, fgetc, fputc, fgets, fprintf, fscanf等进行文件操作。1）用套接字（sockets）API，包括socket, bind, listen, accept, connect, send, recv等函数进行网络通信。nmemb 要写的数据块的个数（一般为sizeof（ptr））->1个1个读，到sizeof（ptr）为止。nmemb 要获取的数据块的个数，拷贝的数据块个数。
Linux中线程接口（分离，查看id）mv指令
2301_77479435的博客
08-14 496
Linux中线程接口（分离，查看id）mv指令
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值