Linux_信号与信号量【转】

转自：http://blog.csdn.net/sty23122555/article/details/51470949

信号：

信号机制是类UNIX系统中的一种重要的进程间通信手段之一。我们经常使用信号来向一个进程发送一个简短的消息。例如：假设我们启动一个进程通过socket读取远程主机发送过来的网络数据包，此时由于网络因素当前主机还没有收到相应的数据，当前进程被设置为可中断等待状态(TASK_INTERRUPTIBLE)，此时我们已经失去耐心，想提前结束这个进程，于是可以通过kill命令想这个进程发送KILL信号，内核会唤醒该进程，执行它的信号处理函数，KILL信号的默认处理是退出该进程。

另外应用程序可以通过signal()等函数来为一个信号设置默认处理函数。例如当用户按下CTRL+C时，shell将会发出SIGINT信号，SIGINT的默认处理函数是执行进程的退出代码，如下所示：

可以通过类似下面的命令显式的给一个进程发送一个信号：

kill -2 pid

事实上，进程也不知道信号到底什么时候到达。信号是异步的，一个进程不可能等待信号的到来，也不知道信号会到来，那么，进程是如何发现和接受信号呢？实际上，信号的接收不是由用户进程来完成的，而是由内核代理。当一个进程P2向另一个进程P1发送信号后，内核接受到信号，并将其放在P1的信号队列当中。当P1再次陷入内核态时，会检查信号队列，并根据相应的信号调取相应的信号处理函数。

信号检测和响应时机

刚才我们说，当P1再次陷入内核时，会检查信号队列。那么，P1什么时候会再次陷入内核呢？陷入内核后在什么时机会检测信号队列呢？

1. 当前进程由于系统调用、中断或异常而进入系统空间以后，从系统空间返回到用户空间的前夕。
2. 当前进程在内核中进入睡眠以后刚被唤醒的时候（必定是在系统调用中），或者由于不可忽略信号的存在而提前返回到用户空间。

进入信号处理函数

发现信号后，根据信号向量，知道了处理函数，那么该如何进入信号处理程序，又该如何返回呢？

我们知道，用户进程提供的信号处理函数是在用户态里的，而我们发现信号，找到信号处理函数的时刻处于内核态中，所以我们需要从内核态跑到用户态去执行信号处理程序，执行完毕后还要返回内核态。

1. #include <signal.h>
2. #include <stdio.h>
3. void int_handler(int signum)
4. {
5. printf("\nSIGINT signal handler.\n");
6. printf("exit.\n");
7. exit(-1);
8. }
9. int main()
10. {
11. signal(SIGINT, int_handler);
12. printf("int_handler set for SIGINT\n");
13. 　　while(1)
14. {
15. printf("go to sleep.\n");
16. sleep(60);
17. }
18. 　　return 0;
19. }

信号量：

一．什么是信号量
信号量的使用主要是用来保护共享资源，使得资源在一个时刻只有一个进程（线程）所拥有。
信号量的值为正的时候，说明它空闲。所测试的线程可以锁定而使用它。若为0，说明它被占用，测试的线程要进入睡眠队列中，等待被唤醒。

二．信号量的分类

在学习信号量之前，我们必须先知道——Linux提供两种信号量：
（1） 内核信号量，由内核控制路径使用
（2）用户态进程使用的信号量，这种信号量又分为POSIX信号量和SYSTEM V信号量。
1、POSIX信号量又分为有名信号量和无名信号量：

（1）有名信号量，其值保存在文件中，所以它既可以用于线程，也可以用于相关进程间，甚至是不相关进程。

（2）无名信号量，其值保存在内存中。无名信号量常用于多线程间的同步，同时也用于相关进程间的同步。也就是说，无名信号量必须是多个进程（线程）的共享变量，无名信号量要保护的变量也必须是多个进程（线程）的共享变量，这两个条件是缺一不可的。

倘若对信号量没有以上的全面认识的话，你就会很快发现自己在信号量的森林里迷失了方向。

POSIX 信号量与SYSTEM V信号量的比较：
1. 对POSIX来说，信号量是个非负整数。常用于线程间同步。而SYSTEM
V信号量则是一个或多个信号量的集合，它对应的是一个信号量结构体，这个结构体是为SYSTEM V IPC服务的，信号量只不过是它的一部分。常用于进程间同步。
2．POSIX信号量的引用头文件是“<semaphore.h>”，而SYSTEM V信号量的引用头文件是“<sys/sem.h>”。
3．从使用的角度，System V信号量是复杂的，而Posix信号量是简单。比如，POSIX信号量的创建和初始化或PV操作就很非常方便。

无名信号量：

1. #include <pthread.h>
2. #include <semaphore.h>
3. #include <sys/types.h>
4. #include <stdio.h>
5. #include <unistd.h>
6. int number; // 被保护的全局变量
7. sem_t sem_id;
8. void* thread_one_fun(void *arg)
9. {
10. sem_wait(&sem_id);
11. printf("thread_one have the semaphore\n");
12. number++;
13. printf("number = %d\n",number);
14. sem_post(&sem_id);
15. }
16. void* thread_two_fun(void *arg)
17. {
18. sem_wait(&sem_id);
19. printf("thread_two have the semaphore \n");
20. number--;
21. printf("number = %d\n",number);
22. sem_post(&sem_id);
23. }
24. int main(int argc,char *argv[])
25. {
26. number = 1;
27. pthread_t id1, id2;
28. sem_init(&sem_id, 0, 1);
29. pthread_create(&id1,NULL,thread_one_fun, NULL);
30. pthread_create(&id2,NULL,thread_two_fun, NULL);
31. pthread_join(id1,NULL);
32. pthread_join(id2,NULL);
33. printf("main,,,\n");
34. return 0;
35. }

有名信号量：

1. //File1: server.c </u>
2. #include <sys/types.h>
3. #include <sys/ipc.h>
4. #include <sys/shm.h>
5. #include <stdio.h>
6. #include <semaphore.h>
7. #include <sys/types.h>
8. #include <sys/stat.h>
9. #include <fcntl.h>
10. #define SHMSZ 27
11. char SEM_NAME[]= "vik";
12. int main()
13. {
14. char ch;
15. int shmid;
16. key_t key;
17. char *shm,*s;
18. sem_t *mutex;
19. //name the shared memory segment
20. key = 1000;
21. //create & initialize semaphore
22. mutex = sem_open(SEM_NAME,O_CREAT,0644,1);
23. if(mutex == SEM_FAILED)
24. {
25. perror("unable to create semaphore");
26. sem_unlink(SEM_NAME);
27. exit(-1);
28. }
29. //create the shared memory segment with this key
30. shmid = shmget(key,SHMSZ,IPC_CREAT|0666);
31. if(shmid<0)
32. {
33. perror("failure in shmget");
34. exit(-1);
35. }
36. //attach this segment to virtual memory
37. shm = shmat(shmid,NULL,0);
38. //start writing into memory
39. s = shm;
40. for(ch='A';ch<='Z';ch++)
41. {
42. sem_wait(mutex);
43. *s++ = ch;
44. sem_post(mutex);
45. }
46. //the below loop could be replaced by binary semaphore
47. while(*shm != '*')
48. {
49. sleep(1);
50. }
51. sem_close(mutex);
52. sem_unlink(SEM_NAME);
53. shmctl(shmid, IPC_RMID, 0);
54. exit(0);
55. }

1. //File 2: client.c</u>
2. #include <sys/types.h>
3. #include <sys/ipc.h>
4. #include <sys/shm.h>
5. #include <stdio.h>
6. #include <semaphore.h>
7. #include <sys/types.h>
8. #include <sys/stat.h>
9. #include <fcntl.h>
10. #define SHMSZ 27
11. char SEM_NAME[]= "vik";
12. int main()
13. {
14. char ch;
15. int shmid;
16. key_t key;
17. char *shm,*s;
18. sem_t *mutex;
19. //name the shared memory segment
20. key = 1000;
21. //create & initialize existing semaphore
22. mutex = sem_open(SEM_NAME,0,0644,0);
23. if(mutex == SEM_FAILED)
24. {
25. perror("reader:unable to execute semaphore");
26. sem_close(mutex);
27. exit(-1);
28. }
29. //create the shared memory segment with this key
30. shmid = shmget(key,SHMSZ,0666);
31. if(shmid<0)
32. {
33. perror("reader:failure in shmget");
34. exit(-1);
35. }
36. //attach this segment to virtual memory
37. shm = shmat(shmid,NULL,0);
38. //start reading
39. s = shm;
40. for(s=shm;*s!=NULL;s++)
41. {
42. sem_wait(mutex);
43. putchar(*s);
44. sem_post(mutex);
45. }
46. //once done signal exiting of reader:This can be replaced by
47. another semaphore
48. *shm = '*';
49. sem_close(mutex);
50. shmctl(shmid, IPC_RMID, 0);
51. exit(0);
52. }

System V信号量：

1. int sem_id = 0; /* semget的返回值，全局 */
2. #define MUTEX 0 /* 用于返回临界区的信号量在集合中的序数 */
3. #define NUM_SEM 1 /* 集合中信号量的个数 */
4. #define SEM_KEY 0x11223344 /*保证内核中的唯一性 */
5. void P(int sem_num)
6. {
7. struct sembuf sem;
8. sem.sem_num = MUTEX;
9. sem.sem_op = -1;
10. sem.sem_flg = 0;
11. if( -1 == semop(sem_id, &sem, 1) )
12. {
13. /* 错误处理 */
14. }
15. }
16. void V(int sem_num)
17. {
18. struct sembuf sem;
19. sem.sem_num = MUTEX;
20. sem.sem_op = 1;
21. sem.sem_flg = 0;
22. if( -1 == semop(sem_id, &sem, 1) )
23. {
24. /* 错误处理 */
25. }
26. }
27. 主函数：
28. int main()
29. {
30. ...
31. int semid;
32. ....
33. semid = semget(SEM_KEY, 0, 0); /* panduan 判断该型号量组是否已经存在 */
34. if( -1 == semid )
35. {
36. semid = semget(SEM_KEY, NUM_SEM, IPC_CREAT | IPC_EXCL | 0666);
37. if( -1 == semid)
38. {
39. /* 错误处理 */
40. }
41. else
42. {
43. semctl(sem_id, MUTEX, SETVAL, 1); /* 初始值为1。错误处理略 */
44. }
45. }
46. ...
47. P(MUTEX);
48. /* 临界区代码段 */
49. V(MUTEX);
50. ...
51. }

最全面的linux信号量解析：http://blog.csdn.net/qinxiongxu/article/details/7830537

信号只是一个数字，数字为0-31表示不同的信号，如下表所示。

编号	信号名	默认动作	说明
1	SIGHUP	进程终止	终端断开连接
2	SIGINT	进程终止	用户在键盘上按下CTRL+C
3	SIGQUIT	进程意外结束（Dump)	用户在键盘上按下CTRL+\
4	SIGILL	进程意外结束（Dump)	遇到非法指令
5	SIGTRAP	进程意外结束（Dump)	遇到断电，用于调试
6	SIGABRT/SIGIOT	进程意外结束（Dump)
7	SIGBUS	进程意外结束（Dump)	总线错误
8	SIGFPE	进程意外结束（Dump)	浮点异常
9	SIGKILL	进程终止	其他进程发送SIGKILL将导致目标进程终止
10	SIGUSR1	进程终止	应用程序可自定义使用
11	SIGSEGV	进程意外结束（Dump)	非法的内存访问
12	SIGUSR2	进程终止	应用程序可自定义使用
13	SIGPIPE	进程终止	管道读取端已经关闭，写入端进程会收到该信号
14	SIGALRM	进程终止	定时器到时
15	SIGTERM	进程终止	发送该信号使目标进程终止
16	SIGSTKFLT	进程终止	堆线错误
17	SIGCHLD	忽略	子进程退出时会向父进程发送该信号
18	SIGCONT	忽略	进程继续执行
19	SIGSTOP	进程暂停	发送该信号会使目标进程进入TASK_STOPPED状态
20	SIGTSTP	进程暂停	在终端上按下CTRL+Z
21	SIGTTIN	进程暂停	后台进程从控制终端读取数据
22	SIGTTOU	进程暂停	后台进程从控制终端读取数据
23	SIGURG	忽略	socket收到设置紧急指针标志的网络数据包
24	SIGXCPU	进程意外结束（Dump)	进程使用CPU已经超过限制
25	SIGXFSZ	进程意外结束（Dump)	进程使用CPU已经超过限制
26	SIGVTALRM	进程终止	进程虚拟定时器到期
27	SIGPROF	进程终止	进程Profile定时器到期
28	SIGMNCH	忽略	进程终端窗口大小改变
29	SIGIO	进程暂停	用于异步IO
29	SIGPOLL	进程暂停	用于异步IO
30	SIGPWR	进程暂停	电源失效
31	SIGUNUSED	进程暂停	保留未使用

版权声明：本文为博主原创文章，未经博主允许不得转载。