LINUX-c-线程池-(条件信号量+互斥量)

 

knoppix@Microknoppix:/mnt-system/lx/test$ gcc -D_REENTRANT -lpthread -o testcondout testcondout.c
knoppix@Microknoppix:/mnt-system/lx/test$ ./testcondout

please input an integer:(<=1000)26
time out
time out
1/1 finished,push 1.0000000000
1/2 finished,push 0.5000000000
1/3 finished,push 0.3333333333
1/4 finished,push 0.2500000000
1/5 finished,push 0.2000000000
time out
1/6 finished,push 0.1666666667
1/7 finished,push 0.1428571429
1/8 finished,push 0.1250000000
1/9 finished,push 0.1111111111
1/10 finished,push 0.1000000000
time out
1/11 finished,push 0.0909090909
1/12 finished,push 0.0833333333
1/13 finished,push 0.0769230769
1/14 finished,push 0.0714285714
1/15 finished,push 0.0666666667
1/1:1.0000000000 added result 1.0000000000
1/2:0.5000000000 added result 1.5000000000
1/3:0.3333333333 added result 1.8333333333
1/4:0.2500000000 added result 2.0833333333
1/5:0.2000000000 added result 2.2833333333
1/6:0.1666666667 added result 2.4500000000
1/7:0.1428571429 added result 2.5928571429
1/8:0.1250000000 added result 2.7178571429
1/9:0.1111111111 added result 2.8289682540
1/10:0.1000000000 added result 2.9289682540
1/11:0.0909090909 added result 3.0198773449
1/12:0.0833333333 added result 3.1032106782
1/13:0.0769230769 added result 3.1801337551
1/14:0.0714285714 added result 3.2515623266
1/15:0.0666666667 added result 3.3182289932
*******1/1:1.0000000000 computed result 1.0000000000
*******1/2:0.5000000000 computed result 0.5000000000
*******1/3:0.3333333333 computed result 0.8333333333
*******1/4:0.2500000000 computed result 0.5833333333
*******1/5:0.2000000000 computed result 0.7833333333
*******1/6:0.1666666667 computed result 0.6166666667
*******1/7:0.1428571429 computed result 0.7595238095
*******1/8:0.1250000000 computed result 0.6345238095
*******1/9:0.1111111111 computed result 0.7456349206
*******1/10:0.1000000000 computed result 0.6456349206
*******1/11:0.0909090909 computed result 0.7365440115
*******1/12:0.0833333333 computed result 0.6532106782
*******1/13:0.0769230769 computed result 0.7301337551
*******1/14:0.0714285714 computed result 0.6587051837
*******1/15:0.0666666667 computed result 0.7253718504
===============compute finish!=========== result:0.7253718504
1/16 finished,push 0.0625000000
1/17 finished,push 0.0588235294
1/18 finished,push 0.0555555556
1/19 finished,push 0.0526315789
1/20 finished,push 0.0500000000
1/16:0.0625000000 added result 3.3807289932
1/17:0.0588235294 added result 3.4395525226
1/18:0.0555555556 added result 3.4951080782
1/19:0.0526315789 added result 3.5477396571
1/20:0.0500000000 added result 3.5977396571
1/21 finished,push 0.0476190476
1/22 finished,push 0.0454545455
1/23 finished,push 0.0434782609
1/24 finished,push 0.0416666667
1/25 finished,push 0.0400000000
time out
*******1/16:0.0625000000 computed result 0.6628718504
*******1/17:0.0588235294 computed result 0.7216953798
*******1/18:0.0555555556 computed result 0.6661398242
*******1/19:0.0526315789 computed result 0.7187714032
*******1/20:0.0500000000 computed result 0.6687714032
*******1/21:0.0476190476 computed result 0.7163904508
*******1/22:0.0454545455 computed result 0.6709359053
*******1/23:0.0434782609 computed result 0.7144141662
*******1/24:0.0416666667 computed result 0.6727474995
*******1/25:0.0400000000 computed result 0.7127474995
===============compute finish!=========== result:0.7127474995
1/21:0.0476190476 added result 3.6453587048
1/22:0.0454545455 added result 3.6908132502
1/23:0.0434782609 added result 3.7342915111
1/24:0.0416666667 added result 3.7759581778
1/25:0.0400000000 added result 3.8159581778
1/26 finished,push 0.0384615385
time out
time out
*******1/26:0.0384615385 computed result 0.6742859611
===============compute finish!=========== result:0.6742859611
1/26:0.0384615385 added result 3.8544197162
================add finish!============ result:3.8544197162
2个线程完成累加和累加减运算(其中一个采用超时等待条件信号,另一个采用等待条件信号),n个线程完成计算每个符点数

C代码
  1.    #include <pthread.h>     
  2.    #include <bits/pthreadtypes.h>     
  3.    #include <stdio.h>     
  4.    #include <stdlib.h>     
  5.    #include <errno.h>    
  6.    #define MAXS 1000      
  7.    #define MAXTDS 5 //线程池大小   
  8.        
  9.         
  10.   double myjg[MAXS+1];//计算结果存放位置     
  11.   int max;     
  12.   pthread_mutex_t eventlock;   //互斥锁   
  13.   pthread_cond_t myevent;   //条件变量   
  14.   pthread_t threads[MAXTDS+2];   //线程池,完成1/n计算   
  15.   int isend=0;   
  16.   
  17.   int done;       
  18.        
  19.  void *mycomp(void *x){//计算1/i的结果,计算结果放在一个数组中。     
  20.    int i=0;   
  21.    int rc;   
  22.    while (1){    
  23.      pthread_mutex_lock(&eventlock);     
  24.      if (isend){   
  25.              pthread_mutex_unlock(&eventlock);    
  26.              break;                 
  27.      }      
  28.      i=myjg[0];//myjg[0]存放着线程已经计算到的i。       
  29.      if (i<max){   
  30.          i++;   
  31.          myjg[0]=i;             
  32.      }     
  33.          if (i==max){//最后一个数   
  34.               myjg[i]=(1/(double)i);   
  35.               isend=1;     
  36.               printf(“1/%d finished,push %.10f\n”,i,myjg[i]);    
  37.               fflush(stdout);   
  38.               pthread_mutex_unlock(&eventlock);    
  39.               sleep(3);   
  40.               rc=pthread_cond_signal(&myevent);//广播信号,多个任务不被阻塞,多个任务竞争互斥锁的所有权。也可以使用pthread_cond_signal(&event);发送信号,这样只有一个线程不被阻塞,其它线程都被阻塞。   
  41.               if (rc){   
  42.                   perror(“pthread_cond_broadcast”);   
  43.                   fflush(stdout);   
  44.               }     
  45.               sleep(2);     
  46.               break;        
  47.          }   
  48.        
  49.      //开始计算   
  50.      myjg[i]=(1/(double)i);     
  51.      printf(“1/%d finished,push %.10f\n”,i,myjg[i]);    
  52.      fflush(stdout);       
  53.      pthread_mutex_unlock(&eventlock);      
  54.      if (!(i%MAXTDS)){   
  55.         sleep(3);    
  56.         pthread_cond_broadcast(&myevent);//广播信号,多个任务不被阻塞,多个任务竞争互斥锁的所有权。也可以使用pthread_cond_signal(&event);发送信号,这样只有一个线程不被阻塞,其它线程都被阻塞。       
  57.         sleep(3);    
  58.      }   
  59.   }    
  60.   pthread_exit(NULL);   
  61. }     
  62.   
  63.        
  64.  void *myprint1(void *xx){//读取数组,将计算结果累加,最终完成1/1+1/2+1/3+……+1/n的计算,使用超时等待     
  65.    int maxi;     
  66.    int curj=1;     
  67.    double jg=0;    
  68.    int rc;    
  69.    struct timeval now;//使用微秒   
  70.    struct timespec timeout;  //使用纳秒   
  71.   
  72.   
  73.          
  74.    while(curj<=max)     
  75.      {     
  76.       //取当前时间   
  77.       // 深未来技术http://deepfuture.javaeye.com/      
  78.          gettimeofday(&now);   
  79.       //准备时间间隔   
  80.         timeout.tv_sec=now.tv_sec+1;   
  81.         timeout.tv_nsec=now.tv_usec*1000;   
  82.          maxi=0;   
  83.            
  84.          pthread_mutex_lock(&eventlock);//用于条件变量的互斥,条件变量就是一个用来发送事件发生信号的信号量   
  85.          rc=pthread_cond_timedwait(&myevent,&eventlock,&timeout);//在等待条件变量myevent的发生,超时就返回,不再等待。条件变量必须与一个互斥锁eventlock相关联,条件变量不提供锁定,必须有一个互斥锁eventlock配合。   
  86.         //互斥锁eventlock在调用wait前应锁定,然后在wait期间,互斥量eventlock被解锁。挂起线程执行,直到条件变量myevent收到信号                
  87.   
  88.          if (rc==0){  // 深未来技术http://deepfuture.javaeye.com/     
  89.               maxi=myjg[0];    
  90.               fflush(stdout);    
  91.               pthread_mutex_unlock(&eventlock);   
  92.               for (;curj<=maxi;curj++)   
  93.               {    // 深未来技术http://deepfuture.javaeye.com/     
  94.                    jg+=myjg[curj];     
  95.                    printf(“1/%d:%.10f added result %.10f\n”,curj,myjg[curj],jg);        
  96.                    fflush(stdout);                   
  97.               }      
  98.   
  99.          }    
  100.          else if (rc==ETIMEDOUT){//TIMEOUT   
  101.               printf(“time out\n”);   
  102.               fflush(stdout);    
  103.               pthread_mutex_unlock(&eventlock);    
  104.               continue;               
  105.          }    
  106.          else  {  // 深未来技术http://deepfuture.javaeye.com/     
  107.               perror(“pthread_cond_wait”);   
  108.               fflush(stdout);    
  109.               pthread_mutex_unlock(&eventlock);    
  110.               continue;                 
  111.          }   
  112.     }     
  113.     printf(“================add finish!============ result:%.10f\n”,jg);//输出累加结果。     
  114.     fflush(stdout);   
  115.     pthread_exit(NULL);   
  116. }     
  117.        
  118. void *myprint2(void *xx){//读取数组,将计算结果完成1/1+1/2-1/3+1/4-1/5……的计算     
  119.    int maxi=0;     
  120.    int curi=1;     
  121.    double jg=0;    
  122.    int fh=1;   
  123.    int rc;    
  124.    while(curi<=max)     
  125.      {     
  126.          maxi=0;   
  127.          sleep(2);    
  128.          pthread_mutex_lock(&eventlock);//用于条件变量的互斥,条件变量就是一个用来发送事件发生信号的信号量   
  129.          rc=pthread_cond_wait(&myevent,&eventlock);//在等待条件变量myevent的发生。条件变量必须与一个互斥锁eventlock相关联,条件变量不提供锁定,必须有一个互斥锁eventlock配合。   
  130.         //互斥锁eventlock在调用wait前应锁定,然后在wait期间,互斥量eventlock被解锁。挂起线程执行,直到条件变量myevent收到信号     
  131.   // 深未来技术http://deepfuture.javaeye.com/     
  132.          if (rc==0){   
  133.               maxi=myjg[0];    
  134.               fflush(stdout);    
  135.               pthread_mutex_unlock(&eventlock);   
  136.               while (curi<=maxi){                 
  137.                     jg+=fh*myjg[curi];     
  138.                     printf(“*******1/%d:%.10f computed result %.10f\n”,curi,myjg[curi],jg);     
  139.                     fflush(stdout);          
  140.                     fh=-fh;   
  141.                     curi++;   
  142.              }                    
  143.              printf(“===============compute finish!=========== result:%.10f\n”,jg);//输出累加结果    
  144.              fflush(stdout);                 
  145.          }    
  146.          else{//error   
  147.               perror(“pthread_cond_wait”);   
  148.               fflush(stdout);    
  149.               pthread_mutex_unlock(&eventlock);    
  150.               continue;               
  151.          }     
  152.    }         
  153.   
  154.     pthread_exit(NULL);   
  155.  }     
  156.       
  157.    int main(){     
  158.    //计算1+1/2+1/3+……和1+1/2-1/3+1/4-1/5……     
  159.   
  160.      pthread_mutex_init(&eventlock,NULL);   
  161.      pthread_cond_init(&myevent,NULL);            
  162.      int i =0;   
  163.         
  164.      printf(“please input an integer:(<=%d)”,MAXS);     
  165.      while (scanf(“%d”,&max),max>MAXS){//n的最大值     
  166.         printf(“please input an integer:(<=%d)”,MAXS);     
  167.      };     
  168.      //深未来技术http://deepfuture.javaeye.com/     
  169.      myjg[0]=0;   
  170.      
  171.      pthread_create(&(threads[i]),NULL,myprint1,(void *)&i);   
  172.      sleep(1);    
  173.      i++;         
  174.      pthread_create(&(threads[i]),NULL,myprint2,(void *)&i);     
  175.      sleep(1);     
  176.      i++;    
  177.      for (;i<=MAXTDS;i++){     
  178.          pthread_create(&(threads[i]),NULL,mycomp,(void *)&i);     
  179.          sleep(1);           
  180.     }      
  181.     sleep(MAXTDS*2*(i/10+1));  //wait……   
  182.     pthread_mutex_destroy(&eventlock);       
  183.     return(0);     
  184.  }      
  185.        
 
20101020
 

发表评论

电子邮件地址不会被公开。