一道多线程编程题初解

2140阅读　2评论2013-05-30　cjdao
分类：LINUX

废话少说直接上代码!


  1. /*
  2. * 有四个线程1、2、3、4。线程1的功能就是输出A，线程2的功能就是输出B，以此类推.........
  3. * 现在有四个文件file1, file2,file3, file4。初始都为空。现要让四个文件呈如下格式：
  4. * file1：A B C D A B....
  5. * file2：B C D A B C....
  6. * file3：C D A B C D....
  7. * file4：D A B C D A....
  8. */
  9. #include <stdio.h>
  10. #include <pthread.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include <fcntl.h>
  14. #include <unistd.h>
  15. #include <stdlib.h>

  17. pthread_t threads[4];
  18. char writer_char[4] = {'A','B', 'C', 'D'};
  19. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  20. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

  22. struct file_res{
  23.     pthread_t *writer; /*当前文件可以被那个线程写入*/
  24.     int fd; /*文件描述符*/
  25. }file_res[4] =
  26. {
  27.     {.writer=&threads[0]},/*file1初始化可以被线程1写入'A'*/
  28.     {.writer=&threads[1]},/*file2初始化可以被线程2写入'B'*/
  29.     {.writer=&threads[2]},/*file3初始化可以被线程3写入'C'*/
  30.     {.writer=&threads[3]},/*file4初始化可以被线程4写入'D'*/
  31. };

  33. void *writer_routine(void *arg)
  34. {
  35.     int index = (int)arg;
  36.     int file_index[4] ;
  37.     int can_write_file_cnt = 0;
  38.     int i = 0;
  39.     int next_index=0;
  40.     printf("thread %d is running, and will write '%c' to files\n", index, writer_char[index]);
  41.     
  42.     while(1)
  43.     {
  44.         if (0!=pthread_mutex_lock(&mutex))
  45.             exit(-1);
  46.         for(;;) {
  47.          /*下面的for语句查询本线程可以写的文件id*/
  48.             for(i=0; i<(sizeof(file_res)/sizeof(file_res[0])); i++) {
  49.                 if (&threads[index]==file_res[i].writer) {
  50.                     file_index[can_write_file_cnt++] = i;
  51.                     next_index = index+1;
  52.                     if (next_index>3)next_index=0;
  53.                     file_res[i].writer = &threads[next_index];
  54.                 }
  55.             }
  56.             /*找到本线程可以写的文件id,则退出for(;;), 执行写操作*/
  57.             if (can_write_file_cnt != 0)
  58.                 break;
  59.             /*等待其他线程唤醒*/
  60.             pthread_cond_wait(&cond,&mutex);
  61.         }        
  62.         
  63.         /*本线程可以写的文件,执行写操作*/
  64.         for(i=0; i<can_write_file_cnt; i++) {
  65.             write(file_res[file_index[i]].fd, &writer_char[index], sizeof(writer_char[index]));
  66.         }
  67.         can_write_file_cnt = 0;
  68.         
  69.         /*唤醒下一批线程*/
  70.         pthread_cond_broadcast(&cond);
  71.         if (0!=pthread_mutex_unlock(&mutex))
  72.             exit(-1);    
  73.     }
  74. }
  75.  
  76. int main(int argc, char* argv[])
  77. {
  78.     int i;
  79.     
  80.     for(i=0; i<4; i++)
  81.     {
  82.         char file_name[] = "filex";
  83.         sprintf(file_name, "file%d", i+1);
  84.         if ((file_res[i].fd = open(file_name, O_RDWR|O_CREAT|O_TRUNC, 0666))<0)
  85.         {
  86.             printf("open %s error.\n", file_name);
  87.             exit(-1);
  88.         }
  89.     }
  90.     
  91.     for (i=0; i<(sizeof(threads)/sizeof(pthread_t)); i++)
  92.     {
  93.         if(pthread_create(&threads[i], NULL, writer_routine, (void *)i))
  94.         {
  95.             printf("create writer thread error\n");
  96.             exit(-1);
  97.         }
  98.     }
  99.     pthread_exit(NULL);
  100.     return 0;
  101. }

上一篇：linux内核内存管理的三个阶段分析（1）
下一篇：多线程模型下的无锁编程

文章评论