linux signal应用实例

最新推荐文章于 2024-07-25 11:18:30 发布
最新推荐文章于 2024-07-25 11:18:30 发布
阅读量341 收藏 10
点赞数 7
文章标签： linux 算法 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TONGTONGTOM/article/details/135761163
版权

5sec.c

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

int main()
{
    time_t end;
    int64_t count = 0;

    end = time(NULL) + 5;
    
    while (time(NULL) <= end)
        ++count;

    printf("%lld\n", count);

    exit(0);
}

5sec_sig.c

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

// volatile 去到真正存放这个值的地址取值，不要轻信内存空间的值
static volatile int loop = 1;

static void alrm_handler(int s)
{
    loop = 0;
}

int main()
{
    int64_t count = 0;

    //signal 在alarm之前使用
    signal(SIGALRM, alrm_handler);
    alarm(5);

    while (loop)
        ++count;

    printf("%lld\n", count);

    exit(0);
}

block.c

/* 信号屏蔽 */

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

static void int_handler(int s)
{
    write(1, "!", 1);

}

int main()
{
    int i, j;
    sigset_t set, oldset, saveset;

    signal(SIGINT, int_handler);
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigprocmask(SIG_UNBLOCK, &set, &saveset);

    for (j = 0; j < 1000; j++) {
        sigprocmask(SIG_BLOCK, &set, &oldset);
        for (i = 0; i < 5; i++) {
            write(1, "*", 1);
            sleep(1);
        }
        //sigprocmask(SIG_BLOCK, &set, NULL);

        //SIG_SETMASK 恢复到oldset
        sigprocmask(SIG_SETMASK, &oldset, NULL);
        write(1, "\n", 1);
    }

    sigprocmask(SIG_SETMASK, &saveset, NULL);

    exit(0);
}

mycat.c

/*
 *  实现cat功能
 *  加入信号机制
 */


#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#define BUFFSIZE 1024


int main(int argc, char **argv)
{
    int sfd, dfd = 1;
    char buf[BUFFSIZE];
    int len, ret, pos;

    if(argc != 2)
    {
        fprintf(stderr, "Usage...\n");
        exit(1);
    }
    
    do {
        sfd = open(argv[1], O_RDONLY);
        if(sfd < 0)
        {
            if (errno != EINTR) {
                perror("sfd_open()");
                exit(1);
            }
        }
    } while (sfd < 0);

    while(1)
    {
        len = read(sfd, buf, BUFFSIZE);
        if(len < 0)
        {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        } 
        else if (len == 0) 
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(dfd, buf + pos, len);
            if(ret < 0)
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
         }
    }

    close(sfd);

    exit(0);
}

mycp.c

/*
 *  实现复制功能
 *  加入信号机制
 */


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

#define BUFFSIZE 1024


int main(int argc, char **argv)
{
    int sfd, dfd;
    char buf[BUFFSIZE];
    int len, ret, pos;

    if(argc != 3)
    {
        fprintf(stderr, "Usage...\n");
        exit(1);
    }
    
    do {
        sfd = open(argv[1], O_RDONLY);
        if(sfd < 0)
        {
            if (errno != EINTR) {
                perror("sfd_open()");
                exit(1);
            }
        }
    } while (sfd < 0);

    dfd = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0644);
    do {
        if(dfd < 0)
        {
            if (errno != EINTR) {
                close(sfd);
                perror("dfd_open()");
                exit(1);
            }
        }
    } while (dfd < 0);

    while(1)
    {
        len = read(sfd, buf, BUFFSIZE);
        if(len < 0)
        {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        } 
        else if (len == 0) 
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(dfd, buf + pos, len);
            if(ret < 0)
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
         }
    }

    close(dfd);
    close(sfd);

    exit(0);
}

slowcat.c

/*
 *  实现cat功能
 *  加入信号机制
 *  每秒显示10个字符
 */


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

#define CPS      10
#define BUFFSIZE CPS

static volatile int loop = 0;

static void alrm_handler(int s)
{
    alarm(1);
    loop = 1;
}

int main(int argc, char **argv)
{
    int sfd, dfd = 1;
    char buf[BUFFSIZE];
    int len, ret, pos;

    if(argc != 2)
    {
        fprintf(stderr, "Usage...\n");
        exit(1);
    }
    

    signal(SIGALRM, alrm_handler);
    alarm(1);

    do {
        sfd = open(argv[1], O_RDONLY);
        if(sfd < 0)
        {
            if (errno != EINTR) {
                perror("sfd_open()");
                exit(1);
            }
        }
    } while (sfd < 0);

    while(1)
    {
        while(!loop)
            pause();
        loop = 0;


        while ((len = read(sfd, buf, BUFFSIZE)) < 0) {
            if (errno == EINTR)
                continue;
            perror("read()");
            //如果出错 只能跳出内部这个循环
            break;
        } 
        if (len == 0) 
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(dfd, buf + pos, len);
            if(ret < 0)
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
         }
        //sleep(1);
    }

    close(sfd);

    exit(0);
}

slowcat_settimer.c

/*
 *  实现cat功能
 *  加入信号机制
 *  
 *  使用setitimer()实现
 *  settimer工作机制是，先对it_value倒计时，当it_value为零时触发信号，
 *  然后重置为it_interval，继续对it_value倒计时，一直这样循环下去
 *  
 *  假如it_value为0是不会触发信号的，所以要能触发信号，it_value得大于0；
 *  如果it_interval为零，只会延时，不会定时（也就是说只会触发一次信号)。
 *
 *  显示效果：开始时10s后打印10个字符 以后每秒打印10个字符
 */


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


#define CPS      10
#define BUFFSIZE CPS

static volatile int loop = 0;

static void alrm_handler(int s)
{
    //alarm(1);
    loop = 1;
}

int main(int argc, char **argv)
{
    int sfd, dfd = 1;
    char buf[BUFFSIZE];
    int len, ret, pos;
    struct itimerval itv;

    if(argc != 2)
    {
        fprintf(stderr, "Usage...\n");
        exit(1);
    }
    

    signal(SIGALRM, alrm_handler);
    //alarm(1);
    
    itv.it_interval.tv_sec = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 10;
    itv.it_value.tv_usec = 0;

    if (setitimer(ITIMER_REAL, &itv, NULL) < 0) {
        perror("setitimer()");
        exit(1);
    }

    do {
        sfd = open(argv[1], O_RDONLY);
        if(sfd < 0)
        {
            if (errno != EINTR) {
                perror("sfd_open()");
                exit(1);
            }
        }
    } while (sfd < 0);

    while(1)
    {
        while(!loop)
            pause();
        loop = 0;


        while ((len = read(sfd, buf, BUFFSIZE)) < 0) {
            if (errno == EINTR)
                continue;
            perror("read()");
            //如果出错 只能跳出内部这个循环
            break;
        } 
        if (len == 0) 
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(dfd, buf + pos, len);
            if(ret < 0)
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
         }
        //sleep(1);
    }

    close(sfd);

    exit(0);
}

slowcat2.c

/*
 *  实现cat功能
 *  加入信号机制
 *  每秒显示10个字符
 *  积攒权限（输出字符）
 */


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

#define CPS      10
#define BUFFSIZE CPS
#define BURST    100

//sig_atomic_t 信号原子类型，这个类型的取值和赋值操作一条指令完成
static volatile sig_atomic_t token = 0;

static void alrm_handler(int s)
{
    alarm(1);
    ++token;
    if (token > BURST)
        token = BURST;
}

int main(int argc, char **argv)
{
    int sfd, dfd = 1;
    char buf[BUFFSIZE];
    int len, ret, pos;

    if(argc != 2)
    {
        fprintf(stderr, "Usage...\n");
        exit(1);
    }
    

    signal(SIGALRM, alrm_handler);
    alarm(1);

    do {
        sfd = open(argv[1], O_RDONLY);
        if(sfd < 0)
        {
            if (errno != EINTR) {
                perror("sfd_open()");
                exit(1);
            }
        }
    } while (sfd < 0);

    while(1)
    {
        while(token <= 0)
            pause();
        --token;

        while ((len = read(sfd, buf, BUFFSIZE)) < 0) {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        } 
        if (len == 0) 
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(dfd, buf + pos, len);
            if(ret < 0)
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
         }
        //sleep(1);
    }

    close(sfd);

    exit(0);
}

star.c

/* 信号初探 */

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

static void int_handler(int s)
{
    write(1, "!", 1);

}

int main()
{
    int i;

//    signal(SIGINT, SIG_IGN);
    signal(SIGINT, int_handler);
    for (i = 0; i < 10; i++) {
        write(1, "*", 1);
        sleep(1);
    }
    



    exit(0);
}

susp.c

/* 
 * 信号屏蔽 
 *  每行打印5个*，然后暂停等^C
 *  如果在中间收到了^C，那么下一行5个*也会继续打印
 *  
 */

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

static void int_handler(int s)
{
    write(1, "!", 1);

}

int main()
{
    int i, j;
    sigset_t set, oldset, saveset;

    signal(SIGINT, int_handler);
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigprocmask(SIG_UNBLOCK, &set, &saveset);
    sigprocmask(SIG_BLOCK, &set, &oldset);
    for (j = 0; j < 1000; j++) {
        for (i = 0; i < 5; i++) {
            write(1, "*", 1);
            sleep(1);
        }
        //sigprocmask(SIG_BLOCK, &set, NULL);

        //SIG_SETMASK 恢复到oldset
        write(1, "\n", 1);
        sigsuspend(&oldset);
        /*
        sigset_t tmpset;
        sigprocmask(SIG_SETMASK, &oldset, &tmpset);
        pause();
        sigprocmask(SIG_SETMASK, &tmpset, NULL);
        */
    }

    sigprocmask(SIG_SETMASK, &saveset, NULL);

    exit(0);
}

susp_rt.c

/* 
 * 信号屏蔽 
 *  每行打印5个*，然后暂停等^C
 *  如果在中间收到了^C，那么下一行5个*也会继续打印
 *  
 *  实时信号实现
 *  实时信号不丢失 :
 */

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

#define MYRTSIG     (SIGRTMIN+6)

static void mysig_handler(int s)
{
    write(1, "!", 1);

}

int main()
{
    int i, j;
    sigset_t set, oldset, saveset;

    signal(MYRTSIG, mysig_handler);
    sigemptyset(&set);
    sigaddset(&set, MYRTSIG);
    sigprocmask(SIG_UNBLOCK, &set, &saveset);
    sigprocmask(SIG_BLOCK, &set, &oldset);
    for (j = 0; j < 1000; j++) {
        for (i = 0; i < 5; i++) {
            write(1, "*", 1);
            sleep(1);
        }
        //sigprocmask(SIG_BLOCK, &set, NULL);

        //SIG_SETMASK 恢复到oldset
        write(1, "\n", 1);
        sigsuspend(&oldset);
    }

    sigprocmask(SIG_SETMASK, &saveset, NULL);

    exit(0);
}

TONGTONGTOM
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Linux信号透彻分析与理解
01-11 1万+
本文将从以下几个方面来阐述信号:(1)信号的基本知识(2)信号生命周期与处理过程分析(3) 基本的信号处理函数(4) 保护临界区不被中断(5) 信号的继承与执行(6)实时信号中锁的研究第一部分: 信号的基本知识1.信号本质:信号的本质是软件层次上对中断的一种模拟。它是一种异步通信的处理机制，事实上，进程并不知道信号何时到来。2.信号来源(1)程序错误，如非法访问内存(2)外部信号，如按下了CTRL+C(3)通过kill或sigqueue向另外一个进程发送信号3.信号种类信号分为可靠信号与不可靠信号,可靠信号
linux 信号量使用实例
轨迹
11-21 2902
<br />信号量是一种睡眠锁。它是实现同步操作，防止竟态的方式之一。任何进程在对共享数据进行读写操作之前必须获得用来保护共享数据的信号量，否则不能供访问权限，信号量会把这个访问进程放进一个等待队列中（这个等待队列是在信号量初始化过程中被初始化的），然后让其进入睡眠状态。这是处理器重新调度，去执行其他进程的操作。保护共享数据的信号量被释放，被这个信号量放进等待队列的进程会被激活，获得该信号量，然后对共享数据进行访问。<br /><br />下面的代码演示了在设备驱动程序的读写操作中，信号量的使用<br />
linux系统编程之信号(signal)的使用方法案例
qq_30143193的博客
11-08 1425
linux中信号的扫盲学习：包括signal注册，sigaction的注册，pause的使用，alarm的使用，信号集的使用，信号的可靠性和不可靠性验证，信号在进程的数据传送等！
Linux信号signal的介绍和示例
C语言技术网-码农有道
08-07 1901
如何让程序在后台运行 在之前的章节中，如果要运行程序，在命令提示行下输入程序名后回车，程序被执行，然后等待程序运行完成。在程序运行的过程中，可以用Ctrl+c中止它。 在实际开发中，我们需要让程序在后台运行，不受界面的影响，也不让程序员等待，例如前几章节的socket服务端程序。 如果想让程序在后台运行，有两种方法。 1、加“&”符号...
进程与信号（四）
06-10 1790
线程Linux进程可以协作，可以发送消息，也可以中断另一个进程。他们甚至可以在彼此之间共享内存段，但是在操作系统内部他们却是完全不同的实体。他们并不能共享变量。在许多Unix系统与Linux系统还有另一类名为线程的进程。线程在某些程序中具有巨大的价值，例如多线程数据库服务器，然而线程很难进行编程。Linux上的线程编程并不如使用多进程那样常见，因为Linux的进程是轻量级的
linux. signal信号,Linux下signal信号汇总
weixin_33721696的博客
05-14 666
SIGHUP /* Hangup (POSIX). */ 终止进程 终端线路挂断SIGINT /* Interrupt (ANSI). */ 终止进程 中断进程 Ctrl+CSIGQUIT ...
Linux信号的使用
Serendipity_00的博客
11-25 764
信号1.1概念1.2信号分类1.2信号的产生1.3信号的响应方式修改信号的响应方式信号的发送 1.1概念 信号：操作系统预先定义好的某些特定的事件，信号可以被产生，也可以被接收。产生和接收的主体都是进程。（一个进程向另一个进程通知某一个事件的发生）。 kill -l//查看所有信号 1~34为普通信号，不存在（0，32，33号信号），34以上为实时信号 Linux系统平台上信号的定义： 每个信号都有一个编号和一个宏定义名称，这些宏定义可以在系统调用signal.h找到。 常见信号的值及对应功能。
Python中常用信号signal类型实例
01-20
本文研究的主要是Python中的... SIGKILL 终止进程 杀死进程，不可捕捉(相当于linux下的kill命令，windows下使用会抛出异常) SIGALRM 闹钟信号 可以通过signal.alarm()和os.kill()发送该信号，可通过signal.signal()捕
Linux 信号signal处理机制
05-24
5. 实例应用： - 当程序出现段错误（如访问无效内存）时，系统自动发送`SIGSEGV`，若未注册自定义处理函数，则进程终止。 - 用户按下Ctrl+C，系统发送`SIGINT`，若程序未处理，通常会退出。 - `SIGCHLD`信号用于...
Linux信号(signal)机制.rar
11-16
在Linux操作系统中，信号（Signal）是一种异步通信机制，用于通知进程发生了某些事件或条件。它是进程间通信（IPC, Inter-Process Communication）的一种基本方式，尤其在处理错误、异常或者时间间隔等事件时非常...
Linux-application-development.rar_Linux编程实例
09-21
通过逐个研究这些实例，初学者能够逐步积累经验，深化对Linux应用开发的理解。 总之，"Linux-application-development.rar" 提供的资源覆盖了Linux编程的关键知识点，通过深入学习和实践，初学者可以逐步建立起坚实...
使用Python编写Linux系统守护进程实例
09-22
本文将深入探讨如何使用Python语言编写Linux守护进程，并解释相关的关键概念和技术。 首先，理解守护进程的基本概念至关重要。守护进程，也称为后台进程，是在多任务操作系统中运行的程序，不与任何终端直接关联，...
Linux中signal的种类和用法
yikunbai5708的博客
10-03 5390
目录 1、signal信号详解 1.1 信号列表 1.2 信号详解 2、信号的来源 2.1 信号来自内核， 生成信号的请求来自以下3个地方。 2.2 信号捕获处理 2.3 信号处理例子 3、sigaction函数使用 3.1 函数原型 3.2 struct sigaction结构体介绍 3.3 例子 1、signal信号详解 1.1 信号列表 列表中，编号...
linux signal信号处理过程与机制--完全实例讲解
奔跑的路
08-20 9645
信号是Linux编程中非常重要的部分，本文将详细介绍信号机制的基本概念、Linux对信号机制的大致实现方法、如何使用信号，以及有关信号的几个系统调用。  信号机制是进程之间相互传递消息的一种方法，信号全称为软中断信号，也有人称作软中断。从它的命名可以看出，它的实质和使用很象中断。所以，信号可以说是进程控制的一部分。  一、信号的基本概念  本节先介绍信号的一些基本概念，然后给出一
Linux信号来源和捕获处理以及signal函数简介
爱拼才会赢
09-06 1万+
1、信号是什么？信号本质是什么？      日常生活中，绿灯是一个信号，停止标牌是一个信号，裁判手势也是一个信号。      信号本质（计算机）：软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。在软件层次上是对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是进程间通信机制中唯一的异步通信机制，一个进程不必通过任何操作来等待信号的到...
linux signal 处理
热门推荐
企鹅的自我修养
06-18 3万+
源地址：http://blog.csdn.net/zhuixundelang/article/details/5979465 linuxsignal 处理   说明: 本文主要翻译自ULK 3rd chapter 11. 主要受 http://blog.csdn.net/yunsongice 影响,故发表在csdn. 另外,本文是最初版本,估计以后会有一个改进版本. 文中还有很多
王保明老师Linux学习笔记---------信号----signal（）函数使用实例
H002399的专栏
10-19 1088
信号编程实例： #include #include #include #include void handler(int num) { printf("recv num:%d \n",num); if(num==SIGQUIT)//这个函数的参数是一个信号值，是由终端发送给内核，然后内核传递给进程的handler()函数。 { exit(0); } el
Windows 下的sqlserver数据拷贝到linux
最新发布
cyw8998的专栏
07-25 283
2.在 >1 提示符下，输入以下 RESTORE DATABASE 命令，并在每行后按 Enter（无法同时复制和粘贴整个多行命令）。将出现的所有 gpdb 替换为数据库的名称。1.启动 sqlcmd。下面的示例以 SA 用户身份连接到本地 SQL Server。出现提示时输入密码，或使用 -P 参数指定密码。SSH打开linux终端。
嵌入式Linux应用开发实验手册：初学者入门指南
实验4-3是关于信号处理的一个实例，目的是让学习者学会如何定义和使用自定义的信号处理函数来处理特定的信号，例如SIGBUS。SIGBUS信号通常在访问无效内存地址或对硬件错误做出响应时被操作系统发送。实验要求学生在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值