C小程序 - 分析一个多线程的小程序

C小程序 - 分析一个多线程的小程序 (2012-11-01 11:51)

分类：  Linux C

这个程序的作用是统计输入的两个文件的字数，使用方法
./program cp1.c cp2.c

1. /* threaded word counter for two files.    
   
2.  */
   
3. 
   
4. #include <stdio.h>
   
5. #include <pthread.h>
   
6. #include <ctype.h>
   
7. 
   
8. struct arg_set {        
   
9.         char *fname;    //文件名
   
10.         int count;    //文字数量
    
11.         char *name;   //线程名字
    
12. };
    
13. 
    
14. struct arg_set *mailbox = NULL;
    
15. pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    
16. pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
    
17. 
    
18. main(int ac, char *av[])
    
19. {
    
20.     pthread_t t1, t2;        /* two threads */
    
21.     struct arg_set args1, args2;    /* two argsets */
    
22.     void     *count_words(void *);
    
23.     int reports_in = 0;
    
24.     int     total_words = 0;
    
25. 
    
26.     if ( ac != 3 ){
    
27.         printf("usage: %s file1 file2\n", av[0]);
    
28.         exit(1);
    
29.     }
    
30.     pthread_mutex_lock(&lock);    // 对互斥量加锁
    
31. 
    
32.     args1.fname = av[1];
    
33.     args1.count = 0;
    
34.     args1.name = "1";
    
35.     pthread_create(&t1, NULL, count_words, (void *) &args1); //开启第一个线程
    
36. 
    
37.     args2.fname = av[2];
    
38.     args2.count = 0;
    
39.     args2.name = "2";
    
40.     pthread_create(&t2, NULL, count_words, (void *) &args2); //开启第二个线程
    
41.     
    
42.     /* sleep(10); */ //这里通过sleep函数来检查一下对同一个lock加锁多次的现象，
43.                      //在本人的机器上，主线程sleep的时候，
    
44.                      //子线程们会pending在线程函数对互斥量加锁的地方;也就是count_words中的第17行的地方。
    
45.     while( reports_in < 2 ){
    
46.         printf("MAIN: waiting for flag to go up\n");
    
47.         pthread_cond_wait(&flag, &lock); //pthread_cond_wait的作用是
    
48.                                          //1.先释放锁 
    
49.                                          //2.等待信号flag的变化 
    
50.                                          //3.当收到信号变更通知的时候被唤醒，再次对互斥量加锁
    
51.         printf("MAIN: Wow! flag was raised, I have the lock\n");
    
52.         printf("%7d: %s\n", mailbox->count, mailbox->fname);
    
53.         total_words += mailbox->count;
    
54.         if ( mailbox == &args1) 
    
55.             pthread_join(t1,NULL);
    
56.         if ( mailbox == &args2) 
    
57.             pthread_join(t2,NULL);
    
58.         mailbox = NULL;
    
59.         pthread_cond_signal(&flag);        // 告知信号有变化，如果没有线程在等待信号变化，
60.                                            //那么不会发生什么，如果有线程在等待信号，那么该线程被唤醒
    
61.         reports_in++;
    
62.     }
    
63.     printf("%7d: total words\n", total_words);
    
64. }
    
65. void *count_words(void *a)
    
66. {
    
67.     struct arg_set *args = a;    /* cast arg back to correct type */
    
68.     FILE *fp;
    
69.     int c, prevc = '\0';
    
70.     
    
71.     if ( (fp = fopen(args->fname, "r")) != NULL ){
    
72.         while( ( c = getc(fp)) != EOF ){
    
73.             if ( !isalnum(c) && isalnum(prevc) )
    
74.                 args->count++;
    
75.             prevc = c;
    
76.         }
    
77.         fclose(fp);
    
78.     } else 
    
79.         perror(args->fname);
    
80.     printf("COUNT%s: waiting to get lock\n", args->name);
    
81.     pthread_mutex_lock(&lock);    //子线程对互斥量加锁
    
82.     printf("COUNT%s: have lock, storing data\n", args->name);
    
83. 
    
84.     if ( mailbox != NULL ){ //如果mailbox不为空，这种情况出现在第一个子线程结束后，
85.                             //第二个子线程马上获得锁，并开始执行，
    
86.                              //而主线程此时虽然已经获得信号变化通知，
87.                              //但是被其它子线程抢先对互斥量加锁并执行。
88.                              //这样主线程的pthread_cond_wait(&flag, &lock);就无法对互斥量加锁，
    
89.                              //pthread_cond_wait(&flag, &lock);函数不能返回，继续等待。
    
90.         printf("COUNT%s: oops..mailbox not empty. wait for signal\n", args->name);
    
91.         pthread_cond_wait(&flag,&lock); //而当第二个子线程执行到这里发现mailbox不为空的时候，它执行                                                 //pthread_cond_wait(&flag, &lock);函数，
92.                                         //这个函数首先释放锁，并等待信号变化
    
93.                                         //此时，主线程的pthread_cond_wait(&flag, &lock);才能对互斥量加锁，
94.                                         //从而返回，继续执行。
    
95.                                         //而这里第二个子线程将等待主线程pthread_cond_signal(&flag);
96.                                         //函数的执行，从而获取信号变化通知，
97.                                         //然后主线程的while循环到再次执行pthread_cond_wait(&flag, &lock);
98.                                         //的时候，主线程释放了锁，子线程才能对互斥量继续加锁，从而继续执行。
    
99.     }
    
100.     mailbox = args;            /* put ptr to our args there */
     
101.     printf("COUNT%s: raising flag\n", args->name);
     
102.     pthread_cond_signal(&flag);                //通知主线程信号变化
     
103.     printf("COUNT%s: unlocking box\n", args->name);
     
104.     pthread_mutex_unlock(&lock);                //释放锁。
     
105.     printf("COUNT%s: unlocked box\n", args->name);
     
106.     return NULL;
     
107. }

输出：

1. [lizhuohua@lizhuohua-phy Program]$ ./program cp1.c cp2.c
   
2. COUNT1: waiting to get lock
   
3. COUNT2: waiting to get lock
   
4. MAIN: waiting for flag to go up
   
5. COUNT1: have lock, storing data
   
6. COUNT1: raising flag
   
7. COUNT1: unlocking box
   
8. COUNT1: unlocked box
   
9. MAIN: flag was raised, I have the lock
   
10.     131: cp1.c
    
11. MAIN: waiting for flag to go up
    
12. COUNT2: have lock, storing data
    
13. COUNT2: raising flag
    
14. COUNT2: unlocking box
    
15. COUNT2: unlocked box
    
16. MAIN: flag was raised, I have the lock
    
17.     131: cp2.c
    
18.     262: total word