udp并发服务器程序之客户端测试－－－－再次修改

1. #include <pthread.h>
2. #include <iostream>
3. #include <errno.h>
4. #include <sys/socket.h>
5. #include <sys/types.h>
6. #include <time.h>
7. #include <algorithm>
8. #include <iterator>
9. #include <netinet/in.h>
10. #include <arpa/inet.h>
11. #include <sstream>
12. #include <fcntl.h>
13. #include <unistd.h>
14. #include <sys/stat.h>
16. const int PROCESS_NUMBER=4;
17. const int THREAD_NUMBER=100;
18. pthread_mutex_t mutex;
20. int thread_index=THREAD_NUMBER;
22. void* thread_function(void* args)
23. {  
24.   std::stringstream buf;
25.   struct sockaddr_in* server_addr = (sockaddr_in*)args;
26.   int my_socket = socket(AF_INET, SOCK_DGRAM, 0);
27.   if (my_socket == -1)
28.     {
29.       perror("create socket failure");
30.       pthread_exit(NULL);
31.     }
32.   char data[512];
33.   bzero(data, sizeof(data));
34.   snprintf(data, 512, "%ld", random());
35.   buf<<"send data size is:"<<data<<std::endl;
36.   if (sendto(my_socket, (void*)&data, sizeof(data), 0,(sockaddr*)server_addr, sizeof(sockaddr_in)) == -1)
37.     {
38.       perror("sendto data failure");
39.       close(my_socket);
40.       pthread_exit(NULL);
41.     }
42.   char buffer[1024];
43.   struct sockaddr_in receive_addr;
44.   socklen_t len = sizeof(sockaddr_in);
45.   buf<<"recvice data:";
46.   std::size_t actual_len = recvfrom(my_socket, buffer, 1024, 0, (sockaddr*)&receive_addr, &len);
47.   if (actual_len == -1)
48.     {
49.       perror("revcfrom data failure");
50.     }
51.   else
52.     {
53.       //buf<<std::endl<<pthread_self()<<"receive data:";
54.       std::copy(buffer, buffer+actual_len, std::ostream_iterator<char>(buf));      
55.     }
56.   pthread_mutex_lock(&mutex);
57.   thread_index--;
58.   buf<<"/n"<<thread_index<<"thread exit/n/n";
59.   printf("%s", buf.str().c_str());
60.   pthread_mutex_unlock(&mutex);
61.   close(my_socket);
62. }
64. int main(int argc, char* argv[])
65. {
66.   pid_t pid;
67.   int current_index=0;
68.   while ((++current_index<PROCESS_NUMBER) && ((pid=fork())>0));
69.   /*
70.   //redirect stdout
71.   char file_name[50];
72.   bzero(file_name, sizeof(file_name));
73.   snprintf(file_name, sizeof(file_name), "%ld", getpid());
74.   int old_std_out = dup(STDOUT_FILENO);  
75.   if (dup2(open(file_name, O_APPEND|O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IXUSR), STDOUT_FILENO) == -1)
76.     {
77.       perror("dup2 failure");
78.       return -1;
79.     }
80.   */
82.   std::cout<<getpid()<<" process start"<<std::endl;
83.   struct sockaddr_in server_addr;
84.   bzero(&server_addr, sizeof(server_addr));
85.   server_addr.sin_family = AF_INET;
86.   server_addr.sin_port = htons(1120);
87.   server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
89.   srand((unsigned long)time(NULL));
90.   pthread_t pt[THREAD_NUMBER];
91.   pthread_attr_t attr;
92.   if (pthread_attr_init(&attr) != 0)
93.     {
94.       perror("pthread attr init failure");
95.       return -1;
96.     }
98.   if (pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN*2) != 0)
99.     {
100.       perror("pthread attr set stack failure");
101.       return -1;
102.     }
103.  
104.   if (pthread_mutex_init(&mutex, NULL) != 0)
105.     {
106.       perror("pthread mutex init failuer");
107.       return -1;
108.     }
109.   int i;
110.   for (i=0; i<THREAD_NUMBER; i++)
111.     {
112.       if (pthread_create(&pt[i], &attr, &thread_function, (void*)&server_addr) != 0)
113.     {
114.       perror("create thread fialure");      
115.       break;
116.     }     
117.     }
118.   pthread_mutex_lock(&mutex);
119.   std::cout<<"create thread number is:"<<i<<std::endl<<"rest thread number:"<<thread_index<<std::endl;
120.   pthread_mutex_unlock(&mutex);
121.   for (int j=0; j<THREAD_NUMBER; j++)
122.     {
123.       pthread_join(pt[j], NULL);      
124.     }
125.   //getchar();
126.   pthread_mutex_destroy(&mutex);
127.   //dup2(old_std_out, STDOUT_FILENO);
128.   std::cout<<getpid()<<"process exit"<<std::endl;
129.   return 0;
130. }