Linux学习记录（十三）----信号

---

声明：本人撰写的为学习笔记内容来源于网络，如有侵权联系删除（包括之前的文章）

6.信号

信号通信，其实就是内核向用户空间进程发送信号，只有内核才能发信号，用户空间进程不能发送信号。

信号已经存在在内核中，不需要用户自己创造！

信号只能内核发！

内核可以发送多少种信号呢？

命令：kill ‐l

信号名	含义	默 认 操 作
SIGHUP	该信号在用户终端连接(正常或非正常)结束时发出，通常是在终端的控制进程结束 时，通知同一会话内的各个作业与控制终端不再关联。	终 止
SIGINT	该信号在用户键入INTR字符(通常是Ctrl-C)时发出，终端驱动程序发送此信号并送到 前台进程中的每一个进程。	终 止
SIGQUIT	该信号和SIGINT类似，但由QUIT字符(通常是Ctrl-)来控制。	终 止
SIGILL	该信号在一个进程企图执行一条非法指令时(可执行文件本身出现错误，或者试图执 行数据段、堆栈溢出时)发出。	终 止
SIGFPE	该信号在发生致命的算术运算错误时发出。这里不仅包括浮点运算错误，还包括溢出 及除数为0等其它所有的算术的错误。	终 止
SIGKILL	该信号用来立即结束程序的运行，并且不能被阻塞、处理和忽略。	终 止
SIGALRM	该信号当一个定时器到时的时候发出。	终 止
SIGSTOP	该信号用于暂停一个进程，且不能被阻塞、处理或忽略。	暂 停 进 程
SIGTSTP	该信号用于暂停交互进程，用户可键入SUSP字符(通常是Ctrl-Z)发出这个信号。	暂 停 进 程
SIGCHLD	子进程改变状态时，父进程会收到这个信号	忽 略
SIGABORT	该信号用于结束进程	终 止

信号通信的框架

• 信号的发送（发送信号进程）：kill、raise、alarm

• 信号的接收（接收信号进程） : pause()、 sleep、 while(1)

• 信号的处理（接收信号进程） :signal

1.信号的发送（发送信号进程）

kill:

#include<signal.h>
#include<sys/types.h>
函数原型：int kill(pid_t pid, int sig);
/*参数：
*		函数传入值：pid
*				正数：要接收信号的进程的进程号
*				  0：信号被发送到所有和pid进程在同一个进程组的进程
*				 ‐1：信号发给所有的进程表中的进程(除了进程号最大的进程外)
*			sig：信号
*			函数返回值：成功 0 出错 ‐1
*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
int main(int argc ,char *argv[])
{
	int sig;
	pid_t pid;
	if(argc > 3)
	{
		printf("param error\n");
		return -1;
	}
	sig = atoi(argv[1]);//将其转化成int类型的值
	pid = atoi(argv[2]);//将其转化成int类型的值
	printf("sig = %d,pid = %d\n",sig,pid);
	kill(pid,sig);//向进程号为pid的进程发送 sig信号
	return 0;
}

raise:

发信号给自己 == kill(getpid(), sig)

#include<signal.h>
#include<sys/types.h>
函数原型：
int raise(int sig);
/*参数：
* 	 函数传入值：sig：信号：
*@return 成功 0 出错 ‐1
*/

#include <stdio.h>
#include <stdlib.h>
#include<signal.h>
#include<sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
	pid_t pid;
	pid = fork();

	if(pid == -1)
	{
		printf("create process failed\n");
		return -1;
	}
	else if(pid > 0)
	{
		sleep(8);
		if(waitpid(pid,NULL,WNOHANG) == 0)//WNOHANG设置非阻塞，等于0表示子进程正在运行
		{
			kill(pid,9);
		}
		wait(NULL);
		while(1);	
	}
	else if(pid == 0)
	{
		printf("before raise\n");
		raise(SIGTSTP);//暂停信号
		printf("after raise\n");
	}
	return 0;
}

alarm :

发送闹钟信号的函数

alarm 与 raise 函数的比较：

相同点：让内核发送信号给当前进程

不同点：

• alarm 只会发送SIGALARM信号

• alarm 会让内核定时一段时间之后发送信号， raise会让内核立刻发信号

#include <unistd.h>
函数原型 unsigned int alarm(unsigned int seconds)
/*参数：
*		seconds：指定秒数
*@return：成功：如果调用此alarm()前，进程中已经设置了闹钟时间，则 返回上一个闹钟时间的剩余时间，否则返回0。
*		  出错：‐1
*/

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

int main()
{
        int i = 0;
        alarm(7);
        while(1)
        {
                i++;
                printf("i = %d\n",i);
                sleep(1);
        }
        return 0;
}

2.信号的接收

接收信号的进程，要有什么条件：要想使接收的进程能收到信号，这个进程不能结束 :

sleep 、pause：进程状态为S

函数原型 int pause(void);
函数返回值 成功：0，出错：‐1

3.信号的处理

收到信号的进程，应该怎样处理？ 处理的方式：

• 1.进程的默认处理方式（内核为用户进程设置的默认处理方式）

  A：忽略B：终止进程C: 暂停

• 2.自己的处理方式：

  自己处理信号的方法告诉内核，这样你的进程收到了这个信号就会采用你自己的的处理方式

#include <signal.h>
函数原型 void (*signal(int signum, void (*handler)(int)))(int);
/*参数：
 *	signum：指定信号
 *	handler
 *	SIG_IGN：忽略该信号。
 *	SIG_DFL：采用系统默认方式处理信号
		自定义的信号处理函数指针
 *@return：成功：设置之前的信号处理方式，出错：‐1
	signal 函数有二个参数，第一个参数是一个整形变量（信号值），第二个参数是一个函数指针，是我们自己写的处理函
数；这个函数的返回值是一个函数指针。
 */

用自己定义的处理方式处理闹钟信号

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

void myalarm(int signum)
{
	int j = 3;
	printf("Processing of signal %d\n",signum);
	while(j--)
	{
		printf("get up!!!\n");
		sleep(1);
	}
}

int main()
{
	int i = 0;
	signal(14,myalarm);//信号处理函数收到对应的信号会执行自定义的函数
	printf("Please wake me up in 7 seconds\n");
	alarm(7);
	while(1)
	{
		i++;
		printf("i = %d\n",i);
		sleep(1);
		if(i > 7)
		{
			printf("I'm awake\n");
			break;
		}
	}
	return 0;
}

信号父子进程间通信

让父进程或子进程收到信号后执行一些特定的操作为信号父子进程间的通信

问题：

通信过程中子进程退出父进程无法收到子进程退出状态会导致子进程变成僵尸态

解决思路：

exit（0）== kill（pid，17）；

父子进程间的通信

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <stdlib.h>

void myuser(int signum)
{
	int j = 3;
	printf("Processing of signal %d\n",signum);
	while(j--)
	{
		printf("Mom is back, go do some housework quickly\n");
		sleep(1);
	}
}

void mywait(int signum)
{
	printf("Processing of signal %d\n",signum);
	printf("Hurry up, Mom is very angry\n");
	wait(NULL);
}
int main()
{
	pid_t pid;
	pid = fork();
	int i = 0;
	if(pid == -1)
	{
		printf("create process failed\n");
		return -1;
	}
	if(pid > 0)
	{
		signal(10,myuser);//接收到信号执行操作
		signal(17,mywait);//接收到信号执行操作，防止子进程变成僵尸进程
		while(1)
		{
			printf("i = %d\n",i);
			i++;
			sleep(1);
			if(i > 10 && i < 15)
			{
				printf("I'm going now\n");
			}
			else if(i > 15)
			{
				printf("Son, dad ran away first\n");
				break;
			}
		}

	}
	else if(pid == 0)
	{
		sleep(10);
		kill(getppid(),10);
		sleep(5);
		exit(0);//kill(getppid(),17)
	}

	return 0;
}

7.信号灯(semaphore)

信号灯集合（可以包含多个信号灯）IPC对象是一个信号的集合（多个信号量）

创建信号灯函数

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
函数原型： int semget(key_t key, int nsems, int semflg);
//创建一个新的信号量或获取一个已经存在的信号量的键值。
/*
 *@param：
 *		key：和信号灯集关联的key值
 *		nsems: 信号灯集中包含的信号灯数目
 *		semflg：信号灯集的访问权限
 *@return：成功：信号灯集ID，出错：‐1
 */

控制信号灯函数

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
函数原型：int semctl ( int semid, int semnum, int cmd，…union semun arg(不是地址));
//控制信号量，删除信号量或初始化信号量

/*
 *@param：
 *		semid：信号灯集ID
 *		semnum: 要修改的信号灯编号
 *		cmd :
 *			GETVAL：获取信号灯的值
 *			SETVAL：设置信号灯的值
 *			IPC_RMID：从系统中删除信号灯集合
 *@return：
成功：0
出错：‐1

创建一个信号灯集合并删除它

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int main()
{
        int semid;
        semid = semget(IPC_PRIVATE,3,0777);
        if(semid == -1)
        {
                printf("create semaphore failed\n");
                return -1;
        }
        printf("create semaphore successed semid is %d\n",semid);
        system("ipcs -s");
        semctl(semid,0,IPC_RMID);
        system("ipcs -s");
        return 0;
}

PV操作

P操作：申请资源操作

V操作：释放资源操作

include<sys/sem.h>
int semop(int semid ,struct sembuf sops ,size_t nsops);
//用户改变信号量的值。也就是使用资源还是释放资源使用权
/
*@param：

•  semid : 信号量的标识码。也就是semget（）的返回值
  

•  sops是一个指向结构体数组的指针。
  

•  	struct sembuf{
  

•  					unsigned short sem_num；//信号灯编号；
  

•  					short sem_op;//对该信号量的操作。‐1 ，P操作，1 ，V操作
  

•  					short sem_flg;0阻塞，1非阻塞
  

•  			     };
  

•  nsops : 操作信号灯的个数
  

*//如果其值为正数，该值会加到现有的信号内含值中。通常用于释放所控资源的使用权；如果sem_op的值为负
*数，而其绝对值又大于信号的现值，操作将会阻塞，直到信号值大于或等于sem_op的绝对值。通常用于获取资源的使用
*权；如果sem_op的值为0，则操作将暂时阻塞，直到信号的值变为0。
*/

用信号灯pv操作读写共享内存

#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/sem.h>

#define SEM_READ 0
#define SEM_WRITE 0

union semun 
{
	int val;
};

void Poperation(int semnum,int semid)
{
	struct sembuf sop;
	sop.sem_num = 0;
	sop.sem_op = -1;//
	sop.sem_flg = 0;

	semop(semid,&sop,1);
}

void Voperation(int semnum,int semid)
{

	struct sembuf sop;
	sop.sem_num = 0;
	sop.sem_op = 1;
	sop.sem_flg = 0;

	semop(semid,&sop,1);
}
int main()
{
	int semid;
	int shmid;
	key_t key;
	char * shmaddr;
	key = ftok(".",123);
	semid = semget(key,3,IPC_CREAT|0777);
	if(semid == -1)
	{
		perror("semget");
		return -1;
	}
	shmid = shmget(key,128,IPC_CREAT|0777);
	if(shmid == -1)
	{
		perror("shmget");
		return -1;
	}	
	//init union
	union semun myun;
	//init semphore read
	myun.val = 0;
	semctl(semid,SEM_READ,SETVAL,myun);//设置读操作的value为0
	//init semphore write
	myun.val = 1;
	semctl(semid,SEM_WRITE,SETVAL,myun);

	pid_t pid = fork();
	if(pid == 0)
	{
		while(1)
		{
			shmaddr = (char *)shmat(shmid,NULL,0);//获取共享内存映射的地址
			Poperation(SEM_READ,semid);	//p操作通过判断是否有资源运行别的进程即若有别的进程在运行就会阻塞
			printf("get share memory is %s\n",shmaddr);
			Voperation(SEM_READ,semid);//释放资源，让别的进程操作可执行
		}
	}
	else if(pid > 0)
	{
		while(1)
		{
			shmaddr = (char *)shmat(shmid,NULL,0);//获取共享内存映射地址
			Poperation(SEM_WRITE,semid);
			printf("plese input message:\n");
			fgets(shmaddr,32,stdin);//从终端读到共享内存的映射中去
			Voperation(SEM_WRITE,semid);

		}
	}
	return 0;
}

疑问点：为什么连续给同一个信号量赋值之后，父子进程依旧可以调用读或写对应的val

解决：设置之后立马执行