奇怪的问题，莫非这个就是Linux的信号灯惊群效应？

elssann

接受批评，把代码放上来：

1. 
   
2. #ifndef __QUEUE__H
   
3. #define        __QUEUE__H
   
4. 
   
5. 
   
6. u_long        queue_create(void);
   
7. 
   
8. void        queue_destroy(u_long q_id);
   
9. 
   
10. int                getqueue_status(u_long q_id, struct eph_context ** context);
    
11. 
    
12. int                putqueue_status(u_long q_id, struct eph_context * context);
    
13. 
    
14. 
    
15. 
    
16. #endif        /* __QUEUE__H */
    
17. 
    

复制代码

1. 
   
2. 
   
3. #include "precomp.h"
   
4. #include "mempool.h"
   
5. #include "queue.h"
   
6. 
   
7. 
   
8. 
   
9. 
   
10. u_long queue_create()
    
11. {
    
12.         struct queue_handle * q_handle = NULL;
    
13. 
    
14. 
    
15.         q_handle = (struct  queue_handle *)malloc(sizeof(struct queue_handle));
    
16.         if (!q_handle)
    
17.         {
    
18.                 return -1;
    
19.         }
    
20. 
    
21.         if (sem_init(&q_handle->;queue_sem, 0, 0) == -1)
    
22.         {
    
23.                 free(q_handle);
    
24.                 return -1;
    
25.         }
    
26. 
    
27.         if (pthread_mutex_init(&q_handle->;queue_lock, NULL) != 0)
    
28.         {
    
29.                 sem_destroy(&q_handle->;queue_sem);
    
30.                 free(q_handle);
    
31.                 return -1;
    
32.         }
    
33.        
    
34.         q_handle->;context_front = NULL;
    
35.         q_handle->;context_rear  = NULL;
    
36.        
    
37.         return (u_long)q_handle;       
    
38. }/* end of queue_create        */
    
39. 
    
40. 
    
41. 
    
42. void queue_destroy(u_long q_id)
    
43. {
    
44.         struct eph_context        * context = NULL;
    
45.         struct queue_handle        * q_handle = NULL;
    
46. 
    
47. 
    
48.         if (q_id <= 0)
    
49.         {
    
50.                 return;
    
51.         }
    
52. 
    
53.         q_handle = (struct queue_handle *)q_id;
    
54.        
    
55.         sem_destroy(&q_handle->;queue_sem);
    
56. 
    
57.         pthread_mutex_lock(&q_handle->;queue_lock);
    
58.         while (q_handle->;context_front)
    
59.         {
    
60.                 context = q_handle->;context_front;
    
61.                 q_handle->;context_front = q_handle->;context_front->;next;
    
62.                 context_pool_put(g_context_pool, context);
    
63.         }
    
64.         pthread_mutex_unlock(&q_handle->;queue_lock);
    
65.        
    
66.         pthread_mutex_destroy(&q_handle->;queue_lock);
    
67. 
    
68.         free(q_handle);
    
69. 
    
70.         return;
    
71. }/* end of queue_destroy */
    
72. 
    
73. 
    
74. 
    
75. int getqueue_status(u_long q_id, struct eph_context ** context)
    
76. {
    
77.         struct queue_handle * q_handle = NULL;
    
78. 
    
79. 
    
80.         if (q_id <= 0)
    
81.         {
    
82.                 return -1;
    
83.         }
    
84. 
    
85.         q_handle = (struct queue_handle *)q_id;
    
86. 
    
87. 
    
88.     while (1)
    
89.     {
    
90.             if (sem_wait(&q_handle->;queue_sem) == 0)
    
91.             {
    
92.                     break;
    
93.             }
    
94.     }
    
95. 
    
96.        
    
97.         pthread_mutex_lock(&q_handle->;queue_lock);
    
98.         if (q_handle->;context_front != NULL)
    
99.         {
    
100.                 *context = q_handle->;context_front;
     
101.                 if (q_handle->;context_front == q_handle->;context_rear)
     
102.                 {
     
103.                         q_handle->;context_front        = NULL;
     
104.                         q_handle->;context_rear        = NULL;
     
105.                 }
     
106.                 else
     
107.                 {
     
108.                         q_handle->;context_front        = q_handle->;context_front->;next;
     
109.                 }
     
110.                 *context->;next = NULL;
     
111.         }
     
112.         else
     
113.         {
     
114.      /* 就是想不通为什么会执行到这里来 */
     
115.         *context = NULL;
     
116.         }
     
117.         pthread_mutex_unlock(&q_handle->;queue_lock);
     
118.        
     
119.        
     
120.         return 0;       
     
121. }/* end of getqueue_status */
     
122. 
     
123. 
     
124. 
     
125. 
     
126. int putqueue_status(u_long q_id, struct eph_context * context)
     
127. {
     
128.         struct queue_handle *q_handle = NULL;
     
129.        
     
130.        
     
131.         if (q_id <= 0)
     
132.         {
     
133.                 return -1;
     
134.         }
     
135.                
     
136.        
     
137.         context->;next = NULL;
     
138.         q_handle = (struct queue_handle *)q_id;
     
139.        
     
140.         pthread_mutex_lock(&q_handle->;queue_lock);
     
141.         if (q_handle->;context_front == NULL)
     
142.         {
     
143.                 q_handle->;context_front = context;
     
144.                 q_handle->;context_rear  = context;
     
145.         }
     
146.         else
     
147.         {
     
148.                 q_handle->;context_rear->;next = context;
     
149.                 q_handle->;context_rear       = context;
     
150.                
     
151.         }
     
152.         pthread_mutex_unlock(&q_handle->;queue_lock);
     
153.        
     
154.         sem_post(&q_handle->;queue_sem);
     
155. 
     
156.         return 0;
     
157. }/* end of putqueue_status */
     
158. 
     
159. 
     

复制代码

简单的说，就是我做了一个队列，ABCD线程调用getqueue_status函数阻塞住。E线程调用putqueue_status给队列里放一个东西，然后发出信号灯让ABCD中的一个线程返回，但是奇怪的是，在我的程序中，我竟然发现，有时候线程进去队列里取数据的时候，竟然执行到了 getqueue_status函数的这一段，else
{
*context = NULL;
}

奇怪啊，莫非这就是所谓的信号灯惊群效应？

补充一个结构
struct queue_handle
{
int queue_len;
sem_t queue_sem;
pthread_mutex_t queue_lock;
struct eph_context *context_front;
struct eph_context *context_rear;
};


开始以为是信号灯惊群效应，后来我就A线程getqueue_status,B线程putqueue_status，还是一样出现那个问题

elssann

如果说是惊群效应也不对啊。，
我就用A线程getqueue_status
用B线程putqueue_status

结果有时候还是会执行到
else
{
*context = NULL;
}

yuxh

1.         pthread_mutex_lock(&q_handle->;queue_lock);
   
2.         if (q_handle->;context_front != NULL)
   
3.         {
   
4.                 *context = q_handle->;context_front;
   
5.                 if (q_handle->;context_front == q_handle->;context_rear)
   
6.                 {
   
7.                         q_handle->;context_front        = NULL;
   
8.                         q_handle->;context_rear        = NULL;
   
9.                 }
   
10.                 else
    
11.                 {
    
12.                         q_handle->;context_front        = q_handle->;context_front->;next;
    
13.                 }
    
14.                 *context->;next = NULL;
    
15.         }
    
16.         else
    
17.         {
    
18.                 *context = NULL;
    
19.         }
    
20.         pthread_mutex_unlock(&q_handle->;queue_lock);
    

复制代码

*context->;next=NULL;
不管队列后面有没有东西全置NULL，别的线程还能取到队列里的东西吗？
还有你从队列里取走后也没有释放资源的过程，时间长了，资源不耗光？

你可以用code把代码贴上来，不然别人懒得看!

elssann

原帖由 "yuxh" 发表：

不管队列后面有没有东西全置NULL，别的线程还能取到队列里的东西吗？
还有你从队列里取走后也没有释放资源的过程，时间长了，资源不耗光？

你可以用code把代码贴上来，不然别人懒得看!

啊，老大，我觉得这一段没错啊。。

1. 
   
2.         pthread_mutex_lock(&q_handle->;queue_lock);
   
3.         if (q_handle->;context_front != NULL)
   
4.         {
   
5. /* 队列不为空，将*context指向队列头 */
   
6.                 *context = q_handle->;context_front;
   
7.                 if (q_handle->;context_front == q_handle->;context_rear)
   
8.                 {
   
9. /* 如果队列里只有一个结点，将队列置空 */
   
10.                         q_handle->;context_front        = NULL;
    
11.                         q_handle->;context_rear        = NULL;
    
12.                 }
    
13.                 else
    
14.                 {
    
15. /* 队列里有多个结点， 将队列头结点指向队列头结点的下一个结点 */
    
16.                         q_handle->;context_front        = q_handle->;context_front->;next;
    
17.                 }
    
18. /* 将原来的队列头结点（现在已经不在队列里了）的next指针置空 */
    
19.                 *context->;next = NULL;
    
20.         }
    
21.         else
    
22.         {
    
23.                 *context = NULL;
    
24.         }
    
25.         pthread_mutex_unlock(&q_handle->;queue_lock);

复制代码

另外资源的问题，因为我是用的内存池方式管理，在程序开始的时候分配，程序退出的时候释放。

yuxh

我指的是if语句里*context->;next不能置为NULL，应该是下一个节点
不然把前面q_handle->;context_front   = q_handle->;context_front->;next；又改回去了

twen345

*context->;next=NULL;  //编译能通过？

(*context) ->; next = NULL;

〉〉还有你从队列里取走后也没有释放资源的过程，时间长了，资源不耗光？
它取走了应该会在其他地方用到吧

yuxh

我看错了
那也应该是(*context)->;next，你编译时没警告吗？

elssann

没有警告啊，，， 我用GCC编译的
我觉得*好优先级是要高一些吧？我把GCC加上 -wall参数看看

elssann

我把 *context->;next=NULL;
改为
(*context) ->; next = NULL;

问题依旧

twen345