linux网络编程之—多线程模型 .

1.网络编程是一个程序员必须掌握的一项技能，尤其c/c++程序员必须掌握，而实际应用中，绝大部分网络程序都不可能是单连接，那么就意味着需要处理并发问题，目前来说主流的linux下的网络模型基本都基于epoll，select，在大规模并发情况下性能较高，而多进程，多线程模型相对较少，多进程模型实际使用确实较少，进程间通讯和数据共享都不太方便，而多线程模型在小连接数，尤其在内部通讯还是有可取之处，可以利用多核优势，开发也简单，易于维护。

 

多线程模型分为几类，一个是来一个连接开一个线程，二是先开N个线程，每个同时监听要连接的客户端程序，也就是通常说的线程池，线程池可以减少创建和销毁线程的代价。

下面就是我自己写的一个多线程echo服务端程序，没有数据处理部分，仅仅是将收到的客户端数据返回给相应的客户端。

[cpp] view plain copy print ?

1. #include<iostream>   
2. #include<stdio.h>   
3. #include<stdlib.h>   
4. #include<unistd.h>   
5. #include<errno.h>   
6. #include<netdb.h>   
7. #include<sys/types.h>   
8. #include<sys/socket.h>   
9. #include<netinet/in.h>   
10. #include<arpa/inet.h>   
11. #include<netdb.h>   
12. #include<sys/time.h>   
13. #include<string.h>   
14. #include<pthread.h>   
15. using namespace std;  
16.   
17. int thread_count = 0;  
18. void *word_thread(void *p);  
19. int main(int argc, char*argv[])  
20. {     
21.     int port = 0;  
22.     if (argc != 3)  
23.     {  
24.         cout<<"command error"<<endl;  
25.         exit(-1);  
26.     }  
27.   
28.     port = atoi(argv[1]);  
29.     thread_count = atoi(argv[2]);  
30.     int server_sock = 0;  
31.     struct sockaddr_in server_addr;  
32.     memset(&server_addr, 0, sizeof(server_addr));  
33.   
34.     if((server_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
35.     {  
36.         cout<<"create socket error"<<endl;  
37.         exit(-1);  
38.     }  
39.   
40.     server_addr.sin_family = AF_INET;  
41.     server_addr.sin_addr.s_addr =htonl(INADDR_ANY);  
42.     server_addr.sin_port = htons(port);  
43.       
44.     if(bind(server_sock, (struct sockaddr*)&server_addr,sizeof(sockaddr))  
45.        == -1)  
46.     {  
47.         cout<<"bind error"<<endl;  
48.         exit(-1);  
49.     }     
50.       
51.     if(listen(server_sock, 5) == -1)  
52.     {     
53.         cout<<"listent error"<<endl;  
54.         exit(-1);  
55.     }  
56.       
57.     pthread_t *thread_id = new pthread_t[thread_count];  
58.     for(int i = 0; i < thread_count; i++)  
59.     {  
60.         pthread_create(&thread_id[i], NULL, word_thread, &server_sock);  
61.     }  
62.   
63.   
64.     for(int j = 0; j < thread_count; j++)  
65.     {  
66.         pthread_join(thread_id[j], NULL);  
67.     }     
68.       
69.     return 0;  
70.   
71. }  
72.   
73. void *word_thread(void *p)  
74. {     
75.     int *s = (int*)p;  
76.     int listen_fd = *s;  
77.     while(1)  
78.     {  
79.         struct sockaddr_in client_addr;  
80.         memset(&client_addr, 0, sizeof(client_addr));  
81.         unsigned int len = sizeof(client_addr);   
82.         int new_sock= accept(listen_fd, (struct sockaddr*) &client_addr, &len);  
83.         if(new_sock == -1)  
84.         {  
85.                 cout<<"accept error"<<endl;  
86.         }  
87.       
88.         char recvbuf[1024] = {0};  
89.         char sendbuf[1024] = {0};  
90.         while(1)  
91.         {  
92.             if(recv(new_sock, recvbuf, sizeof(recvbuf), 0) <= 0)  
93.             {     
94.                 cout<<"recv error"<<endl;  
95.                 close(new_sock);  
96.                 break;  
97.             }  
98.   
99.             sleep(1);  
100.             strcpy(sendbuf, recvbuf);  
101.   
102.             if(send(new_sock, sendbuf, sizeof(sendbuf), 0) <= 0)  
103.             {     
104.                 cout<<"send error"<<endl;  
105.                 close(new_sock);  
106.                 break;  
107.             }  
108.               
109.         }  
110.     }     
111.   
112.     pthread_exit(NULL);  
113.     return NULL;  
114. }