C++学习：第六章Linux高级编程 - （六）进程控制、信号、定时器、信号操作、信号屏蔽

最新推荐文章于 2024-01-05 17:26:17 发布
最新推荐文章于 2024-01-05 17:26:17 发布
阅读量240 收藏
点赞数
分类专栏： C++
共享知识，欢迎转载
本文链接：https://blog.csdn.net/kakiebu/article/details/108685522
版权

问题解答：

     1. exit(状态码)返回状态码有什么意义?

          返回值被系统得到.系统根据状态码进行日志记录.

          返回值被调用者得到：system/wait.程序会根据返回状态码进行对应处理。

          exit(状态码)=main函数中的return 状态码;

     2. 状态码的第二个字节才是exit()的返回值或者return值。

一、 进程的基本控制

     1. 进程的常见控制函数

          1.1 为什么需要控制进程?

          1.2 pause/sleep/usleep（精确到微秒的sleep）

          1.3 atexit  on_exit           回调函数

     程序在结束前会回调fun函数

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

void fun()
{
    printf("over\n");
}

int main()
{
    atexit(fun);
    printf("Process!\n");

    return 0;
}

     2. 进程与文件锁

          在多进程下文件读写是共享的

     问题：

          怎么知道一个文件正在被另外进程读写？

     解决方案：

          文件锁。(建议锁)

     API：

          fcntl（文件锁受内核参数影响）

     编程技巧：

          对文件加锁

          判定一个文件是否存在锁

     函数说明：

int fcntl(
    int fd,    //被加锁的文件描述符号
    int cmd, //锁的操作方式:F_SETLK(已经加锁，异常返回)
    F_UNLK F_SETLKW(已经加锁，则阻塞等待)
    struct flock *lk);  //锁的描述

返回值：
    0：加锁成功
    -1：:加锁失败

案例：

写两个程序：

A：加锁

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

main()
{
    int fd;
    struct flock lk;
    int r;

    //打开一个文件
    fd=open("a.txt",O_RDWR);
    if(fd==-1) printf(":%m\n"),exit(-1);

    //描述锁
    lk.l_type=F_WRLCK;//锁的类型，写锁
    lk.l_whence=SEEK_SET;//锁的参照位置，绝对位置
    lk.l_start=5;//锁的开始，第5个字节开始
    lk.l_len=10;//锁的长度，10个字节

    //锁的进程ID，系统定义

    //加锁
    r=fcntl(fd,F_SETLK,&lk);//加锁
    if(r==0) printf("加锁成功！\n");
    else printf("加锁失败！\n");
    while(1);      

    //程序退出后系统会自动解锁
}

B：获取锁的信息

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

main()
{
    int fd;
    struct flock lk={0};//不初始化得到的信息会有误
    int r;

    //打开一个文件
    fd=open("a.txt",O_RDWR);
    if(fd==-1) printf(":%m\n"),exit(-1);

    r=fcntl(fd,F_GETLK,&lk);//获取锁的信息
    if(r==0) printf("得到锁成功！\n");
    if(lk.l_type==F_WRLCK)
    {
        printf("写锁 \n");
    }

    printf("PID : %d \n", lk.l_pid);//加锁的进程id
}

锁也是一个进程可以共享的信息。

二、 信号

     1. 信号的作用

     背景：

          进程之间通信比较麻烦，但进程之间有必须通信，比如父子进程之间。

     作用：

          通知其他进程响应。进程之间通信机制。

     信号：

          接受信号的进程马上停止，调用信号处理函数。

     信号处理函数：

          默认处理函数：打印信号信息，退出进程。

          用户处理函数。

     中断：（硬件的处理）把当前所有任务停止下来去处理当前信号任务

          信号的终端处理是假的，称软中断。

     案例：

          1. 进程之中，默认信号处理

          2. 进程之中，用户信号处理

          3. 中断

               kill  -s    信号      进程ID

               kill  -信号            进程ID

               信号表达方式：

                    数字形式     1-31和34-64

                    宏的方式     SIGINT=2

                    其中ctrl+c 发送的信号就是2（ SIGINT）

                    kill -l察看所有信号

                    信号SIGKILL   SIGSTOP不能被处理.

              案例：

             发送信号

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

void handle(int s)
{
    printf("我是信号发生！\n");  
}


main()
{
    signal(SIGINT,handle);

    while(1)
    {
        printf("进程在执行:%d!\n",getpid());
        sleep(1);
    }
}

     控制台每次输入 Ctrl+c 就会输出 我是信号发生！ ，同样可以使用kill  -SIGINT      进程ID

 

     案例：使用程序发送信号

          int kill(pid_t pid,int s)

          进程ID（pid）:

          >0：发送信号到指定进程

          =0：发送信号到该进程所在进程组的所有进程

          -1：发送给所有进程，除init外

          <0：发送给指定的进程组(组ID=绝对值)

     2. 信号发送与安装

     signal

     kill

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

main()
{

    while(1)
    {
        kill(4601,SIGINT);
        sleep(2);
    }
}

     3. 信号的应用

          3.1.延时器timeout

               SIGALRM（名字）

               信号发出函数:alarm

               unsigned int alarm(unsigned int seconds);

               只向本进程发送信号，不向其他进程发送信号。

               一个函数能绑定多个信号，一个信号只能绑定一个函数

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>

void deal(int s)
{
    printf("起床!\n");
}

main()
{
    signal(SIGALRM,deal);
    alarm(5);
    while(1)
    {
        //.....
    }
}

          3.2.定时器

               int setitimer(int which,      //计时方式：

                    //ITIMER_REAL      自然界真实时间作为计时方式，推荐

                    //ITIMER_VIRTUA  由程序实际运行时间作为计时方式

                    //ITIMER_PROF       系统执行和进程执行混合计时方式

                    const struct itimerval *val,       //定时器的时间参数

                    struct itimer *oldval); //返回原来设置的定时器

          //如果=NULL，则不返回

                    struct itimerval{

                          struct timeval it_interval;  //间隔时间

                         struct timeval it_value;            //延时时间

                    }

                    struct timeval{

                         long tv_sec;  //秒

                         long tv_usec;       //微妙

                    }

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>

void deal(int s)
{
printf("起床!\n");
}

main()
{
    struct itimerval v={0};
    signal(SIGALRM,deal);

    //v.it_value.tv_sec=3;
    v.it_value.tv_sec=0;
    v.it_value.tv_usec=1;
    v.it_interval.tv_sec=1;

    //alarm(5);
    setitimer(ITIMER_REAL,&v,0);

    while(1)
    {
        //.....
    }
}

          3.3 信号应用:

               系统与应用程序之间

               应用于应用程序之间

               父子进程之间

          案例1：

               使用定时器信号，实现多任务。

          实现：

               实现7位随机数

          使用中断实现时间的显示

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <curses.h>
#include <math.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>

WINDOW *wtime,*wnumb;
int num,i;

void showtime(int s)
{
    time_t tt;
    struct tm *t;

    if(s==SIGALRM)
    {
        tt=time(0);
        t=localtime(&tt);
        mvwprintw(wtime,1,1,"%02d:%02d:%02d",t->tm_hour,t->tm_min,t->tm_sec);

        refresh();
        wrefresh(wtime);
        wrefresh(wnumb);//¿ÉÑ¡
    }
}

main()
{
    struct itimerval val;
    initscr();
    curs_set(0);
    signal(SIGALRM,showtime);

    bzero(&val,sizeof(struct  itimerval));
    val.it_value.tv_sec=0;
    val.it_value.tv_usec=1;
    val.it_interval.tv_sec=1;

    wnumb=derwin(stdscr,3,11,(LINES-3)/2,(COLS-11)/2);
    wtime=derwin(stdscr,3,10,0,COLS-10);

    box(wnumb,0,0);
    box(wtime,0,0);
    setitimer(ITIMER_REAL,&val,0);

    refresh();
    wrefresh(wtime);
    wrefresh(wnumb);

    while(1)
    {
        num=0;
        for(i=0;i<7;i++)
        {
            num=num*10+rand()%10;
        }

        mvwprintw(wnumb,1,2,"%07d",num);

        refresh();
        wrefresh(wnumb);
        wrefresh(wtime);
        usleep(10000);
    }

    endwin();
}

     案例2：

          实现父子进程之间通信

          控制进程。

          sleep与pause函数被信号影响后，sleep不再继续sleep，pause不再pause.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <curses.h>
#include <math.h>

WINDOW *w;
int num,i;
int isstop=0;

void handle(int s)
{
    if(s==SIGUSR1)
    {
        if(isstop==0)
        {
            isstop=1;
        }
        else
        {
            isstop=0;
        }
    }
}

main()
{
    initscr();
    curs_set(0);//隐藏光标
    w=derwin(stdscr,3,11,(LINES-3)/2,(COLS-11)/2);//创建子窗体

    keypad(stdscr,TRUE);
    keypad(w,TRUE);
    noecho();//禁止输入回显
    box(w,0,0);//给子窗体加边框

    refresh();
    wrefresh(w);

    if(fork())
    {
        signal(SIGUSR1,handle);
        while(1)//显示7位数的随机数
        {
            if(isstop==1)
            {
                pause();//pause会被信号中断停止 ***
            }

            num=0;
            for(i=0;i<7;i++)//产生7位随机数
            {
                num=num*10+rand()%10;
            }

            mvwprintw(w,1,2,"%07d",num);//显示随机数
            refresh();//刷新屏幕。
            wrefresh(w);
            usleep(10000);//暂停10毫秒
        }
    }
    else//child
    {
        //输入
        int ch;
        while(1)//处理按键
        {
            ch=getch();
            //if(ch==KEY_ENTER)
            {
                kill(getppid(),SIGUSR1);
            }
        }
    }
    endwin();
}

     练习：

     在curses显示7位随机数

          其他信号函数

          raise

     4. 信号的可靠与不可靠以及信号的含义

          信号有丢失。(信号压缩)

          由于历史的缘故：信号有压缩的需求.

          可靠信号(实时信号)与不可靠信号(非实时信号).

          早期信号 1-31 31个信号，不可靠(与系统有关).

          后期信号34-64 31个信号，可靠信号(用户信号)       

     5. 信号的操作

          信号导致的问题

          5.1 信号屏蔽    

               int sigprocmask(int how,         //操作方式

                    SIG_BLOCK         //

                    SIG_UNBLOCK   //

                    SIG_SETMASK    //

                    const sigset_t *sigs,   //操作的信号集合

                    sigset_t *oldsigs);             //返回原来操作的信号集合

               5.1.1.声明信号集合

                    sigset_t  sigs;

               5.1.2 加入屏蔽信号

                    一组信号集合维护函数:

                    1. 清空集合                            sigemptyset

                    2. 添加信号到集合         sigaddset

                    3. 从集合删除信号         sigdelset

                    4. 添加所有信号到集合 sigfillset

                    5. 判定信号是否在集合 sigismember

             5.1.3 屏蔽信号

             5.1.4 解除屏蔽

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

void h(int s)
{
    printf("抽空处理int信号\n");
}

main()
{
    int sum=0;
    int i;

    //1.
    signal(SIGINT,h);
    sigset_t sigs,sigp,sigq;

    //2.
    sigemptyset(&sigs);
    sigemptyset(&sigp);
    sigemptyset(&sigq);
    sigaddset(&sigs,SIGINT);

    //3.
    sigprocmask(SIG_BLOCK,&sigs,0);
    for(i=1;i<=10;i++)
    {
        sum+=i;
        sigpending(&sigp);//返回在阻塞期间接收到阻塞信号的集合
        if(sigismember(&sigp,SIGINT))
        {
            printf("SIGINT在排队!\n");
            sigsuspend(&sigq);
            //彩色字体部分控制中断位置在此
            //使原来屏蔽信号无效，开放原来信号
            //使新的信号屏蔽,
            //当某个信号处理函数处理完毕
            //sigsuspend恢复原来屏蔽信号，返回
        }
        sleep(1);
    }
    printf("sum=%d\n",sum);
    sigprocmask(SIG_UNBLOCK,&sigs,0);
    printf("Over!\n");
}

          5.2 信号屏蔽的切换

               int sigsuspend(sigset_t *sigs);

                    屏蔽新的信号，原来的信号失效.

               sigsuspend

                    是阻塞函数，对参数信号屏蔽。

                    对参数没有指定的信号不屏蔽，但当没有屏蔽信号处理函数调用完毕

               sigsuspend返回条件：

                    信号发生，并且信号是非屏蔽信号

                    信号必须要处理，而且处理函数返回后 sigsuspend才返回。

                    sigsuspend放在sigprocmask函数后使用时，sigsuspend设置新的屏蔽信号，保存旧的屏蔽信号。而且当sigsuspend返回的时候，会自动恢复sigprocmask旧的屏蔽信号。

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

void h(int s)
{
    printf("非屏蔽信号发生！\n");
}

main()
{
    sigset_t sigs;

    signal(SIGWINCH,h);
    sigemptyset(&sigs);
    sigaddset(&sigs,2);

    printf("屏蔽开始!\n");
    sigsuspend(&sigs);
    printf("屏蔽结束!\n");
}

          5.3 查询被屏蔽的信号

               int sigpending(sigset_t *sets);

     回顾：

  1. 进程控制sleep pause
  2. 理解信号的中断流程
  3. 发射信号(Shell/code),处理信号
  4. alarm与setitimer
  5. 信号应用:实现简单多任务与进程之间通信
  6. 使用信号+sleep/pause控制进程
  7. 信号的屏蔽
  8. 了解sigpending与 sigsuspend的使用.

思考:

              信号处理函数调用过程中,是否被其他信号影响.

Thomas会写字
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 信号处理
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-21 333
C++ 信号处理 信号是由操作系统传给进程的中断，会提早终止一个程序。在 UNIX、LINUX、Mac OS X 或 Windows 系统上，可以通过按 Ctrl+C 产生中断。 有些信号不能被程序捕获，但是下表所列信号可以在程序中捕获，并可以基于信号采取适当的动作。这些信号是定义在 C++ 头文件 中。 信号描述 SIGABRT程序的异常终止，如调用 abort。 SIGFPE错误的算术运算，...
C++多核高级编程-多进程
01-27
进程是由操作系统创建的工作单元。值得注意的是进程和程序未必是等同的。一个程序可能由多个任务组成，而每个任务可以和一个或多个进程相关联。程序是由程序员创建的，而进程是由操作系统创建的。一个工作单元要想被称作进程，它必须要有操作系统指派给他的地址空间，必须拥有进程ID，必须拥有状态和进程表中的表项。进程和线程之间最大的区别是进程有着自己的地址空间，而线程共享创建它们的进程的地址空间。 在将C++任务映射为操作系统能够理解的执行单元时，结果证明线程更易于编程，其主要原因是线程共享相同
linux 禁用日志,清除linux系统日志,禁用linux系统日志,删除linux日志
weixin_36147027的博客
05-02 324
/var/log/这下面的东东,就是各日志记录文件,但这些文件日志存储是由/etc/syslog.conf 配置的,可以修改存储地,不记录任何日志可以用vi syslog.conf打开,用dd清空每行内容,用:命令结束编辑,用wq退出!再用less命令查看文档less syslog.conf查看是否修改好,按esc,再按wq退出查看!还可用rm -r 文件名方式删除/var/log/下的日志文件,...
linux高级编程day06 笔记
weixin_34311757的博客
08-22 95
问题解答：1.exit(状态码)返回状态码有什么意义?返回值被系统得到.系统根据状态码进行日志记录.返回值被调用者得到：system/wait.程序会根据返回状态码进行对应处理。exit(状态码)=main函数中的return 状态码;2.状态码的第二个字节才是exit()的返回值或者return值。 一.进程的基本控制1.进程的常见控制函数1.1.为什么需要...
Linux C++ 通信 - 信号集(信号屏蔽字)的简单认知
m0_46684679的博客
08-03 340
简单写写信号集，暂时不写sigprocmask
信号屏蔽函数
张同光 (Tongguang Zhang)：Hello everyone !
03-30 629
http://blog.163.com/hzr163_2004/blog/static/3308607520106254328196/ void InstalSignal(){    signal(SIGHUP ,SIG_IGN); /* hangup, generated when terminal disconnects */    signal(SIGINT ,SIG_IGN); /* in
linux-C信号处理函数
深未来技术
09-17 259
#include &lt;stdio.h&gt; #include &lt;unistd.h&gt; #include &lt;signal.h&gt; void catch_int(int sig_num){ signal(SIGINT,catch_int);//再次设置信号回调函数。ctrl+c：INT信号,ctrl+Z：挂起,TSTP信号.ctrl+\:发送BRT信号,进程立...
Linux高级编程 第六章 进程控制 信号 定时器 信号操作 信号屏蔽
学峰的学习笔记
04-30 574
Linux高级编程  第六章   此处为截图  原文件下载地址：
Linux C/C++编程之（十八）信号产生和处理
种树最好的时间是10年前，其次是现在！！！
07-08 6780
文章目录一、概述二、信号详解1. 信号的概念2. 信号的机制3. 与信号相关的事件和状态4. 信号的处理方式5. 信号的编号6. 信号4要素7. Linux常规信号一览表8. 信号的产生9. 信号集操作函数 一、概述 二、信号详解 1. 信号的概念 信号在我们的生活中随处可见， 如：古代战争中摔杯为号；现代战争中的信号弹；体育比赛中使用的信号枪…他们都有共性： 1） 简单 2）不能携带大量信息 3）满足某个特设条件才发送。 信号是信息的载体，Linux/UNIX 环境下，古老、经典的通信方式， 现下依然
05--Linux系统编程-信号.pdf
10-08
Linux开发
Linux 下C++共享内存、信号量封装，实现进程同步
06-17
Linux 下C++共享内存、信号量封装，实现进程同步
Linux信号编程课件与实验代码.rar
05-01
Linux信号编程课件与实验代码 包含课程PPT，实验报告，实验源码。
Linux学习之系统编程5(信号）
最新发布
yourgrandfather_的博客
01-05 1068
本文详细介绍了Linux系统中的信号相关的概念和函数。我会详细讲解每一个函数，从参数，返回值，注意事项等多个方面解读，并且配有图片帮助你理解，而且对于每一个函数我都会几个小demo来演示，提供源代码。还不赶紧点进来学习！！！
MFC 点击其他进程的按钮，编辑Edit对话框值
Thomas会写字
01-29 480
跨进程控制的基本思路：MFC消息机制 使用函数 PostMessage（阻塞） / SendMessage（非阻塞） 点击按钮 其他进程主窗口指针pWnd->PostMessage(WM_COMMAND, MAKEWPARAM(ID, BN_CLICKED), (LPARAM)pDlg->hWndLoad); 这里最后一个参数可以设置为NULL，但是有些对话框会设置一些安全信息来验证消息。 设置Edit对话框内容 ::SendMessage(Edit控件hWnd, WM_SETTEX
C++学习：第六章Linux高级编程 - （四）文件映射、文件描述符、curses
Thomas会写字
09-18 444
IO与文件映射 IO的共享与效率 read与write其中数据缓冲的大小 读取数据的缓冲：getpagesize。一般用它的返回值大小设置为缓冲大小就可以，也可以为一个页大小。 定位与定位读取(随机读取) read与write在操作的时候，自动移动读取位置. lseek改变读取位置. pread/pwrite在指定位置读写。 ssize_t pread(intfd, void *buf, size_tcount, off_toffset); ssize_t pwrite(intfd, const
C++学习：第二章C语言基础 - （十四）指针
Thomas会写字
09-28 441
  1. 地址与指针 首先要明白，每个变量存放都有一个唯一的内存编码，成为该变量的存放地址 而存放地址类型的变量则称为指针，有些地方就直接把地址成为指针，这点需要注意下 地址不是孤立的，总是伴随着变量类型， #include &lt;stdio.h&gt; int main(){ char x[9] = {'a', 'b', 'c', 'd', 'e', 'f', 'g',...
C++学习：第二章C语言基础 - （十五）主方法参数
Thomas会写字
09-30 409
main(int argc, char* argv[]) int argc              形参， 接受shell传来的参数，接受命令行有几个字符串即字符串的个数 char* argv[]     形参， 接受shell传来的参数，接受命令行的命令符，即该字符串是什么 #include&lt;stdio.h&gt; int main(int argc, char* argv[]...
C++学习：第六章Linux高级编程 - （八）共享内存、消息队列、Socket、Socket编程模型
Thomas会写字
10-27 408
Day09 信号量同步、socket网络编程基础、TCP、UDP 信号量(同步) 回顾： 一个进程控制另外一个进程. 逻辑变量+pause/sleep+信号 信号量(semaphore)信号灯 三个数据：红灯/绿灯/黄灯 60 90 10 信号量是共享内存整数数组，根据需要定义指定的数组长度 信号量就是根据数组中的值，决定阻塞还是解除阻塞 编程 3.1 创建或者得到信号量 semget 3.2 初始化信号量中指定下标的值 semctl 3.3 根据信号量阻塞或者解除阻塞 se...
android c++高级编程----使用ndk pdf
07-24
NDK是一个工具集，它允许开发者在Android应用中嵌入本地代码，并且提供了一系列的开发工具和库，以便开发者能够在Android应用中使用C/C++进行高级编程。使用NDK可以提供更高的性能和更低的内存占用，适用于需要处理...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值