C++学习：第六章Linux高级编程 - （七）信号、sigqueue、sigaction、IPC、管道、匿名管道

最新推荐文章于 2024-05-15 23:45:29 发布

Thomas会写字

最新推荐文章于 2024-05-15 23:45:29 发布

阅读量326

点赞数

分类专栏： C++

共享知识，欢迎转载

本文链接：https://blog.csdn.net/kakiebu/article/details/109312078

版权

C++ 专栏收录该内容

67 篇文章 6 订阅

订阅专栏

回顾:

1. 信号的作用

2. 理解信号:

软中断

可靠与不可靠信号

kill -l

3. 信号发送与注册

kill/raise

alarm

setitimer

signal

4. 信号的屏蔽

sigprocmask

sigemptyset

sigfillset

5. 信号屏蔽的切换

sigpending

sigsuspend = pause + 指定屏蔽信号

pause与sigsuspend都会被信号中断。中断的是pause与sigsuspen函数，不是进程中其他代码

sigsuspend放在sigprocmask环境中思考:

5.1.sigsuspend是否影响sigprocmask屏蔽的信号呢?

影响。使原来的屏蔽信号全部失效。当sigsuspend返回，恢复原来的屏蔽信号.

5.2.sigsuspend什么时候使用?

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

void handle(int s)
{
    printf("外部用户中断处理...!\n");
    sleep(3);
    printf("外部用户中断处理完毕!\n");
}

main()
{
    int sum=0;
    int i;
    sigset_t sigs,sigt,sigu;
    sigemptyset(&sigs);
    sigemptyset(&sigt);
    sigemptyset(&sigu);
    sigaddset(&sigs,SIGINT);

    //sigfillset(&sigs);
    signal(SIGINT,handle);
    sigprocmask(SIG_BLOCK,&sigs,0);

    for(i=0;i<10;i++)
    {
        printf("正在拷贝电影<%d>!\n",i);
        sleep(5);//模拟业务处理时间比较长
        printf("正在拷贝电影<%d>完毕!\n",i);
        sigpending(&sigu);
        if(sigismember(&sigu,SIGINT))
        {
            sigsuspend(&sigt);
        }
    }

    printf("所有电影拷贝完毕\n",sum);
    sigprocmask(SIG_UNBLOCK,&sigs,0);
    printf("over!\n");
}

一、最新版本的信号发送与处理

sigqueue/sigaction

1. 思考：信号中断函数调用中是否被其他信号中断。

信号函数调用中只屏蔽本身信号，不屏蔽其他信号。

#include <stdio.h>
#include <signal.h>

void handle(int s)
{
    printf("Hello!start\n");
    sleep(10);
    printf("Hello!end\n");
}

main()
{
    signal(SIGINT,handle);
    while(1);
}

2. 怎么保证函数调用中屏蔽指定的信号呢?

sigaction 可以指定处理函数调用的屏蔽信号

sigaction 在处理信号的时候，接受数据.

sigqueue 发送信号的时候，可以发送数据.

sigaction/sigqueue是signal/kill的增强版本，区别在于函数本身可以自动屏蔽和处理队列信号，不需要再次声明。四个函数可以混合使用。

3. 函数说明

使用sigaction/sigqueue有两个理由.

3.1 稳定

3.2 增强功能

int sigaction(
int sig, //被处理信号
const struct sigaction*action, //处理函数及其参数
struct sigaction*oldact //返回原来的处理函数结构体
)
返回：
0：成功
-1：失败

struct sigaction
{
void (*sa_handle)(int); //函数指针
void (*sa_sigaction)(int,siginfo_t*,void*); //函数指针
sigset_t *mask; //屏蔽信号
int flags; //SA_SIGINFO，决定优先使用第一个函数还是第二个
void** //保留成员.
}

案例:

使用sigaction处理信号，使用kill发送信号
使用sigaction处理信号，使用sigqueue发送信号
发送信号的同时处理数据

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

/*
void handle(int s)
{
    printf("OOOK!\n");
    sleep(5);
    printf("KOOO!\n");
}
*/

void handle(int s,siginfo_t* info,void *d)
{
    printf("OOOK:%d\n",info->si_int);//获取8888参数
    sleep(5);
    printf("KOOO!\n");
}

main()
{
    struct sigaction act={0};
    //act.sa_handler=handle;
    act.sa_sigaction=handle;

    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,SIGINT);
    act.sa_flags=SA_SIGINFO;
    sigaction(SIGUSR1,&act,0);

    while(1);
}

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

main()
{
    union sigval val;
    val.sival_int=8888;
    sigqueue(3972,SIGUSR1,val);
}

二、 IPC

IPC 进程之间通讯。最初Unix IPC包括：管道、FIFO、信号；

1. 基于文件

1.1.无序文件

1.1.有序文件

1.1.1.管道

1.1.1.1.有名

1.1.1.2.匿名

1.1.2.socket

2. 基于内存

2.1 无序内存

2.1.1.匿名内存

2.1.2.共享内存

2.2.有序内存

2.2.1.共享队列

3. 同步:基于内存IPC应用(共享内存数组)

信号量/信号灯

linux下进程间通信的几种主要手段简介：

管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；

信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）；

报文（Message）队列（消息队列）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。

共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。

信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。

套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

三、基于普通文件的IPC

IPC的技术提出的应用背景.

进程之间需要同步处理:

同步需要通信.

普通文件就是最基本的通信手段.

普通文件IPC技术的问题:

一个进程改变文件，另外一个进程无法感知.

解决方案:

一个特殊的文件:管道文件

A文件，写内容

#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>

main()
{
    int *p;
    int fd;
    int i;

    fd=open("tmp",O_RDWR|O_CREAT,0666);
    ftruncate(fd,4);

    p=mmap(0,4,PROT_READ|PROT_WRITE,
    MAP_SHARED,fd,0);

    i=0;
    while(1)
    {
        sleep(1);
        *p=i;
        i++;
    }

    close(fd);
}

B文件：读内容

#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>

main()
{
    int *p;
    int fd;

    fd=open("tmp",O_RDWR);
    p=mmap(0,4,PROT_READ|PROT_WRITE,
    MAP_SHARED,fd,0);

    while(1)
    {
        sleep(1);
        printf("%d\n",*p);
    }

    close(fd);
}

四、管道文件

创建管道mkfifo
体会管道文件特点

案例：

fifoA fifoB

建立管道文件

打开管道打开管道

写数据读数据

关闭管道关闭管道

删除管道

建立管道文件:

使用linux的指令mkfifo

fifoA 文件

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdlib.h>

int fd;
int i;

void  end(int s)
{
    //关闭管道
    close(fd);

    //删除管道
    unlink("my.pipe");
    exit(-1);
}


main()
{
    signal(SIGINT,end);

    //建立管道
    mkfifo("my.pipe",0666);

    //打开管道
    fd=open("my.pipe",O_RDWR);

    //shutdown(fd,SHUT_RD);//关闭读权限
    i=0;

    while(1)
    {
        //每隔1秒写数据
        sleep(1);
        write(fd,&i,4);
        i++;
    }
}

fifoB文件

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdlib.h>

int fd;
void end(int s)
{
    //关闭管道
    close(fd);
    exit(-1);
}

main()
{
    int i;

    //打开管道
    signal(SIGINT,end);
    fd=open("my.pipe",O_RDWR);

    //shutdown(fd,SHUT_WR);//关闭写权限
    while(1)
    {
        read(fd,&i,4);
        printf("%d\n",i);
    }
}

总结:

read时，如果没有数据则read阻塞，而且read后数据是被删除
数据有序
打开的描述符号可以读写(two-way双工)
管道文件关闭后，数据不持久(数据消失，无法被读到).
管道的数据存储在内核缓冲中，而没有写到文件中。

五、匿名管道

发现有名的管道的名字仅仅是内核识别是否返回同一个fd的标示。所以当管道名失去表示作用的时候，实际可以不要名字.

在父子进程之间：打开文件描述后创建进程。父子进程都有描述符号。所以管道文件没有价值。所以在父子进程中引入一个没有名字的管道：匿名管道，但在其他进程之间还是需要有名管道。

结论：

匿名管道只能使用在父子进程.

创建匿名管道
使用匿名管道

案例：

匿名管道的创建

体会匿名管道的特点

int pipe(int fd[2]);//创建匿名管道.打开管道.拷贝管道.关闭读写

fd[0]:只读(不能写)

fd[1]:只写(不能读)

注意：数据无边界.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    int fd[2];
    int r;
    char buf[20];
    printf("%d\n",getpid());
    r=pipe(fd);

    write(fd[1],"hello",5);
    write(fd[1],"world",5);

    r=read(fd[0],buf,20);
    buf[r]=0;
    printf("%s\n",buf);
    write(fd[1],"louis",5);
    r=read(fd[0],buf,20);
    buf[r]=0;
    printf("%s\n",buf);

    while(1);
}

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

main()
{
    int fd[2];
    pipe(fd);
    
    if(fork())
    {
        //parent
        close(fd[0]);//只负责写，以防数据混乱
        
        while(1)
        {
            write(fd[1],"Hello",5);
            sleep(1);
        }
    }
    else
    {
        //child
        char buf[20];
        int r;
        close(fd[1]);//只负责读，以防数据混乱
    
        while(1)
        {
            r=read(fd[0],buf,20);
            buf[r]=0;
            printf("::%s\n",buf);
        }
    }
}

综合：（只为示范进程+通信，不推荐这样使用）

建立两个子进程：

一个负责计算1-5000的素数

另外一个负责计算5001-10000

父进程负责存储

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>

int idx=0;
int fddata;
void handle(int s)
{
    int status;
    if(s==SIGCHLD)
    {
        wait(&status);
        idx++;
    
        if(idx==2)
        {
            close(fddata);
            printf("任务完成\n");
            exit(-1);
        }
    }
}

int isprimer(int ta)
{
    int i=2;
    
    for(;i<ta;i++)
    {
        if(ta%i==0)
        {
            return 0;
        }
    }
    return 1;
}

main()
{
    int a,b;
    int id=1;
    int fd[2];
    signal(SIGCHLD,handle);
    pipe(fd);

    while(1)
    {
        if(id==1)
        {
            a=2;b=50000;
        }

        if(id==2)
        {
            a=50001;b=100000;
        }

        if(fork())
        {
            id++;
            if(id>2)
            {
                break;
            }
            continue;
        }
        else
        {
            //子进程
            int i;
            close(fd[0]);
            
            for(i=a;i<=b;i++)
            {
                if(isprimer(i))
                {
                    write(fd[1],&i,sizeof(int));
                }
                sched_yield();
            }

            printf("%d任务完成!\n",getpid());
            exit(0);
        }
    }

    int re;
    char buf[20];

    //打开文件，准备存储
    close(fd[1]);
    fddata=open("result.txt",
    O_RDWR|O_CREAT,0666);

    while(1)
    {
        read(fd[0],&re,sizeof(int));
        sprintf(buf,"%d\n",re);
        write(fddata,buf,strlen(buf));
        sched_yield();
    }
}

补充：

sched_yield()会让出当前线程的CPU占有权，然后把线程放到静态优先队列的尾端，然后一个新的线程会占用CPU。那这个和sleep()有啥区别呢？

sched_yield()这个函数可以使用另一个级别等于或高于当前线程的线程先运行。如果没有符合条件的线程，那么这个函数将会立刻返回然后继续执行当前线程的程序。而sleep则是等待一定时间后等待CPU的调度，然后去获得CPU资源（这也是usleep()为什么不准的原因）。

那么什么时候使用sched_yield()呢？man手册是这么说的

有策略的调用sched_yield()能在资源竞争情况很严重时，通过给其他的线程或进程运行机会的方式来提升程序的性能。也就是说，调用sched_yield()能让你的当前线程让出资源，通过一定的策略调用sched_yield()满足你的业务要求可以保证各个线程或进程都有机会运行。