Linux多线程——使用信号量同步线程

信号量、同步这些名词在进程间通信时就已经说过，在这里它们的意思是相同的，只不过是同步的对象不同而已。但是下面介绍的信号量的接口是用于线程的信号量， 注意不要跟用于进程间通信的信号量混淆，关于用于进程间通信的信号量的详细介绍可以参阅我的另一篇博文： Linux进程间通信——使用信号量。相似地， 线程同步是控制线程执行和访问临界区域的方法。

一、什么是信号量

线程的信号量与进程间通信中使用的信号量的概念是一样，它是一种特殊的变量，它可以被增加或减少，但对其的关键访问被保证是原子操作。如果一个程序中有多个线程试图改变一个信号量的值，系统将保证所有的操作都将依次进行。

而只有0和1两种取值的信号量叫做二进制信号量，在这里将重点介绍。而信号量一般常用于保护一段代码，使其每次只被一个执行线程运行。我们可以使用二进制信号量来完成这个工作。

二、信号量的接口和使用

信号量的函数都以sem_开头，线程中使用的基本信号量函数有4个，它们都声明在头文件 semaphore.h中。

1、sem_init函数

该函数用于创建信号量，其原型如下：

[cpp]  view plain copy print ?

1. int sem_init(sem_t *sem, int pshared， unsigned int value);  

该函数初始化由sem指向的信号对象，设置它的共享选项，并给它一个初始的整数值。pshared控制信号量的类型，如果其值为0，就表示这个信号量是当前进程的局部信号量，否则信号量就可以在多个进程之间共享，value为sem的初始值。调用成功时返回0，失败返回-1.

2、sem_wait函数

该函数用于以原子操作的方式将信号量的值减1。原子操作就是，如果两个线程企图同时给一个信号量加1或减1，它们之间不会互相干扰。它的原型如下：

[cpp]  view plain copy print ?

1. int sem_wait(sem_t *sem);  

sem指向的对象是由sem_init调用初始化的信号量。调用成功时返回0，失败返回-1.

3、sem_post函数

该函数用于以原子操作的方式将信号量的值加1。它的原型如下：

[cpp]  view plain copy print ?

1. int sem_post(sem_t *sem);  

与sem_wait一样，sem指向的对象是由sem_init调用初始化的信号量。调用成功时返回0，失败返回-1.

4、sem_destroy函数

该函数用于对用完的信号量的清理。它的原型如下：

[cpp]  view plain copy print ?

1. int sem_destroy(sem_t *sem);  

成功时返回0，失败时返回-1.

三、使用信号量同步线程

下面以一个简单的多线程程序来说明如何使用信号量进行线程同步。在主线程中，我们创建子线程，并把数组msg作为参数传递给子线程，然后主线程等待直到有文本输入，然后调用sem_post来增加信号量的值，这样就会立刻使子线程从sem_wait的等待中返回并开始执行。线程函数在把字符串的小写字母变成大写并统计输入的字符数量之后，它再次调用sem_wait并再次被阻塞，直到主线程再次调用sem_post增加信号量的值。

[cpp]  view plain copy print ?

1. #include <unistd.h>  
2. #include <pthread.h>  
3. #include <semaphore.h>  
4. #include <stdlib.h>  
5. #include <stdio.h>  
6. #include <string.h>  
7.   
8. //线程函数  
9. void *thread_func(void *msg);  
10. sem_t sem;//信号量  
11.   
12. #define MSG_SIZE 512  
13.   
14. int main()  
15. {  
16.     int res = -1;  
17.     pthread_t thread;  
18.     void *thread_result = NULL;  
19.     char msg[MSG_SIZE];  
20.     //初始化信号量，其初值为0  
21.     res = sem_init(&sem, 0, 0);  
22.     if(res == -1)  
23.     {  
24.         perror("semaphore intitialization failed\n");  
25.         exit(EXIT_FAILURE);  
26.     }  
27.     //创建线程，并把msg作为线程函数的参数  
28.     res = pthread_create(&thread, NULL, thread_func, msg);  
29.     if(res != 0)  
30.     {  
31.         perror("pthread_create failed\n");  
32.         exit(EXIT_FAILURE);  
33.     }  
34.     //输入信息，以输入end结束，由于fgets会把回车（\n）也读入，所以判断时就变成了“end\n”  
35.     printf("Input some text. Enter 'end'to finish...\n");  
36.     while(strcmp("end\n", msg) != 0)  
37.     {  
38.         fgets(msg, MSG_SIZE, stdin);  
39.         //把信号量加1  
40.         sem_post(&sem);  
41.     }  
42.   
43.     printf("Waiting for thread to finish...\n");  
44.     //等待子线程结束  
45.     res = pthread_join(thread, &thread_result);  
46.     if(res != 0)  
47.     {  
48.         perror("pthread_join failed\n");  
49.         exit(EXIT_FAILURE);  
50.     }  
51.     printf("Thread joined\n");  
52.     //清理信号量  
53.     sem_destroy(&sem);  
54.     exit(EXIT_SUCCESS);  
55. }  
56.   
57. void* thread_func(void *msg)  
58. {  
59.     //把信号量减1  
60.     sem_wait(&sem);  
61.     char *ptr = msg;  
62.     while(strcmp("end\n", msg) != 0)  
63.     {  
64.         int i = 0;  
65.         //把小写字母变成大写  
66.         for(; ptr[i] != '\0'; ++i)  
67.         {  
68.             if(ptr[i] >= 'a' && ptr[i] <= 'z')  
69.             {  
70.                 ptr[i] -= 'a' - 'A';  
71.             }  
72.         }  
73.         printf("You input %d characters\n", i-1);  
74.         printf("To Uppercase: %s\n", ptr);  
75.         //把信号量减1  
76.         sem_wait(&sem);  
77.     }  
78.     //退出线程  
79.     pthread_exit(NULL);  
80. }  

运行结果如下：

从运行的结果来看，这个程序的确是同时在运行两个线程，一个控制输入，另一个控制处理统计和输出。

四、分析此信号量同步程序的缺陷

但是这个程序有一点点的小问题，就是这个程序依赖接收文本输入的时间足够长，这样子线程才有足够的时间在主线程还未准备好给它更多的单词去处理和统计之前处理和统计出工作区中字符的个数。所以当我们连续快速地给它两组不同的单词去统计时，子线程就没有足够的时间支执行，但是信号量已被增加不止一次，所以字符统计线程（子线程）就会反复处理和统计字符数目，并减少信号量的值，直到它再次变成0为止。

为了更加清楚地说明上面所说的情况，修改主线程的while循环中的代码，如下：

[cpp]  view plain copy print ?

1. printf("Input some text. Enter 'end'to finish...\n");  
2. while(strcmp("end\n", msg) != 0)  
3. {  
4.     if(strncmp("TEST", msg, 4) == 0)  
5.     {  
6.         strcpy(msg, "copy_data\n");  
7.         sem_post(&sem);  
8.     }  
9.     fgets(msg, MSG_SIZE, stdin);  
10.     //把信号量加1  
11.     sem_post(&sem);  
12. }  

重新编译程序，此时运行结果如下：

当我们输入TEST时，主线程向子线程提供了两个输入，一个是来自键盘的输入，一个来自主线程复数据到msg中，然后从运行结果可以看出，运行出现了异常，没有处理和统计从键盘输入TEST的字符串而却对复制的数据作了两次处理。原因如上面所述。

五、解决此缺陷的方法

解决方法有两个，一个就是再增加一个信号量，让主线程等到子线程处理统计完成之后再继续执行；另一个方法就是使用互斥量。

下面给出用增加一个信号量的方法来解决该问题的代码，源文件名为semthread2.c，源代码如下：

[cpp]  view plain copy print ?

1. #include <unistd.h>  
2. #include <pthread.h>  
3. #include <semaphore.h>  
4. #include <stdlib.h>  
5. #include <stdio.h>  
6. #include <string.h>  
7.   
8.   
9. //线程函数  
10. void *thread_func(void *msg);  
11. sem_t sem;//信号量  
12. sem_t sem_add;//增加的信号量  
13.   
14.   
15. #define MSG_SIZE 512  
16.   
17.   
18. int main()  
19. {  
20.     int res = -1;  
21.     pthread_t thread;  
22.     void *thread_result = NULL;  
23.     char msg[MSG_SIZE];  
24.     //初始化信号量,初始值为0  
25.     res = sem_init(&sem, 0, 0);  
26.     if(res == -1)  
27.     {  
28.         perror("semaphore intitialization failed\n");  
29.         exit(EXIT_FAILURE);  
30.     }  
31.     //初始化信号量,初始值为1  
32.     res = sem_init(&sem_add, 0, 1);  
33.     if(res == -1)  
34.     {  
35.         perror("semaphore intitialization failed\n");  
36.         exit(EXIT_FAILURE);  
37.     }  
38.     //创建线程，并把msg作为线程函数的参数  
39.     res = pthread_create(&thread, NULL, thread_func, msg);  
40.     if(res != 0)  
41.     {  
42.         perror("pthread_create failed\n");  
43.         exit(EXIT_FAILURE);  
44.     }  
45.     //输入信息，以输入end结束，由于fgets会把回车（\n）也读入，所以判断时就变成了“end\n”  
46.     printf("Input some text. Enter 'end'to finish...\n");  
47.       
48.     sem_wait(&sem_add);  
49.     while(strcmp("end\n", msg) != 0)  
50.     {  
51.         if(strncmp("TEST", msg, 4) == 0)  
52.         {  
53.             strcpy(msg, "copy_data\n");  
54.             sem_post(&sem);  
55.             //把sem_add的值减1，即等待子线程处理完成  
56.             sem_wait(&sem_add);  
57.         }  
58.         fgets(msg, MSG_SIZE, stdin);  
59.         //把信号量加1  
60.         sem_post(&sem);  
61.         //把sem_add的值减1，即等待子线程处理完成  
62.         sem_wait(&sem_add);  
63.     }  
64.   
65.   
66.     printf("Waiting for thread to finish...\n");  
67.     //等待子线程结束  
68.     res = pthread_join(thread, &thread_result);  
69.     if(res != 0)  
70.     {  
71.         perror("pthread_join failed\n");  
72.         exit(EXIT_FAILURE);  
73.     }  
74.     printf("Thread joined\n");  
75.     //清理信号量  
76.     sem_destroy(&sem);  
77.     sem_destroy(&sem_add);  
78.     exit(EXIT_SUCCESS);  
79. }  
80.   
81.   
82. void* thread_func(void *msg)  
83. {  
84.     char *ptr = msg;  
85.     //把信号量减1  
86.     sem_wait(&sem);  
87.     while(strcmp("end\n", msg) != 0)  
88.     {  
89.         int i = 0;  
90.         //把小写字母变成大写  
91.         for(; ptr[i] != '\0'; ++i)  
92.         {  
93.             if(ptr[i] >= 'a' && ptr[i] <= 'z')  
94.             {  
95.                 ptr[i] -= 'a' - 'A';  
96.             }  
97.         }  
98.         printf("You input %d characters\n", i-1);  
99.         printf("To Uppercase: %s\n", ptr);  
100.         //把信号量加1，表明子线程处理完成  
101.         sem_post(&sem_add);  
102.         //把信号量减1  
103.         sem_wait(&sem);  
104.     }  
105.     sem_post(&sem_add);  
106.     //退出线程  
107.     pthread_exit(NULL);  
108. }  

其运行结果如下：

分析：这里我们多使用了一个信号量sem_add，并把它的初值赋为1，在主线程在使用sem_wait来等待子线程处理完全，由于它的初值为1，所以主线程第一次调用sem_wait总是立即返回，而第二次调用则需要等待子线程处理完成之后。而在子线程中，若处理完成就会马上使用sem_post来增加信号量的值，使主线程中的sem_wait马上返回并执行紧接下面的代码。从运行结果来看，运行终于正常了。注意，在线程函数中，信号量sem和sem_add使用sem_wait和sem_post函数的次序，它们的次序不能错乱，否则在输入end时，可能运行不正常，子线程不能正常退出，从而导致程序不能退出。

至于使用互斥量的方法，将会在下篇文章： Linux多线程——使用互斥量同步线程中详细介绍。