读不懂，一段以多线程程序由于线程间冲突导致栈破坏的程序，求大神解答。。。。

dxxtl

1. #include <sys/types.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <pthread.h>
   
6. #include <errno.h>
   
7. 
   
8. #define LOGFILE                "error.log"
   
9. 
   
10. #define NR_DATA                64
    
11. #define NR_QUEUE        32
    
12. 
    
13. #define NR_REQ                64
    
14. #define NR_RES                16
    
15. 
    
16. #define SV_ST_REQ        1
    
17. #define SV_ST_RES_OK        2
    
18. #define SV_ST_RES_NG        3
    
19. 
    
20. struct service {
    
21.         int req[NR_DATA];
    
22.         int res[NR_DATA];
    
23.         int status;
    
24. };
    
25. 
    
26. struct service *queue[NR_QUEUE];
    
27. int rqueue, wqueue, nr_queue;
    
28. 
    
29. pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
    
30. pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
    
31. pthread_mutex_t mtx3 = PTHREAD_MUTEX_INITIALIZER;
    
32. pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
    
33. pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
    
34. 
    
35. FILE *logfile;
    
36. 
    
37. void log_setup_strings(char *buf, const char *func)
    
38. {
    
39.         struct timeval now;
    
40. 
    
41.         gettimeofday(&now, NULL);
    
42.         sprintf(buf, "[%d.%06d]:%s\n", now.tv_sec, now.tv_usec, func);
    
43. }
    
44. 
    
45. void log_error(const char *func)
    
46. {
    
47.         char *logbuf;
    
48. 
    
49.         logbuf = malloc(256);
    
50. 
    
51.         usleep(100000);
    
52.         log_setup_strings(logbuf, func);
    
53. 
    
54.         pthread_mutex_lock(&mtx3);
    
55.         fputs(logbuf, logfile);
    
56.         fflush(logfile);
    
57.         pthread_mutex_unlock(&mtx3);
    
58. 
    
59.         free(logbuf);
    
60. }
    
61. 
    
62. int queue_service_req(struct service *sv)
    
63. {
    
64.         int ret = -1;
    
65. 
    
66.         pthread_mutex_lock(&mtx1);
    
67. 
    
68.         if (nr_queue >= NR_QUEUE)
    
69.                 goto out;
    
70.        
    
71.         queue[wqueue] = sv;
    
72.         nr_queue++;
    
73.         wqueue++;
    
74.         if (wqueue >= NR_QUEUE)
    
75.                 wqueue = 0;
    
76. 
    
77.         pthread_cond_signal(&cond1);
    
78.         ret = 0;
    
79. 
    
80. out:
    
81.         pthread_mutex_unlock(&mtx1);
    
82.         return ret;
    
83. }
    
84. 
    
85. struct service *deq_service_req(void)
    
86. {
    
87.         struct service *sv;
    
88. 
    
89.         sv = NULL;
    
90.         pthread_mutex_lock(&mtx1);
    
91. 
    
92.         while (nr_queue <= 0)
    
93.                 pthread_cond_wait(&cond1, &mtx1);
    
94. 
    
95.         sv = queue[rqueue];
    
96.         nr_queue--;
    
97.         rqueue++;
    
98.         if (rqueue >= NR_QUEUE)
    
99.                 rqueue = 0;
    
100. 
     
101.         pthread_mutex_unlock(&mtx1);
     
102. 
     
103.         return sv;
     
104. }
     
105. 
     
106. int proc_req(void)
     
107. {
     
108.         struct service sv;
     
109.         struct timeval now;
     
110.         struct timespec timeout;
     
111.         int i, ret;
     
112. 
     
113.         sv.status = SV_ST_REQ;
     
114.         for (i = 0; i < NR_DATA; i++)
     
115.                 sv.req[i] = 0;
     
116. 
     
117.         ret = queue_service_req(&sv);
     
118.         if (ret == -1)
     
119.                 return -1;
     
120. 
     
121.         gettimeofday(&now, NULL);
     
122.         timeout.tv_sec = now.tv_sec + 1;
     
123.         timeout.tv_nsec = now.tv_usec * 1000;
     
124. 
     
125.         pthread_mutex_lock(&mtx2);
     
126.         ret = pthread_cond_timedwait(&cond2, &mtx2, &timeout);
     
127.         pthread_mutex_unlock(&mtx2);
     
128. 
     
129.         if (ret == ETIMEDOUT)
     
130.                 return -1;
     
131.        
     
132.         if (sv.status == SV_ST_RES_OK)
     
133.                 return 0;
     
134. 
     
135.         return -1;
     
136. }
     
137. 
     
138. int proc_res(void)
     
139. {
     
140.         struct timeval now;
     
141.         struct service *sv;
     
142.         int i;
     
143. 
     
144.         sv = deq_service_req();
     
145.         if (!sv)
     
146.                 return -1;
     
147. 
     
148.         pthread_mutex_lock(&mtx2);
     
149. 
     
150.         usleep(900000);
     
151. 
     
152.         for (i = 0; i < NR_DATA; i++) {
     
153.                 gettimeofday(&now, NULL);
     
154.                 sv->res[i] = now.tv_usec;
     
155.         }
     
156.         sv->status = SV_ST_RES_OK;
     
157. 
     
158.         pthread_mutex_unlock(&mtx2);
     
159. 
     
160.         return 0;
     
161. }
     
162. 
     
163. void *th_req(void *p)
     
164. {
     
165.         for (;;) {
     
166.                 if (proc_req() == -1)
     
167.                         log_error("Request");
     
168.                 usleep(100000);
     
169.         }
     
170. 
     
171.         return NULL;
     
172. }
     
173. 
     
174. void *th_res(void *p)
     
175. {
     
176.         for (;;) {
     
177.                 if (proc_res() == -1)
     
178.                         log_error("Response");
     
179.                 usleep(100000);
     
180.         }
     
181. 
     
182.         return NULL;
     
183. }
     
184. 
     
185. int main(int argc, char **argv)
     
186. {
     
187.         pthread_t reqs[NR_REQ], resp[NR_RES];
     
188.         int i;
     
189. 
     
190.         /* error log init */
     
191.         logfile = fopen(LOGFILE, "w");
     
192. 
     
193.         for (i = 0; i < NR_RES; i++)
     
194.                 pthread_create(&resp[i], NULL, th_res, NULL);
     
195. 
     
196.         for (i = 0; i < NR_REQ; i++)
     
197.                 pthread_create(&reqs[i], NULL, th_req, NULL);
     
198. 
     
199.         for (;;)
     
200.                 sleep(1);
     
201. 
     
202.         fclose(logfile);
     
203. 
     
204.         return 0;
     
205. }
     

复制代码

gdb 的backtrace无法正确显示。

linux_c_py_php

106 int proc_req(void)
107 {
108     struct service sv;
109     struct timeval now;
110     struct timespec timeout;
111     int i, ret;
112
113     sv.status = SV_ST_REQ;
114     for (i = 0; i < NR_DATA; i++)
115         sv.req[i] = 0;
116
117     ret = queue_service_req(&sv);

sv是栈上的, 函数退了就没了, 所以出错了, 其他没仔细看.

dxxtl

回复 2# linux_c_py_php


    求仔细看，这个程序把我绕晕了，看不太懂。。没有注释，最好能分析一下这个程序。

kdkgod

楼上大神说的对，truct service *queue[NR_QUEUE]，这个地方你存的是指针，可你赋值的时候是一个局部变量的地址，函数退出的时候局部变量就被回收了，别的线程访问这个地址肯定有问题。


一个优秀的程序员是能把复杂的问题简单化，而不是把简单的问题复杂化。还是变量名起名一定要见名知意，像mtx1,mtx2,mtx3，谁会一直想着mtx1锁的是哪个对象。回复 3# dxxtl


   

dxxtl

回复 4# kdkgod


    这个是debug hacks中的一段程序，没有注释，变量多又乱，所以我看晕了