APUE笔记七

最新推荐文章于 2024-07-21 21:27:58 发布
最新推荐文章于 2024-07-21 21:27:58 发布
阅读量84 收藏
点赞数
文章标签： 数据结构与算法
原文链接：https://my.oschina.net/voler/blog/337347
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

1. 信号基础

    信号是软件中断，提供了一种处理异步事件的方法。由于产生信号的事件对进程而言是随机出现的，所以进程不能简单的测试一个变量来判别是否出现了一个信号，而是必须告诉内核“在此信号出现时，请执行以下操作”。一般按以下三种方式操作：

1） 忽略此信号。

2） 捕捉信号

3） 执行系统默认动作。


2. signal函数

简单的signal接口定义如下： 

void (*signal(int signo, void (*func)(int)))(int);
    signo参数是信号名。func的值是常量SIG_IGN,SIG_DFL或当接到此信号后要调用的函数的地址。如果指定SIG_IGN,则向内核表示 忽略此信号。如果指定SIG_DFL，则表示接到此信号后的动作是系统默认动作。当指定函数地址时，则在信号发生时，调用此函数（信号处理函数） 
#include <signal.h>
#include <stdio.h>

static void sig_usr( int );

int main( void )
{
        if ( signal( SIGUSR1, sig_usr ) == SIG_ERR )
                printf("can't catch SIGUSR1\n");
        if ( signal( SIGUSR2, sig_usr ) == SIG_ERR )
                printf("can't catch SIGUSR2\n");
        for ( ; ; )
                pause();

        return 0;
}

static void sig_usr( int signo )
{
        if ( signo == SIGUSR1 )
                printf("received SIGUSR1\n");
        else if ( signo == SIGUSR2 )
                printf("received SIGUSR2\n");
        else{
                printf("received signal %d\n", signo );
        }
}
程序输出：


3. 中断的系统调用

    早期UNIX系统的一个特性是：如果进程在执行一个低速系统调用而阻塞期间捕捉到一个信号，则该系统调用就被中断不再继续执行。该系统调用返回出错，其error被设置为EINTR。低速系统调用是可能会使进程永远阻塞的一类系统调用，它们包括：

1） 在读某些类型的文件（管道，终端设备以及网络设备）时，如果数据并不存在则可能会使调用者永远阻塞。

2） 在写这些类型的文件时，如果不能立即接受这些数据，则也可能会使调用者永远阻塞。

3） 打开某些类型文件，在某种条件发生之前也可能会使调用者阻塞。

4） pause和wait函数

5） 某些ioctl操作

6） 某些进程间通信函数

    与被中断的系统调用相关的问题是必须显式的处理出错返回。


4. 可重入函数

    不可重入函数的含义是：如果信号处理程序和主程序中调用相同的函数，则会造成内部指针出错。通常不可重入的函数原因如下：1）已知它们使用静态数据结构。2）它们调用malloc或free。3）它们是标准I/O函数。 

#include <stdio.h>
#include <pwd.h>
#include <signal.h>
static void my_alarm( int signo )
{
        struct passwd   *rootptr;
        printf("in signal handler\n");
        if ( ( rootptr = getpwnam( "root" ) ) == NULL )
                printf("getpwnam(root) error\n");
        alarm( 1 );
}

int main( void )
{
        struct passwd   *ptr;
        signal( SIGALRM, my_alarm );
        alarm(1);
//      sleep( 2 );
        printf("out signal handler\n");
        for( ; ; ){
                if (( ptr = getpwnam("leichaojian")) == NULL)
                        printf("getpwnam error\n");
                if ( strcmp(ptr->pw_name,"leichaojian") != 0 )
                        printf("return value corrupted! pw_name=%s\n", ptr->pw_name);
        }
        return 0;
}
    正常情况下，程序应该每个一秒输出：in signal handler，但实际上却是中断，停留在终端阻塞上了：


5. SIGCLD语义

    对于SIGCLD早期处理如下：

1） 如果进程特地的设置该信号的配置为SIG_IGN,则调用进程的子进程将不会产生僵死进程。

2） 如果将SIGCLD的配置设置为捕捉，则内核立即检查是否有子进程准备好被等待，如果有则调用SIGCLD处理程序。


6. kill和raise函数

    kill函数将信号发送给进程或进程组。raise函数则允许进程向自身发送信号。 

#include <signal.h>
int kill( pid_t pid, int signo );
int raise( int signo );

raise( signo ) == kill( getpid(), signo )

kill的pid参数有4种不同的情况：

1） pid>0: 将该信号发送给进程ID为pid的进程

2） pid==0: 将该信号发送给与发送进程属于同一进程组的所有进程，而且发送进程具有向这些进程发送信号的权限。

3） pid<0: 将该信号发送给其进程组ID等于的绝对值，而且发送进程具有向其发送信号的权限。

4） pid==-1: 将该信号发送给发送进程有权限向它们发送信号的系统上的所有进程。


7. alarm和pause函数

    使用alarm函数可以设置一个计时器，在将来某个特定的时间该计时器会超时。当计时器超时时，产生SIGALRM信号。如果不忽略或不捕捉此信号，则其默认动作是终止调用该alarm函数的进程。

1） sleep的简单而不完整的实现 

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

static void sig_alrm( int signo )
{

}

unsigned int sleep1( unsigned int nsecs )
{
        if ( signal( SIGALRM, sig_alrm ) == SIG_ERR )
                return ( nsecs );
        alarm( nsecs );
        pause();
        return ( alarm( 0 ) );//turn off timer,return unslept time
}
~

    此函数有以下三个问题：

1） 如果在调用sleep1之前，调用者已设置了闹钟，则它会被sleep1函数中的第一次alarm调用擦除。

2） 该程序中修改了对SIGALRM的配置。如果编写了一个函数供其他函数调用，则在该函数被调用时先要保存原配置，在该函数返回前再恢复原配置。

3） 在第一次调用alarm和调用pause之间有一个竞争条件。在繁忙的系统种可能在pause调用之前超时了，则调用者永远被挂起。

改进版： 

#include <signal.h>
#include <stdio.h>
#include <setjmp.h>
#include <unistd.h>
static jmp_buf env_alrm;
static void sig_alrm( int signo )
{
	printf("begin\n");
	longjmp( env_alrm, 1 );
	printf("end\n");
}
unsigned int sleep2( unsigned int );
static void sig_int( int );

int main( void )
{
	unsigned int unslept;
	if ( signal( SIGINT, sig_int ) == SIG_ERR )
		printf("signal error\n");
	unslept = sleep2( 5 );
	printf("sleep2 returned:%u\n", unslept );
	exit( 0 );
}

unsigned int sleep2( unsigned int nsecs )
{
	if ( signal( SIGALRM, sig_alrm ) == SIG_ERR )
		return ( nsecs );
	if ( setjmp( env_alrm ) == 0 ){
		alarm( nsecs );
		printf("pause execute!\n" );
		pause();
	}
	return ( alarm( 0 ) );
}

static void sig_int( int signo )
{
	int i, j;
	volatile int k;
	printf("\nsig_int starting\n");
	for ( i = 0; i < 300000; i++ )
		for ( j = 0; j < 40000; j++ )
			k += i * j;
	printf("sig_int finished\n");
}

    注意：sleep2中，就算alarm和pause之间存在竞争，并且超时，我们也可以通过longjmp来跳出来。程序输出： 
leichaojian@ThinkPad-T430i:~$ ./a.out
pause execute!
begin
sleep2 returned:0

    alarm可用于对可能阻塞的操作设置时间上限值： 
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#define MAXLINE 4096
static void sig_alrm( int );

int main( void )
{
        int     n;
        char    line[ MAXLINE ];

        if ( signal( SIGALRM, sig_alrm ) == SIG_ERR )
                printf("signal error\n");
        alarm( 10 );
        if ( ( n = read( STDIN_FILENO, line, MAXLINE ) ) < 0 )
                printf( "read error\n" );
        alarm( 0 );

        write( STDOUT_FILENO, line, n );
        exit( 0 );
}

static void sig_alrm( int signo )
{
        printf("one signal\n");
}

    如果在alarm和read之间存在竞争条件，并且阻塞了，则read可能永远阻塞。

改进版： 

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

#define MAXLINE 4096
static void sig_alrm( int );
static jmp_buf env_alrm;

int main( void )
{
        int     n;
        char    line[ MAXLINE ];

        if ( signal(SIGALRM, sig_alrm) == SIG_ERR )
                printf("signal error\n");
        if ( setjmp( env_alrm) != 0)
                printf("read timeout");
        alarm(10);
        if ( ( n = read( STDIN_FILENO, line, MAXLINE)) < 0)
                printf("read error\n");
        alarm(0);

        write(STDOUT_FILENO, line, n);
        exit(0);
}

static void sig_alrm( int signo )
{
        longjmp( env_alrm, 1 );
}

8. 信号集

    五个处理信号集的函数： 

#include <signal.h>
int sigemptyset( sigset_t *set );    //清除set中所有信号
int sigfillset( sigset_t *set );     //初始化set指向的信号集
int sigaddset( sigset_t *set, int signo );    //增加信号
int sigdelset( sigset_t *set, int signo );    //删除信号
int sigismember( const sigset_t *set, int signo );    //判断是否存在signo信号

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

static void sig_quit( int );

int main( void )
{
	sigset_t newmask, oldmask, pendmask;

	if ( signal( SIGQUIT, sig_quit ) == SIG_ERR )
		printf( "can't catch SIGQUIT" );
	
	sigemptyset( &newmask );
	sigaddset( &newmask, SIGQUIT );	//将SIGQUIT信号增加到新的信号集中
	//保留旧信号集
	if ( sigprocmask( SIG_BLOCK, &newmask, &oldmask ) < 0 )
		printf( "SIG_BLOCK error" );
	sleep( 5 );

	//返回新的信号集
	if ( sigpending( &pendmask ) < 0 )
		printf( "sigpending error" );
	//判断新的信号集中是否有SIGQUIT信号
	if ( sigismember( &pendmask, SIGQUIT ) )
		printf("\nSIGQUIT pending\n" );
	//重新使用旧的信号集
	if ( sigprocmask( SIG_SETMASK, &oldmask, NULL ) < 0 )
		printf("SIG_SETMASK error");
	printf("SIGQUIT unblocked\n");
	sleep( 5 );
	exit( 0 );
}

static void sig_quit( int signo )
{
	printf("caught SIGQUIT!\n");
	if ( signal( SIGQUIT, SIG_DFL ) == SIG_ERR )
		printf("can't reset SIGQUIT");
}

程序输出： 
leichaojian@ThinkPad-T430i:~$ ./a.out
^\^\
SIGQUIT pending
caught SIGQUIT!
SIGQUIT unblocked

9. sigsetjmp和siglongjmp函数

    可恢复被屏蔽的信号 

#include <stdio.h>
#include <setjmp.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>
static void sig_usr1( int ), sig_alrm( int );
static sigjmp_buf jmpbuf;
static volatile sig_atomic_t    canjump;

int main( void )
{
        if ( signal( SIGUSR1, sig_usr1 ) == SIG_ERR )
                printf("signal SIGUSR1 error\n");
        if ( signal( SIGALRM, sig_alrm ) == SIG_ERR )
                printf("signal SIGALRM error\n");
        printf("starting main:\n");
        if ( sigsetjmp( jmpbuf, 1)){
                printf("ending main:\n");
                exit( 0 );
        }
        canjump = 1;
        for ( ; ; )
                pause();
}

static void sig_usr1( int signo )
{
        time_t  starttime;
        if ( 0 == canjump )
                return;
        printf("starting sig_usr1:\n");
        alarm( 3 );
        starttime = time( NULL );
        for ( ; ; )
                if ( time( NULL ) > starttime + 5 )
                        break;
        printf("finishing sig_usr1\n");
        canjump = 0;
        siglongjmp( jmpbuf, 1 );
}

程序输出： 
leichaojian@ThinkPad-T430i:~$ ./a.out &
[2] 3890
leichaojian@ThinkPad-T430i:~$ starting main:
kill -USR1 3890
starting sig_usr1:
leichaojian@ThinkPad-T430i:~$ in sig_alrm: 
finishing sig_usr1
ending main:

[2]-  Done                    ./a.out

10. sigsuspend函数 
#include <signal.h>

int sigsuspend( const sigset_t *sigmask );
    将进程的信号屏蔽字设置为由sigmask指向的值。在捕捉到一个信号或发生了一个会终止该进程的信号之前，该进程被挂起。如果捕捉到一个信号而且从该信 号处理程序返回，则sigsuspend返回，并且将该进程的信号屏蔽字设置为调用sigsuspend之前的值。

1） 保护临界区不被信号中断

    以下程序保证SIGINT信号被悬挂起来。 

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

void pr_mask( const char *str )
{
	sigset_t sigset;
	int		errno_save;
	errno_save = errno;
	if ( sigprocmask( 0, NULL, &sigset ) < 0 )
		printf("sigprocmask error\n");
	printf("%s", str);

	if ( sigismember( &sigset, SIGINT)) printf("SIGINT ");
	if (sigismember( &sigset, SIGQUIT)) printf("SIGQUIT ");
	if (sigismember( &sigset, SIGUSR1)) printf("SIGUSR1" );
	if (sigismember(&sigset, SIGALRM)) printf("SIGALRM");

	printf("\n");
	errno = errno_save;
}
static void sig_int( int );

int main( void )
{
	sigset_t	newmask, oldmask, waitmask;

	pr_mask( "program start:" );
	
	if ( signal( SIGINT, sig_int ) == SIG_ERR )
		printf("signal(SIGINT) error\n");
	sigemptyset( &waitmask );
	sigaddset(&waitmask, SIGUSR1);
	sigemptyset(&newmask);
	sigaddset(&newmask, SIGINT );
	
	if ( sigprocmask( SIG_BLOCK, &newmask, &oldmask) < 0)
		printf("SIG_BLOCK error");

	pr_mask("in critical region:");

	if ( sigsuspend( &waitmask) != -1 )
		printf("sigsuspend error\n");
	pr_mask("after return from sigsuspend\n");

	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
		printf("SIG_SETMASK error\n");

	pr_mask("program exit:");

	exit(0);
}

static void sig_int( int signo )
{
	pr_mask("\nin sig_int:");
}

    程序输出： 
leichaojian@ThinkPad-T430i:~$ ./a.out
program start:
in critical region:SIGINT 
^C
in sig_int:SIGINT SIGUSR1
after return from sigsuspend
SIGINT 
program exit:

2） 用sigsuspend等待一个全局变量被设置 
#include <signal.h>
#include <stdio.h>

volatile sig_atomic_t quitflag;
static void sig_int( int signo )
{
	if ( signo == SIGINT )
		printf("\ninterrupt\n");
	else if ( signo == SIGQUIT )
		quitflag = 1;
}

int main( void )
{
	sigset_t newmask, oldmask, zeromask;

	if ( signal( SIGINT, sig_int ) == SIG_ERR )
		printf("signal (SIGINT) error");
	if ( signal( SIGQUIT, sig_int ) == SIG_ERR )
		printf("signal (SIGQUIT) error");

	sigemptyset(&zeromask);
	sigemptyset(&newmask);
	sigaddset(&newmask, SIGQUIT);

	if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
		printf("SIG_BLOCK error\n");
	printf("block begin:\n");
	while ( quitflag == 0 )
		sigsuspend(&zeromask);
	printf("block end\n");

	quitflag = 0;
	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
		printf("SIG_SETMASK error\n");

	exit( 0 );
}

    程序输出： 
leichaojian@ThinkPad-T430i:~$ ./a.out
block begin:
^C
interrupt
^C
interrupt
^\block end



转载于:https://my.oschina.net/voler/blog/337347

weixin_33896726
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
APUE_信号
sicofield的专栏
09-04 2021
1.引言        信号是软件中断，提供了一种处理异步事件的方法。每个信号都有一个名字，以字符SIG开头，定义为正整数。很多条件可以产生信号： 1、当用户按某些终端键时，引发终端产生的信号，如中断（Ctrl+C，SIGINT）、退出（Ctrl+/，SIGQUIT）和挂起（Ctrl+Z，SIGTSTP）键。 2、硬件异常产生信号，如除数为0、浮点溢出（SIGFPE），无效的内存引用（S
unix编程专题-信号机制使用实例
tiankong_的博客
07-13 247
1.异步事件通信（甚至可以附带信息数据） （额，由于无线网卡掉了，电脑切换到ubuntu的情况下无法联网，暂时不自己写一个了）暂且用文字说明： 其实子进程结束，内核产生SIGCHLD并递送给父进程，就是一个典型的异步事件通信 2.保护临界区不被信号中断 以下摘自unix高级环境编程 #include "apue.h" static void sig_int(int);
APUE学习笔记-捕捉信号的简单程序，pause
weixin_33895016的博客
09-23 85
2019独角兽企业重金招聘Python工程师标准>>> ...
APUE信号-程序汇总
博观约取
10-02 1365
APUE信号-程序汇总      最近重看APUE，发现对于很多程序的要领还是没有完全理解，所以梳理下便于查看，而且有很多值得思考的问题。 程序清单10- 1  捕获 SIGUSR1 和 SIGUSR2的简单程序 #include "util.h" static void sig_usr(int); int main(void){ if(signal(SIGUSR1,
《APUE》笔记-第十章-信号
ZX714311728的博客
11-06 723
重点：信号意义、几种常见信号 1.信号 信号是软件中断，信号提供了一种处理异步事件的方法：产生信号的事件是随机出现的，需要告诉内核当什么信号发生时该执行什么操作。 定义在里（本机实际位置：/usr/include/bits/signum.h），形式：“#define 信号名  信号编号” ，如下图，不存在编号为0的信号。 信号处理动作：1.忽略；2.捕捉；3.执行系统默认动作（大多
APUE笔记之:进程环境详解
09-05
在深入探讨APUE中的进程环境之前，我们先理解一下什么是进程。进程是操作系统中的一个基本概念，它代表了程序在内存中的执行实例。每个进程都有自己的独立内存空间，包括正文段、堆、栈以及进程环境。 正文段包含了...
Linux应用开发：APUE读书笔记+源码
04-08
压缩包内容包含了第三版APUE读书笔记以及相关训练源码，适用于初学UNIX环境（Linux）应用编程的工程师进行学习，能够帮助工程师更好的上手Linux环境下的应用开发。压缩包中还包含很多文中的示例以及相关笔记注释，...
APUE学习笔记.xmind
04-03
APUE学习笔记.xmind
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 688
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
qq_26521261的博客
07-20 282
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 221
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
代码随想录打卡第二十九天
weixin_48013375的博客
07-19 546
day 29 贪心算法第三天。
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 598
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
文心一言 VS 讯飞星火 VS chatgpt （307）-- 算法导论22.2 5题
最新发布
福大大架构师每日一题
07-21 632
首先，我们来证明在广度优先搜索（BFS）算法中，赋给结点 $ u $ 的 $ u.d $ 值（即结点 $ u $ 被发现的次序或距离）与结点在邻接链表中的出现次序无关。
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 914
数组和字符串介绍以及相关例题
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 1165
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
java算法day19
TOMOT77的博客
07-20 175
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【一刷《剑指Offer》】面试题 42：翻转单词顺序 VS 左旋转字符串
Elena's Blog
07-21 251
思考一下，将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。不要使用辅助空间，空间复杂度要求为O(1)。不能使用辅助空间之后，那么只能在原字符串上下功夫了。保存第一个，剩下的整体前移一个，第一个放在最后，完成一次移动，一次能移动，多次也可以。举个例子，源字符串为："the sky is blue "字符串反转："eulb si yks eht"单词反转："blue is sky the"（3）思路三（双倍字符串，不推荐）（2）思路二（逆置）
深入理解Linux高级环境编程：APUE读书笔记解析
"这篇读书笔记主要涵盖了《高级Linux环境编程》(Advanced Programming in the Unix Environment, APUE)的多个核心章节，包括Unix基础、标准化及实现、文件I/O、文件和目录、标准I/O库、系统数据文件和信息以及进程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值