Linux多线程5-1_一次性初始化

一、为什么要使用一次性初始化
    有些事需要且只能执行一次（比如互斥量初始化）。通常当初始化应用程序时，可以比较容易地将其放在main函数中。但当你写一个库函数时，
    就不能在main里面初始化了，你可以用静态初始化，但使用一次初始（pthread_once_t）会比较容易些。

二、如何进行一次性初始化
    1、首先要定义一个pthread_once_t变量，这个变量要用宏PTHREAD_ONCE_INIT初始化。然后创建一个与控制变量相关的初始化函数
    pthread_once_t once_control = PTHREAD_ONCE_INIT;
    void init_routine（）
    {
         //初始化互斥量
         //初始化读写锁
         ......
    }


    2、接下来就可以在任何时刻调用pthread_once函数
    int pthread_once(pthread_once_t* once_control, void (*init_routine)(void));
    功能：本函数使用初值为PTHREAD_ONCE_INIT的once_control变量保证init_routine()函数在本进程执行序列中仅执行一次。在多线程编程
    环境下，尽管pthread_once()调用会出现在多个线程中，init_routine()函数仅执行一次，究竟在哪个线程中执行是不定的，是由内核调度来决定。


    3、Linux Threads使用互斥锁和条件变量保证由pthread_once()指定的函数执行且仅执行一次。实际"一次性函数"的执行状态有三种：
        NEVER（0）、IN_PROGRESS（1）、DONE （2），用once_control来表示pthread_once()的执行状态：
    1）、如果once_control初值为0，那么 pthread_once从未执行过，init_routine()函数会执行。
    2）、如果once_control初值设为1，则由于所有pthread_once()都必须等待其中一个激发"已执行一次"信号， 因此所有pthread_once ()都会陷入永久
        的等待中，init_routine()就无法执行
    3）、如果once_control设为2，则表示pthread_once()函数已执行过一次，从而所有pthread_once()都会立即   返回，init_routine()就没有机会执行
        当pthread_once函数成功返回，once_control就会被设置为2

三、手册
PTHREAD_ONCE(3P)           POSIX Programmer’s Manual          PTHREAD_ONCE(3P)

PROLOG
       This  manual page is part of the POSIX Programmer’s Manual.  The Linux implementation of this interface may differ (con-
       sult the corresponding Linux manual page for details of Linux behavior), or the interface  may  not  be  implemented  on
       Linux.
         //这只是POSIX的手册，Linux对这个接口的实现可能不一样，或者有的根本没有实现这个接口

NAME
       pthread_once - dynamic package initialization
        //动态初始化

SYNOPSIS
       #include
        //头文件

       int pthread_once(pthread_once_t *once_control,
              void (*init_routine)(void));
       pthread_once_t once_control = PTHREAD_ONCE_INIT;


DESCRIPTION
       The first call to pthread_once() by any thread in a process, with a given once_control, shall call the init_routine with
       no arguments. Subsequent calls of pthread_once() with the same once_control shall not call the init_routine.  On  return
       from  pthread_once(),  init_routine shall have completed. The once_control parameter shall determine whether the associ-
       ated initialization routine has been called.
        //第一次调用 pthread_once()的线程会调用初始化例程，这个初始化函数没有参数，当再次调用 pthread_once()的时候，初始化
        //例程将不被调用。当 pthread_once()返回的时候，初始化例程就会完成，once_control变量将会决定初始化例程是否已经被调用

       The pthread_once() function is not a cancellation point. However, if init_routine is a cancellation point  and  is  can-
       celed, the effect on once_control shall be as if pthread_once() was never called.
        // pthread_once()不是一个取消点。但是初始化例程是一个取消点，如果它被取消，那么 pthread_once()就好像从未调用过

       The constant PTHREAD_ONCE_INIT is defined in the header.
        //PTHREAD_ONCE_INIT定义在头文件pthread.h中

       The  behavior  of  pthread_once()  is  undefined if once_control has automatic storage duration or is not initialized by
       PTHREAD_ONCE_INIT.
        // pthread_once()的行为是未知的，如果once_control没有被初始化

RETURN VALUE
       Upon successful completion, pthread_once() shall return zero; otherwise, an error number shall be returned  to  indicate
       the error.
        //成功返回0 ，失败返回错误码

ERRORS
       The pthread_once() function may fail if:
        // pthread_once()在以下情况会失败

       EINVAL If either once_control or init_routine is invalid.
                    //once_control变量或者初始化例程是无效的

       The pthread_once() function shall not return an error code of [EINTR].
        //不会返回EINTR

四、实例
1、一次性初始化的验证

点击(此处)折叠或打开

1. /*DATE:            2015-4-15
   
2.  *AUTHOR:        DDDDD
   
3.  *DESCRIPTION:    一次性初始化
   
4.     int pthread_once(pthread_once_t* once_control, void (*init_routine)(void));
   
5.     如果once_control为0，init_routine()就会执行
   
6.     pthread_once()成功返回之后，once_control会变为2
   
7.  */
   
8. 
   
9. #include "apue.h"
   
10. 
    
11. pthread_once_t once = 2;
    
12. pthread_t tid;
    
13. 
    
14. void thread_init()
    
15. {
    
16.     printf("I'm in thread 0x%x\n", tid);
    
17. 
    
18. }
    
19. 
    
20. 
    
21. void *thread_fun1(void *arg)
    
22. {
    
23.     tid = pthread_self();
    
24.     printf("I'm thread 0x%x\n", tid);
    
25.     printf("once is %d\n", once);
    
26.     pthread_once(&once, thread_init);
    
27.     printf("once is %d\n", once);
    
28. 
    
29.     return NULL;
    
30. }
    
31. 
    
32. void *thread_fun2(void *arg)
    
33. {
    
34.     sleep(2);
    
35.     tid = pthread_self();
    
36.     printf("I'm thread 0x%x\n", tid);
    
37.     pthread_once(&once, thread_init);
    
38. 
    
39.     return NULL;
    
40. }
    
41. 
    
42. int main()
    
43. {
    
44.     pthread_t tid1, tid2;
    
45.     int err;
    
46. 
    
47.     err = pthread_create(&tid1, NULL, thread_fun1, NULL);
    
48.     if(err != 0)
    
49.     {
    
50.         printf("create new thread 1 failed\n");
    
51.         return ;
    
52.     }
    
53.     err = pthread_create(&tid2, NULL, thread_fun2, NULL);
    
54.     if(err != 0)
    
55.     {
    
56.         printf("create new thread 1 failed\n");
    
57.         return ;
    
58.     }
    
59. 
    
60. 
    
61.     pthread_join(tid1, NULL);
    
62.     pthread_join(tid2, NULL);
    
63. 
    
64.     return 0;
    
65. }

2、将互斥量的初始化，使用pthread_once来实现

点击(此处)折叠或打开

1. /*DATA:            2015-4-20
   
2.  *AUTHOR;        WJ
   
3.  *DESCRIPTION:    使用多线程对一个队列进行增加和减少，增加操作是一个线程，删除操作是一个线程
   
4.  *    
   
5.  */
   
6. #include "apue.h"
   
7. 
   
8. pthread_mutex_t mutex;
   
9. pthread_once_t once = PTHREAD_ONCE_INIT;
   
10. 
    
11. struct queue{
    
12.     int len;
    
13.     int write_pos;
    
14.     int read_pos;
    
15.     int data[50];
    
16. };
    
17. 
    
18. //互斥量初始化函数
    
19. void mutex_init()
    
20. {
    
21.     int err;
    
22.     err = pthread_mutex_init(&mutex, NULL);
    
23.     if(err)
    
24.     {
    
25.         printf("mutex init failed\n");
    
26.         return;
    
27.     }
    
28. }
    
29. 
    
30. //队列初始化
    
31. struct queue *queue_init()
    
32. {
    
33.     struct queue *que;
    
34.     //申请内存
    
35.     que = (struct queue *)malloc(sizeof(struct queue));
    
36.     if(que ==NULL)
    
37.     {
    
38.         printf("malloc failed\n");
    
39.         return;
    
40.     }
    
41. 
    
42.     //初始化
    
43.     que->len = 0;
    
44.     que->write_pos = 0;
    
45.     que->read_pos = 0;
    
46. 
    
47.     return que;
    
48. }
    
49. 
    
50. void queue_destroy(struct queue *que)
    
51. {
    
52.     //销毁互斥量和que
    
53.     pthread_mutex_destroy(&mutex);
    
54.     free(que);
    
55. }
    
56. 
    
57. void *queue_add(void *arg)
    
58. {
    
59.     //对互斥量进行一次性初始化
    
60.     pthread_once(&once, mutex_init);
    
61.     struct queue *que = (struct queue *)arg;
    
62.     int buf=0;
    
63.     while(buf<50)
    
64.     {
    
65.         pthread_mutex_lock(&mutex);
    
66.         que->data[que->write_pos] = buf;
    
67.         que->write_pos ++;
    
68.         que->len ++;
    
69.         buf++;
    
70.         printf("write data %d to queue\n", que->data[que->write_pos -1]);
    
71. 
    
72.         pthread_mutex_unlock(&mutex);
    
73.         sleep(1);
    
74.     }
    
75. }
    
76. 
    
77. void *queue_del(void *arg)
    
78. {
    
79.     //    对互斥量进行一次性初始化
    
80.     pthread_once(&once, mutex_init);
    
81.     struct queue *que = (struct queue *)arg;
    
82.     int buf=0;
    
83.     while(1)
    
84.     {
    
85.         sleep(2);
    
86.         pthread_mutex_lock(&mutex);
    
87.         buf = que->data[que->read_pos];
    
88.         que->read_pos ++;
    
89.         if(que->len -- == 0)
    
90.         {
    
91.             printf("queue is empty\n");
    
92.             return;
    
93.         }
    
94.         buf++;
    
95.         printf("read data %d from queue\n", que->data[que->read_pos -1]);
    
96.         pthread_mutex_unlock(&mutex);
    
97.     }
    
98. }
    
99. 
    
100. int main()
     
101. {
     
102.     pthread_t tid1, tid2;
     
103.     int err;
     
104.     struct queue *que;
     
105. 
     
106.     //队列初始化
     
107.     que = queue_init();
     
108. 
     
109.     err = pthread_create(&tid1, NULL, queue_add, (void *)que);
     
110.     if(err)
     
111.     {
     
112.         printf("create add thread failed\n");
     
113.         queue_destroy(que);
     
114.         return;
     
115.     }
     
116. 
     
117.     err = pthread_create(&tid2, NULL, queue_del, (void *)que);
     
118.     if(err)
     
119.     {
     
120.         printf("create del thread failed\n");
     
121.         queue_destroy(que);
     
122.         return;
     
123.     }
     
124. 
     
125.     //等待增加和删除操作完成
     
126.     pthread_join(tid1, NULL);
     
127.     pthread_join(tid2, NULL);
     
128. 
     
129.     //销毁
     
130.     queue_destroy(que);
     
131. }