一个定时器的普通实现，多进程实现和多线程实现的对比

要求实现一个简单的定时器，该程序要求的输入格式为：

N prompt message

其中N表示时间，prompt message表示提示信息。即过了N秒之后要在终端上显示出提示信息。一共用了三种方式实现：（1）最普通的方式，阻塞I/0+同步。（2）使用进程实现。（3）使用线程实现。

1. /*alarm.c*/ 
2.  
3. #include "../error.h" 
4.  
5. #include<time.h> 
6.  
7. int main(int argc,char *argv[]) 
8.  
9. { 
10.  
11.         int seconds; 
12.  
13.         char line[128]; 
14.  
15.         char message[64]; 
16.  
17.         while(NULL != fgets(line,sizeof(line),stdin)) 
18.  
19.         { 
20.  
21.                 if( 2 > sscanf(line,"%d %64[^\n]",&seconds,message)) 
22.  
23.                         fprintf(stderr,"Bad Command\n"); 
24.  
25.                 else 
26.  
27.                 { 
28.  
29.                         sleep(seconds); 
30.  
31.                         fprintf(stdout,"%s\n",message); 
32.  
33.                 } 
34.  
35.         } 
36.  
37.         return 0; 
38.  
39. } 

评注：

1.常量和函数比较的时候，将常量放在前面可以防止将==写成=，因为编译器会报错。

2.sscanf为从一个字符缓冲区中格式化读取数据。注意字符缓冲区放在第一个参数位置。使用%N可以控制读取字符的数量，中括号的作用和正则表达式中的作用一样，将不读取的字符排除掉或者仅读取中括号内指定的字符集，成功时，返回读取的参数的个数。

3.使用fgets+sscanf，简化了从命令行中提取参数问题。

3.fgets从指定的文件描述符中读取一行字符串，失败时返回NULL。

4.对于每个函数都添加了判断语句，特别有助于调试。

1. /*alarm_fork.c*/ 
2.  
3. #include "../error.h" 
4.  
5. #include <sys/types.h> 
6.  
7. #include<wait.h> 
8.  
9.   
10.  
11. int main(int argc,char *argv[]) 
12.  
13. { 
14.  
15.         pid_t pid; 
16.  
17.         int seconds; 
18.  
19.         char line[128]; 
20.  
21.         char message[64]; 
22.  
23.         while(NULL != fgets(line,sizeof(line),stdin)) 
24.  
25.         { 
26.  
27.                 if(2 > sscanf(line,"%d %64[^\n]",&seconds,message)) 
28.  
29.                 { 
30.  
31.                         fprintf(stdout,"Bad command.\n"); 
32.  
33.                         continue; 
34.  
35.                 } 
36.  
37.                 else 
38.  
39.                 { 
40.  
41.                         pid = fork(); 
42.  
43.                         if((pid_t)-1 == pid) 
44.  
45.                         { 
46.  
47.                                 error_abort("fork error..."); 
48.  
49.                         } 
50.  
51.                         else if((pid_t)0 == pid) 
52.  
53.                         { 
54.  
55.                                 sleep(seconds); 
56.  
57.                                 fprintf(stdout,"%s\n",message); 
58.  
59.                                 exit(0); 
60.  
61.                         } 
62.  
63.                         else 
64.  
65.                         { 
66.  
67.                                 do 
68.  
69.                                 { 
70.  
71.                                         pid = waitpid((pid_t)-1,NULL,WNOHANG); 
72.  
73.                                         if((pid_t)-1 == pid) 
74.  
75.                                         { 
76.  
77.                                                 error_abort("waitpid error..."); 
78.  
79.                                         } 
80.  
81.                                 }while((pid_t)0 != pid); 
82.  
83.   
84.  
85.                         } 
86.  
87.                 } 
88.  
89.         } 
90.  
91.         return 0; 
92.  
93. } 

1.pid_t这个类型在sys/types.h头文件中。

2.比较的时候要进行强制类型转换，比如判断进程id是不是为0，就要使用(pid_t)0 == pid这样的判断语句。

3.waitpid的第一个参数设置为-1，第三个参数设置为WNOHANG,表示非阻塞等待任何一个子进程。如果发现一个子进程返回，立即再判断是否还有其他进程返回。可以迅速的释放不再使用的资源。

1. /*alarm_thread.c*/ 
2.  
3. #include "../error.h" 
4.  
5. #include <sys/types.h> 
6.  
7. #include <pthread.h> 
8.  
9. #include <time.h> 
10.  
11.   
12.  
13. typedef struct alarm_tag 
14.  
15. { 
16.  
17.         int seconds; 
18.  
19.         char message[64]; 
20.  
21. }alarm_t,*alarm_p; 
22.  
23.   
24.  
25. void * alarm_thread(void * arg) 
26.  
27. { 
28.  
29.         int status; 
30.  
31.         status = pthread_detach(pthread_self()); 
32.  
33.         if(0 != status) 
34.  
35.                 err_abort("detaching thread failure...",status); 
36.  
37.         alarm_p alarm = (alarm_p) arg; 
38.  
39.         sleep(alarm->seconds); 
40.  
41.         fprintf(stdout,"%s\n",alarm->message); 
42.  
43. } 
44.  
45.   
46.  
47. int main(int argc,char *argv[]) 
48.  
49. { 
50.  
51.         pthread_t thread; 
52.  
53.         char line[128]; 
54.  
55.         alarm_p alarm; 
56.  
57.         int status; 
58.  
59.         while(NULL != fgets(line,sizeof(line),stdin)) 
60.  
61.         { 
62.  
63.                 alarm = (alarm_p) malloc(sizeof(alarm_t)); 
64.  
65.                 if( NULL == alarm) 
66.  
67.                         error_abort("Allocating alarm failure..."); 
68.  
69.                 if(2 > sscanf(line,"%d %64[^\n]",&alarm->seconds,alarm->message)) 
70.  
71.                 { 
72.  
73.                         fprintf(stdout,"%s\n","Bad command"); 
74.  
75.                         free(alarm); 
76.  
77.                         continue; 
78.  
79.                 } 
80.  
81.                 else 
82.  
83.                 { 
84.  
85.                         status = pthread_create(&thread,NULL,alarm_thread,(void *)alarm); 
86.  
87.                         if(0 != status) 
88.  
89.                                 err_abort("creating thread failure...",status); 
90.  
91.                 } 
92.  
93.         } 
94.  
95.         return 0; 
96.  
97. } 

1.Pthreads相关的类型，接口原型，常量都在pthread.h这个头文件中，编译的时候要加 -lpthread.

2.由于线程的参数只有一个，所以要将传给线程的所有参数封装到一个结构体中。

使用普通方式，多进程，多线程的比较

alarm一次只能发出一个定时请求。如果发出一个10分钟的请求，那么必须要等十分钟才能发出下一个请求。多进程解决了这个同步问题，但是在一个系统中，一个用户能够启动的进程的数量是非常有限的，多线程受到这个影响要小得多。

多线程的几个好处

（1）发掘多核计算潜力

（2）发掘程序自身的并发性

（3）模块式的编程模型，可以更加清晰的表达不同事件之间的关系

本文转自hipercomer 51CTO博客，原文链接:http://blog.51cto.com/hipercomer/908959