udp并发服务器程序－－－－再次修改

1. #include <pthread.h>
2. #include <iostream>
3. #include <errno.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <semaphore.h>
7. #include <netinet/in.h>
8. #include <arpa/inet.h>
9. #include <iterator>
10. #include "connection.hpp"
11. #include "table.hpp"
13. const int NET_BUFFER_NUMBER=1024;
14. const int THREAD_BUFFER_NUMBER=10;
15. const int WORK_THREAD_NUMBER=100;
16. const int THREAD_STACK_SIZE=PTHREAD_STACK_MIN*3;
17. const int WAIT_TIME=3;
19. //this struct for thread deal socket need data
20. struct data_buffer
21. {
22.   char data_array[NET_BUFFER_NUMBER];
23.   int data_len;//data_array actual length
24.   struct sockaddr_in src_socket;
25.     
26.  
27.   const data_buffer& operator=(const data_buffer& rhs)
28.   {
29.     data_len = rhs.data_len;
31.     for (int i=0; i<data_len; i++)
32.       {
33.     data_array[i] = rhs.data_array[i];
34.       }
35.     src_socket = rhs.src_socket;
36.     return rhs;
37.   }
38. };
40. //main thread and dispatch thread
41. struct data_buffer globe_buffer[THREAD_BUFFER_NUMBER];
42. int globe_actual_len;//globe_buffer actual len
43. pthread_mutex_t main_mutex;
44. pthread_cond_t main_cond;
45. bool can_read;
47. //use threads pool manage
48. //pthread_mutex_t mutex[WORK_THREAD_NUMBER];
49. pthread_mutex_t mutex;
50. pthread_cond_t cond;
51. bool is_start[WORK_THREAD_NUMBER];
52. struct thread_arg
53. {
54.   const struct data_buffer* ptr_data;
55.   const int* ptr_work_len;
56.   int self_index;//is_start array index,also mutex array
57. };
59. void* thread_function(void* args)
60. {
61.   //because of after args will changes value
62.   struct thread_arg* ptr_arg = (struct thread_arg*)args;
63.   int index = ptr_arg->self_index;
64.   const struct data_buffer* ptr_src_data = ptr_arg->ptr_data;
65.   const int* ptr_src_work_len = ptr_arg->ptr_work_len;
67.   sqlpp::Connection conn("mysql", "127.0.0.1", "root", "yi_jun_jun");
68.   if (!conn.is_open())
69.     {
70.       perror("database connection failure");
71.       pthread_exit(NULL);
72.     }
74.   sqlpp::Table table("select * from user", conn);
75.   int my_socket = socket(AF_INET, SOCK_DGRAM, 0);
76.   if (my_socket == -1)
77.     {
78.       perror("create my socket failure in thread function");
79.       pthread_exit(NULL);
80.     }
81.   struct data_buffer deal_data[THREAD_BUFFER_NUMBER];
82.   int work_count=0;
83.   while (true)
84.     {      
85.       pthread_mutex_lock(&mutex);
86.       while (!is_start[index])
87.     {
88.       pthread_cond_wait(&cond, &mutex);
89.     }
90.       work_count = *ptr_src_work_len;
91.       for (int j=0; j<work_count; j++)
92.     {
93.       deal_data[j] = ptr_src_data[j];//copy self will deal data
94.     }
95.       pthread_mutex_unlock(&mutex);
96.       
97.       //copy the same data to client
98.       for (int i=0; i<work_count; i++)
99.     {
100.       table.download();
101.       sqlpp::Table::rows rows = table.get_rows<sqlpp::Table::row>();
102.       int k = random()%rows.size();
103.       std::copy(rows[k]["User"].begin(),rows[k]["User"].end(), deal_data[i].data_array);
104.       deal_data[i].data_len = rows[k]["User"].size();    
105.       sendto(my_socket, deal_data[i].data_array, deal_data[i].data_len, 0, (sockaddr*)&(deal_data[i].src_socket), sizeof(deal_data[i].src_socket));      
106.     }      
107.       work_count = 0;
108.       is_start[index] = false;//notice self is idle
109.     }//end of while
110.   close(my_socket);
111.   return NULL;
112. }
114. bool create_threads(int create_count, struct data_buffer data_args[], int* ptr_len)
115. {  
116.   pthread_attr_t attr;
117.   std::size_t stack_size;
118.   struct thread_arg args;
119.   args.ptr_data = data_args;
120.   args.ptr_work_len = ptr_len;
121.   pthread_attr_init(&attr);
122.   pthread_attr_setstacksize(&attr, THREAD_STACK_SIZE);
123.   for (int i=0; i<WORK_THREAD_NUMBER; i++)
124.     {
125.       pthread_t ptd;
126.       args.self_index = i;
127.       if (pthread_create(&ptd, &attr, &thread_function, (void*)&args) != 0)
128.     {
129.       perror("create failure");
130.       return false;
131.     }
132.     }
133.   return true;
134. }
136. void* dispatch(void* args)
137. {
138.   struct data_buffer temp[THREAD_BUFFER_NUMBER];
139.   int work_len = 0;
140.   if (pthread_mutex_init(&mutex, NULL) != 0)
141.     {
142.       perror("init lock failure in dispatch function");
143.       pthread_exit(NULL);
144.     }
146.   if (pthread_cond_init(&cond, NULL) != 0)
147.     {
148.       perror("inin cond failure");
149.       pthread_exit(NULL);
150.     }
152.   for (int i=0; i<WORK_THREAD_NUMBER; i++)
153.     {      
154.       is_start[i] = false;//block all work thread
155.     }
157.   if (!create_threads(WORK_THREAD_NUMBER, temp, &work_len))
158.     {
159.       perror("create threads failure");
160.       pthread_exit(NULL);
161.     }
163.   while (true)
164.     {
165.       pthread_mutex_lock(&main_mutex);
166.       while (!can_read)
167.     {
168.       pthread_cond_wait(&main_cond, &main_mutex);
169.     }
170.       for (int i=0; i<globe_actual_len; i++)
171.     {
172.       temp[i] = globe_buffer[i];
173.     }
174.       work_len = globe_actual_len;
175.       //dispatch work start, if not idle thread, it will be block.
176.       while (true)
177.           {
178.       int j;
179.       for (j=0; j<WORK_THREAD_NUMBER; j++)
180.         {
181.           //find one idle thread, no need lock
182.           if (!is_start[j])
183.         {
184.           //signal this thread start work
185.           pthread_mutex_lock(&mutex);
186.           is_start[j] = true;
187.           pthread_cond_broadcast(&cond);
188.           pthread_mutex_unlock(&mutex);
189.           //std::cout<<"find an idle thread:"<<j<<std::endl;
190.           break;//only break for
191.         }
192.         }
193.       if (j<WORK_THREAD_NUMBER)//find one idle thread and start it
194.         {
195.           //std::cout<<"find an idle thread:"<<j<<std::endl;
196.           break;//break dispatch while
197.         }
198.     }//end of find idle      
199.      can_read = false;
200.      pthread_mutex_unlock(&main_mutex);     
201.     }//end of dispatch
202.   pthread_mutex_destroy(&mutex);
203.   pthread_cond_destroy(&cond);
204. }
206. int main(int argc, char* argv[])
207. {
208.   srand((unsigned long)time(NULL));
209.   int listen_socket = socket(PF_INET, SOCK_DGRAM, 0);
210.   if (listen_socket == -1)
211.     {
212.       perror("create listen socket failure");
213.       return -1;
214.     }
216.   //sizeof(sockaddr_in) = sizeof(sockaddr)
217.   //sockaddr purose = sockaddr_in purose
218.   struct sockaddr_in addr;
219.   bzero(&addr, sizeof(sockaddr_in));
220.   addr.sin_family = PF_INET;
221.   addr.sin_port = htons(1120);
222.   addr.sin_addr.s_addr = inet_addr("127.0.0.1");
224.   if (bind(listen_socket, (sockaddr*)&addr, sizeof(sockaddr_in)) == -1)
225.     {
226.       perror("bind listen_socket failure");
227.       close(listen_socket);
228.       return -1;
229.     }
230.   timeval timeout = {WAIT_TIME,0};
231.   if (setsockopt(listen_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval)) == -1)
232.     {
233.       perror("set time out failure");
234.       close(listen_socket);
235.       return -1;
236.     }
237.  
238.   if (pthread_mutex_init(&main_mutex, NULL) != 0)
239.     {
240.       perror("main_mutex init failure");
241.       close(listen_socket);
242.       return -1;
243.     }
245.   if (pthread_cond_init(&main_cond, NULL) != 0)
246.     {
247.       perror("main_cond init failure");
248.       close(listen_socket);
249.       return -1;
250.     }
252.   //create distpach thread
253.   can_read = false;
254.   globe_actual_len = 0;
255.   pthread_t pt;
256.   if (pthread_create(&pt, NULL, &dispatch, NULL) != 0)
257.     {
258.       perror("create dispatch thread failure");
259.       close(listen_socket);
260.       return -1;
261.     }
263.   //main receive loop
264.   char buffer[NET_BUFFER_NUMBER];
265.   bzero(buffer, sizeof(buffer));
266.   struct sockaddr_in client;
267.   int actual_len=0;
268.   socklen_t sock_len = sizeof(sockaddr_in);
269.   struct data_buffer temp[THREAD_BUFFER_NUMBER];
270.   int index=0;  
271.   while (true)
272.     {
273.       if ((actual_len=recvfrom(listen_socket, buffer, NET_BUFFER_NUMBER, 0, (sockaddr*)&client, &sock_len)) <= 0)
274.     {      
275.       //maybe it is timeout,check exists old socket not dispatch
276.       if ((index>0) && (index<=THREAD_BUFFER_NUMBER))
277.         {          
278.           pthread_mutex_lock(&main_mutex);
279.           globe_actual_len = index;          
280.           for (int i=0; i<globe_actual_len; i++)
281.         {
282.           globe_buffer[i] = temp[i];
283.         }          
284.           index = 0;
285.           can_read = true;          
286.           pthread_cond_broadcast(&main_cond);          
287.           pthread_mutex_unlock(&main_mutex);
288.         }
289.       continue;
290.     }
291.       else
292.     {      
293.       if ( index >= THREAD_BUFFER_NUMBER)
294.         {          
295.           pthread_mutex_lock(&main_mutex);
296.           globe_actual_len = THREAD_BUFFER_NUMBER;          
297.           for (int i=0; i<globe_actual_len; i++)
298.         {
299.           globe_buffer[i] = temp[i];
300.         }          
301.           index = 0;
302.           can_read = true;          
303.           pthread_cond_broadcast(&main_cond);          
304.           pthread_mutex_unlock(&main_mutex);
305.         }
306.       temp[index].data_len = actual_len;
307.       for (int k=0; k<actual_len; k++)
308.         {
309.           temp[index].data_array[k] = buffer[k];
310.         }
311.       temp[index++].src_socket = client;
312.     }
313.     }
314.   pthread_mutex_destroy(&main_mutex);
315.   pthread_cond_destroy(&main_cond);
316.   return 0;
317. }