Linux多线程编程实例 [转→改]

2356阅读　0评论2011-11-23　bo_00
分类：LINUX

原地址：http://blog.csdn.net/tody_guo/article/details/5984367

对原帖稍微改了一些小地方。

  1. /*********
  2. 多线程编程
  3. **********/
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <pthread.h>

  8. void *mythread2()
  9. {
  10.     int i;
  11.     for(i=0;i<3;i++)
  12.         printf("This is a pthread 2:\n");
  13.     pthread_exit("pthread 2 Thank you for the CPU time\n");
  14. }
  15. void *mythread1()
  16. {
  17.     int i;
  18.     for(i=0;i<3;i++)
  19.         printf("This is a pthread 1:\n");
  20.     pthread_exit("pthread 1 Thank you for the CPU time\n");
  21. }
  22. int main(int argc,char **argv)
  23. {
  24.     pthread_t id1,id2;
  25.     int i, ret;
  26.     void *thread_result;
  27.     ret = pthread_create(&id2,NULL,mythread2,NULL);
  28.     if(ret!=0)
  29.     {
  30.          printf("Create pthread 2 failed\n");
  31.         exit(0);
  32.     }
  33.     ret = pthread_create(&id1,NULL,mythread1,NULL);
  34.     if(ret!=0)
  35.     {
  36.          printf("Create pthread 1 failed\n");
  37.         exit(0);
  38.     }
  39.     
  40.     for(i=0;i<3;i++)
  41.         printf("This is the main process:\n");
  42.     pthread_join(id1,&thread_result);
  43.     printf("Thread1 joined,it returned:%s",(char *)thread_result);
  44.     pthread_join(id2,&thread_result);
  45.     printf("Thread2 joined,it returned:%s",(char *)thread_result);
  46.     return 0;
  47. }
  48. /* 打印输出结果 */
  49. /* This is the main process: */
  50. /* This is the main process: */
  51. /* This is the main process: */
  52. /* This is a pthread 1: */
  53. /* This is a pthread 1: */
  54. /* This is a pthread 1: */
  55. /* Thread1 joined,it returned:pthread 1 Thank you for the CPU time */
  56. /* This is a pthread 2: */
  57. /* This is a pthread 2: */
  58. /* This is a pthread 2: */
  59. /* Thread2 joined,it returned:pthread 2 Thank you for the CPU time */

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  4. #include <unistd.h>

  6. void *mythread2()
  7. {
  8.     int i;
  9.     for(i=0;i<3;i++)
  10.     {
  11.         printf("This is a pthread 2:\n");
  12.         sleep(1);
  13.     }
  14.     pthread_exit("pthread 2 Thank you for the CPU time\n");
  15. }
  16. void *mythread1()
  17. {
  18.     int i;
  19.     for(i=0;i<3;i++)
  20.     {
  21.         printf("This is a pthread 1:\n");
  22.         sleep(1);
  23.     }
  24.     pthread_exit("pthread 1 Thank you for the CPU time\n");
  25. }
  26. int main()
  27. {
  28.     pthread_t     id1,id2;
  29.     int         i, ret;
  30.     void        *thread_result;
  31.     ret = pthread_create(&id2,NULL,mythread2,NULL);
  32.     if(ret!=0)
  33.     {
  34.         printf("Create pthread 2 failed\n");
  35.         exit(0);
  36.     }
  37.     ret = pthread_create(&id1,NULL,mythread1,NULL);
  38.     if(ret!=0)
  39.     {
  40.         printf("Create pthread 1 failed");
  41.         exit(0);
  42.     }
  43.     for(i=0;i<3;i++)
  44.     {
  45.         printf("This is the main process:\n");
  46.         sleep(1);
  47.     }
  48.     pthread_join(id1,&thread_result);
  49.     printf("Thread1 joined,it returned:%s",(char *)thread_result);
  50.     pthread_join(id2,&thread_result);
  51.     printf("Thread2 joined,it returned:%s",(char *)thread_result);
  52.     return 0;
  53. }
  54. /* 打印输出结果 */
  55. /* This is the main process: */
  56. /* This is a pthread 1: */
  57. /* This is a pthread 2: */
  58. /* This is the main process: */
  59. /* This is a pthread 1: */
  60. /* This is a pthread 2: */
  61. /* This is the main process: */
  62. /* This is a pthread 1: */
  63. /* This is a pthread 2: */
  64. /* Thread1 joined,it returned:pthread 1 Thank you for the CPU time */
  65. /* Thread2 joined,it returned:pthread 2 Thank you for the CPU time */

  1. /*********
  2. 取消线程
  3. **********/

  5. #include <pthread.h>
  6. #include <stdio.h>
  7. #include <errno.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>

  11. #define handle_error_en(en, msg) \
  12.         do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

  14. static void *
  15. thread_func(void *ignored_argument)
  16. {
  17.     int s;

  19.    /* Disable cancellation for a while, so that we don't
  20.        immediately react to a cancellation request */

  22.    s = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
  23.     if (s != 0)
  24.         handle_error_en(s, "pthread_setcancelstate");

  26.    printf("thread_func(): started; cancellation disabled\n");
  27.     sleep(5);
  28.     printf("thread_func(): about to enable cancellation\n");

  30.    s = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
  31.     if (s != 0)
  32.         handle_error_en(s, "pthread_setcancelstate");

  34.    /* sleep() is a cancellation point */

  36.    sleep(1000); /* Should get canceled while we sleep */

  38.    /* Should never get here */

  40.    printf("thread_func(): not canceled!\n");
  41.     return NULL;
  42. }

  44. int
  45. main(void)
  46. {
  47.     pthread_t thr;
  48.     void *res;
  49.     int s;

  51.    /* Start a thread and then send it a cancellation request */

  53.    s = pthread_create(&thr, NULL, &thread_func, NULL);
  54.     if (s != 0)
  55.         handle_error_en(s, "pthread_create");

  57.    sleep(2); /* Give thread a chance to get started */

  59.    printf("main(): sending cancellation request\n");
  60.     s = pthread_cancel(thr);
  61.     if (s != 0)
  62.         handle_error_en(s, "pthread_cancel");

  64.    /* Join with thread to see what its exit status was */

  66.    s = pthread_join(thr, &res);
  67.     if (s != 0)
  68.         handle_error_en(s, "pthread_join");

  70.    if (res == PTHREAD_CANCELED) //目标线程被取消，PTHREAD_CANCELED会被放置在*res中
  71.         printf("main(): thread was canceled\n");
  72.     else
  73.         printf("main(): thread wasn't canceled (shouldn't happen!)\n");
  74.     exit(EXIT_SUCCESS);
  75. }


  2. /*********
  3. 线程属性
  4. **********/
  5. #define _GNU_SOURCE /* 引入 pthread_getattr_np() 声明 */
  6. #include <pthread.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include <errno.h>

  12. #define handle_error_en(en, msg) \
  13.         do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

  15. static void
  16. display_pthread_attr(pthread_attr_t *attr, char *prefix)
  17. {
  18.     int s, i;
  19.     size_t v;
  20.     void *stkaddr;
  21.     struct sched_param sp;

  23.     s = pthread_attr_getdetachstate(attr, &i);//获取线程属性对象的分离状态属性
  24.     if (s != 0)
  25.         handle_error_en(s, "pthread_attr_getdetachstate");
  26.     printf("%sDetach state = %s\n", prefix,
  27.         (i == PTHREAD_CREATE_DETACHED) ? "PTHREAD_CREATE_DETACHED" :
  28.         (i == PTHREAD_CREATE_JOINABLE) ? "PTHREAD_CREATE_JOINABLE" :
  29.         "???");

  31.     s = pthread_attr_getscope(attr, &i);//获取线程属性对象里的竞争作用域属性
  32.     if (s != 0)
  33.         handle_error_en(s, "pthread_attr_getscope");
  34.     printf("%sScope = %s\n", prefix,
  35.         (i == PTHREAD_SCOPE_SYSTEM) ? "PTHREAD_SCOPE_SYSTEM" :
  36.         (i == PTHREAD_SCOPE_PROCESS) ? "PTHREAD_SCOPE_PROCESS" :
  37.         "???");

  39.     s = pthread_attr_getinheritschedw(attr, &i);//获取 线程属性对象里的继承调度属性
  40.     if (s != 0)
  41.         handle_error_en(s, "pthread_attr_getinheritsched");
  42.     printf("%sInherit scheduler = %s\n", prefix,
  43.         (i == PTHREAD_INHERIT_SCHED) ? "PTHREAD_INHERIT_SCHED" :
  44.         (i == PTHREAD_EXPLICIT_SCHED) ? "PTHREAD_EXPLICIT_SCHED" :
  45.         "???");

  47.     s = pthread_attr_getschedpolicy(attr, &i);//获取线程属性对象的调度策略属性
  48.     if (s != 0)
  49.     handle_error_en(s, "pthread_attr_getschedpolicy");
  50.     printf("%sScheduling policy = %s\n", prefix,
  51.         (i == SCHED_OTHER) ? "SCHED_OTHER" :
  52.         (i == SCHED_FIFO) ? "SCHED_FIFO" :
  53.         (i == SCHED_RR) ? "SCHED_RR" :
  54.         "???");

  56.     s = pthread_attr_getschedparam(attr, &sp);//获取在线程属性对象里的调度参数属性
  57.     if (s != 0)
  58.         handle_error_en(s, "pthread_attr_getschedparam");
  59.     printf("%sScheduling priority = %d\n", prefix, sp.sched_priority);

  61.     s = pthread_attr_getguardsize(attr, &v);//获取 线程属性对象里预留空间尺寸
  62.     if (s != 0)
  63.         handle_error_en(s, "pthread_attr_getguardsize");
  64.     printf("%sGuard size = %d bytes\n", prefix, v);

  66.     s = pthread_attr_getstack(attr, &stkaddr, &v);//获取线程属性对象里的栈属性
  67.     if (s != 0)
  68.         handle_error_en(s, "pthread_attr_getstack");
  69.     printf("%sStack address = %p\n", prefix, stkaddr);
  70.     printf("%sStack size = 0x%x bytes\n", prefix, v);
  71. }

  73. static void *
  74. thread_start(void *arg)
  75. {
  76.     int s;
  77.     pthread_attr_t gattr;

  79.     /* pthread_getattr_np() 一个非标准的 GNU 扩展，
  80.         它用于取得其第一个参数引用的线程的属性。*/

  82.     s = pthread_getattr_np(pthread_self(), &gattr);//pthread_self()获得calling线程的线程id
  83.     if (s != 0)
  84.         handle_error_en(s, "pthread_getattr_np");

  86.     printf("Thread attributes:\n");
  87.     display_pthread_attr(&gattr, "\t");

  89.     exit(EXIT_SUCCESS); /* 终止所有线程 */
  90. }

  92. int
  93. main(int argc, char *argv[])
  94. {
  95.     pthread_t thr;
  96.     pthread_attr_t attr;
  97.     pthread_attr_t *attrp; /* NULL or &attr */
  98.     int s;

  100.     attrp = NULL;

  102.     /* 如果命令行参数提供了，使用它来设置线尺寸属性，
  103.      以及一些其它属性，并设置 attrp 指向这个线程属性对象 */

  105.     printf("argc=%d\n",argc);
  106.     
  107.     if (argc > 1) {
  108.         int        stack_size;
  109.         void *sp;

  111.         attrp = &attr;

  113.         s = pthread_attr_init(&attr);
  114.         if (s != 0)
  115.             handle_error_en(s, "pthread_attr_init");

  117.         s = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  118.         if (s != 0)
  119.             handle_error_en(s, "pthread_attr_setdetachstate");

  121.         s = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
  122.         if (s != 0)
  123.             handle_error_en(s, "pthread_attr_setinheritsched");

  125.         stack_size = strtoul(argv[1], NULL, 0);//convert a string to an unsigned long integer

  127.         s = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stack_size);//对齐内存分配
  128.         if (s != 0)
  129.             handle_error_en(s, "posix_memalign");

  131.         printf("posix_memalign() allocated at %p\n", sp);

  133.         s = pthread_attr_setstack(&attr, sp, stack_size);//设置线程属性对象里的栈属性(地址/尺寸)
  134.         if (s != 0)
  135.             handle_error_en(s, "pthread_attr_setstack");
  136. }

  138.     s = pthread_create(&thr, attrp, &thread_start, NULL);
  139.     if (s != 0)
  140.         handle_error_en(s, "pthread_create");

  142.     if (attrp != NULL) {
  143.         s = pthread_attr_destroy(attrp);
  144.         if (s != 0)
  145.             handle_error_en(s, "pthread_attr_destroy");
  146.     }

  148.     pause();                    /* 当其它线程调用 exit() 时终止 */
  149.     return 0;
  150. }


//pthread_attr_init()的man手册实例
//$ ./a.out
或
//$ ./a.out 0x3000000


  1. /*********
  2. 线程互斥量
  3. **********/
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <pthread.h>

  9. int x;
  10. pthread_mutex_t mutex; // 声明一个互斥量
  11.    
  12. void thread1(void)
  13. {
  14.     while(x>0)
  15.     {
  16.         pthread_mutex_lock(&mutex); //上锁
  17.         printf("Thread 1 is running x=%d\n",x);
  18.         x--;
  19.         pthread_mutex_unlock(&mutex); //解锁
  20.         sleep(1);
  21.     }
  22.     pthread_exit(NULL);
  23. }
  24.    
  25. void thread2(void)
  26. {
  27.     while(x>0)
  28.     {
  29.         pthread_mutex_lock(&mutex);    //上锁 //注释本行看区别
  30.         sleep(3);
  31.         printf("Thread 2 is running x=%d\n",x);
  32.         x--;
  33.         pthread_mutex_unlock(&mutex); //解锁
  34.         sleep(1);
  35.     }
  36.     pthread_exit(NULL);
  37. }
  38.    
  39. int main()
  40. {
  41.     pthread_t id1,id2;
  42.     int ret;
  43.     ret = pthread_mutex_init(&mutex,NULL); //初始化互斥量
  44.     if(ret!=0)
  45.     {
  46.         printf("pthread_mutex_init error\n");
  47.         exit(0);
  48.     }
  49.     x=10; //初始值
  50.     ret = pthread_create(&id1,NULL,(void *)thread1,NULL); //创建线程1
  51.     if(ret!=0)
  52.     {
  53.         printf("Create pthread 1 error\n");
  54.         exit(0);
  55.     }
  56.     ret = pthread_create(&id2,NULL,(void *)thread2,NULL); //创建线程2
  57.     if(ret!=0)
  58.     {
  59.         printf("Create pthread 2 error\n");
  60.         exit(0);
  61.     }
  62.     pthread_join(id1,NULL); //线程结束聚合线程
  63.     pthread_join(id2,NULL);
  64.     printf("Done\n");
  65.     return 0;
  66. }

  1. /*********
  2. 线程条件
  3. **********/
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <pthread.h>
  7. #include <unistd.h>

  9. int x;
  10. pthread_mutex_t mutex;
  11. pthread_cond_t cond;
  12.    
  13. void producer(void)
  14. {
  15.     while(1)
  16.     {
  17.         pthread_mutex_lock(&mutex);
  18.         int i;
  19.         for(i=0;i<3-x;i++)
  20.         {
  21.             x++;
  22.             printf("Producing:i=%d x=%d \n",i,x);
  23.             sleep(1);
  24.         }
  25.         if(x>=3)
  26.         {
  27.             pthread_cond_signal(&cond);    /*条件改变，发送信号，通知consumer线程,激活等待该条件的线程*/
  28.             /*pthread_cond_broadcast()激活所有等待线程*/
  29.             printf("Producing complete %d\n",x);
  30.         }
  31.         pthread_mutex_unlock(&mutex);
  32.         printf("producer Unlock Mutex\n");
  33.         sleep(1);
  34.     }
  35.     pthread_exit(NULL);
  36. }
  37.    
  38. void consumer(void)
  39. {
  40.     while(1)
  41.     {
  42.         pthread_mutex_lock(&mutex);
  43.         while(x<3)
  44.         {
  45.             pthread_cond_wait(&cond,&mutex);//等待一个条件 //等待
  46.             printf("start consuming %d\n",x);
  47.         }
  48.         if(x>0)
  49.         {
  50.             x--;
  51.             printf(" consuming %d\n",x);
  52.             sleep(1);
  53.         }
  54.         pthread_mutex_unlock(&mutex);
  55.         printf("consumer Unlock Mutex\n");
  56.     }
  57.     pthread_exit(NULL);
  58. }
  59.    
  60. int main()
  61. {
  62.     pthread_t id1,id2;
  63.     int ret;
  64.     ret = pthread_mutex_init(&mutex,NULL); //初始化互斥量
  65.     if(ret!=0)
  66.     {
  67.         printf("pthread_mutex_init error\n");
  68.         exit(0);
  69.     }
  70.     ret=pthread_cond_init(&cond,NULL); //初始化条件变量
  71.     if(ret!=0)
  72.     {
  73.         printf("pthread_cond_init error\n");
  74.         exit(0);
  75.     }
  76.     printf("x=[%d]\n",x);
  77.     ret = pthread_create(&id1,NULL,(void *)producer,NULL); //创建线程1 发生器
  78.     if(ret!=0)
  79.     {
  80.         printf("Create pthread producer error\n");
  81.         exit(0);
  82.     }
  83.     ret = pthread_create(&id2,NULL,(void *)consumer,NULL); //创建线程2 消耗器
  84.     if(ret!=0)
  85.     {
  86.         printf("Create pthread consumer, error\n");
  87.         exit(0);
  88.     }
  89.     pthread_join(id1,NULL);
  90.     pthread_join(id2,NULL);
  91.     printf("Done\n");
  92.     return 0;
  93. }


  1. /*********
  2. 线程条件 信号量
  3. **********/

  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <pthread.h>
  9. #include <semaphore.h>

  11. sem_t sem;
  12. char buffer[256];
  13.    
  14. void mythread(void)
  15. {
  16.     sem_wait(&sem); //递减锁定一个信号量
  17.     while(strncmp("exit",buffer,4))
  18.     {
  19.         printf("You input %d characters\n",strlen(buffer)-1);
  20.         sem_wait(&sem);
  21.     }
  22.     pthread_exit(NULL);
  23. }
  24. int main()
  25. {
  26.     pthread_t id;
  27.     int ret;
  28.     ret=sem_init(&sem,0,0); //初始化一个匿名信号量,进程内线程共享，
  29.     if(ret!=0)
  30.     {
  31.         printf("Semaphare initialization failed\n");
  32.         exit(1);
  33.     }
  34.     ret=pthread_create(&id,NULL,(void *)&mythread,NULL); //创建线程
  35.         if(ret!=0)
  36.         {
  37.             printf("pthread_create failed\n");
  38.             exit(1);
  39.         }
  40.     printf("Input some text,Enter'.'to finish\n");
  41.     while(strncmp("exit",buffer,4)!=0)
  42.     {
  43.         fgets(buffer,256,stdin);        //FILE *stdin standard I/O streams
  44.         sem_post(&sem);            //增加解锁一个信号量
  45.     }
  46.     pthread_join(id,NULL);
  47.     printf("Thtead joined,\n");
  48.     sem_destroy(&sem);
  49.     return 0;
  50. }






















上一篇：man手册的manpath $MANPATH
下一篇：动态数组