linux網絡編程：併發服務器的模型

這篇博客主要是參考了http://renwen0524.blog.163.com/blog/static/7301945520116116016141/，這篇博客把linux網絡編程的併發服務器的模型整理得很詳細了，這裏我是在此基礎上加上了一些我自己的理解。

對於進行套接字編程，選擇一個號的服務器模型是非常重要的，爲了實現併發的服務，有以下幾種方法可以做到：

1、併發服務器模型之一：預先分配進程個數。
2、併發服務器模型之二：預先分配多線程個數，使用互斥鎖。
3、併發服務器模型之三：單客戶端單進程，統一accept。
4、併發服務器模型之四：單客戶端單線程，統一accept。
5、併發服務器模型之五：IO複用循環服務器。

（1）預先分配進程個數：

方法：在服務器端，主程序提前構建多個子進程，當客戶端的請求到來的時候，系統從進程池中選取一個子進程來處理客戶端的連接，每個子進程處理一個客戶端的請求。具體模型爲如下：

服務器端的代碼爲：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>


#define BUFLEN 1024
#define PIDNUM 3


/*******************併發服務器模型之一：預先分配好了進程的個數**********************/


static void handle_fork(int sockfd){
    int newfd;
    struct sockaddr_in c_addr;
    char buf[BUFLEN];
    socklen_t len;
    time_t now;
    while(1){
        len = sizeof(struct sockaddr);
        if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) == -1){
            perror("accept");        
            exit(errno);
        }else
        printf("\n*****************通信開始***************\n");
        printf("正在與您通信的客戶端是：%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));


        /******處理客戶端請求*******/
        bzero(buf,BUFLEN);
        len = recv(newfd,buf,BUFLEN,0);
        if(len >0 && !strncmp(buf,"TIME",4)){
            bzero(buf,BUFLEN);
            /*獲取系統當前時間*/
            now = time(NULL);
            /*ctime將系統時間轉換爲字符串，sprintf使轉化後的字符串保存在buf*/
            sprintf(buf,"%24s\r\n",ctime(&now));
            //******發送系統時間*******/
            send(newfd,buf,strlen(buf),0);
        }
        /*關閉通訊的套接字*/
        close(newfd);
    }
}


int main(int argc, char **argv)
{
    int sockfd;
    struct sockaddr_in s_addr;
    unsigned int port, listnum;
    pid_t pid[PIDNUM];
    
    /*建立socket*/
    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
        perror("socket");
        exit(errno);
    }else
        printf("socket create success!\n");
    /*設置服務器端口*/    
    if(argv[2])
        port = atoi(argv[2]);
    else
        port = 4567;
    /*設置偵聽隊列長度*/
    if(argv[3])
        listnum = atoi(argv[3]);
    else
        listnum = 3;
    /*設置服務器ip*/
    bzero(&s_addr, sizeof(s_addr));
    s_addr.sin_family = AF_INET;
    s_addr.sin_port = htons(port);
    if(argv[1])
        s_addr.sin_addr.s_addr = inet_addr(argv[1]);
    else
        s_addr.sin_addr.s_addr = INADDR_ANY;
    /*把地址和端口幫定到套接字上*/
    if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
        perror("bind");
        exit(errno);
    }else
        printf("bind success!\n");
    /*偵聽本地端口*/
    if(listen(sockfd,listnum) == -1){
        perror("listen");
        exit(errno);    
    }else
        printf("the server is listening!\n");
    /*處理客戶端的連接*/
    int i = 0;
    for(i = 0; i < PIDNUM; i++){
        pid[i] = fork();
        if(pid[i] == 0)
            handle_fork(sockfd);    
    }
    /*關閉服務器的套接字*/
    close(sockfd);
    return 0;
}

這個程序執行的時候各個子進程將變成孤兒進程。因爲在子進程真正執行的時候父進程已經結束了。爲了使子進程不變成孤兒進程的話，可以使用waitpid函數來等待子進程結束。具體用法就是在close（sockfd）；語句之前加上相應的waitpid函數來等待子進程結束。

（2）預先分配n個線程，使用互斥鎖

使用預先分配線程的併發服務器與之前使用預先分配進程的併發服務器的主要過程是一致的。主程序先建立多個處理線程，然後等待線程的結束，在多個線程中對客戶端的請求進行處理。處理過程包括接收客戶端的鏈接，處理數據，發送響應過程。這個可以結合線程池來進行相應的處理工作。

相應的模型如下

相應的服務器端的程序如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <errno.h>
   
5. #include <sys/socket.h>
   
6. #include <arpa/inet.h>
   
7. #include <netinet/in.h>
   
8. #include <sys/types.h>
   
9. #include <unistd.h>
   
10. #include <time.h>
    
11. #include <pthread.h>
    
12. 
    
13. #define BUFLEN 1024
    
14. #define THREADNUM 3
    
15. /*互斥量*/
    
16. pthread_mutex_t ALOCK = PTHREAD_MUTEX_INITIALIZER;
    
17. 
    
18. /****併發服務器模型之二：預先分配多個線程（單客戶端單線程，各個線程統一accept,並且使用互斥鎖） ****/
    
19. 
    
20. static void *handle_thread(void *argv){
    
21.     int sockfd = *((int *)argv);    
    
22.     int newfd;
    
23.     struct sockaddr_in c_addr;
    
24.     socklen_t len;
    
25.     char buf[BUFLEN];
    
26.     time_t now;
    
27. 
    
28.     while(1){
    
29.         len = sizeof(struct sockaddr);
    
30.         /*拒絕客戶端的請求*/
    
31.         pthread_mutex_lock(&ALOCK);
    
32.         if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) == -1){
    
33.             perror("accept");        
    
34.             exit(errno);
    
35.         }else{
    
36.             printf("\n*****************通信開始***************\n");
    
37.             printf("正在與您通信的客戶端是：%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));        
    
38.         }
    
39.         /*接受客戶端的請求*/
    
40.         pthread_mutex_unlock(&ALOCK);
    
41.         /******處理客戶端請求*******/
    
42.         bzero(buf,BUFLEN);
    
43.         len = recv(newfd,buf,BUFLEN,0);
    
44.         if(len >0 && !strncmp(buf,"TIME",4)){
    
45.             bzero(buf,BUFLEN);
    
46.             /*獲取系統當前時間*/
    
47.             now = time(NULL);
    
48.             /*ctime將系統時間轉換爲字符串，sprintf使轉化後的字符串保存在buf*/
    
49.             sprintf(buf,"%24s\r\n",ctime(&now));
    
50.             //******發送系統時間*******/
    
51.             send(newfd,buf,strlen(buf),0);
    
52.         }
    
53.         /*關閉通訊的套接字*/
    
54.         close(newfd);
    
55.     }
    
56.     return NULL;
    
57. }
    
58. 
    
59. int main(int argc, char **argv)
    
60. {
    
61.     int sockfd;
    
62.     struct sockaddr_in s_addr;
    
63.     unsigned int port, listnum;
    
64.     pthread_t thread_s[THREADNUM];
    
65.     
    
66.     /*建立socket*/
    
67.     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
    
68.         perror("socket");
    
69.         exit(errno);
    
70.     }else
    
71.         printf("socket create success!\n");
    
72.     /*設置服務器端口*/    
    
73.     if(argv[2])
    
74.         port = atoi(argv[2]);
    
75.     else
    
76.         port = 4567;
    
77.     /*設置偵聽隊列長度*/
    
78.     if(argv[3])
    
79.         listnum = atoi(argv[3]);
    
80.     else
    
81.         listnum = 3;
    
82.     /*設置服務器ip*/
    
83.     bzero(&s_addr, sizeof(s_addr));
    
84.     s_addr.sin_family = AF_INET;
    
85.     s_addr.sin_port = htons(port);
    
86.     if(argv[1])
    
87.         s_addr.sin_addr.s_addr = inet_addr(argv[1]);
    
88.     else
    
89.         s_addr.sin_addr.s_addr = INADDR_ANY;
    
90.     /*把地址和端口幫定到套接字上*/
    
91.     if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
    
92.         perror("bind");
    
93.         exit(errno);
    
94.     }else
    
95.         printf("bind success!\n");
    
96.     /*偵聽本地端口*/
    
97.     if(listen(sockfd,listnum) == -1){
    
98.         perror("listen");
    
99.         exit(errno);    
    
100.     }else
     
101.         printf("the server is listening!\n");
     
102.     /*處理客戶端的連接*/
     
103.     int i = 0;
     
104.     for(i = 0; i < THREADNUM; i++){
     
105.         /*創建線程來處理連接*/
     
106.         pthread_create(&thread_s[i],NULL,handle_thread,(void *)&sockfd);        
     
107.     }
     
108.     /*等待線程結束*/
     
109.     for(i = 0; i < THREADNUM; i++){
     
110.         pthread_join(thread_s[i],NULL);
     
111.     }
     
112.     /*關閉服務器的套接字*/
     
113.     close(sockfd);
     
114.     return 0;
     
115. }

（3）單客戶端單進程，統一accept

實質就會統一accept，當accept之後就給相應的開一個進程進行處理這個已經連接了的套接字，而另一方面，父進程則繼續等待客戶端的連接請求。即：主進程運行時，等待客戶端連接的到來，當客戶端連接請求到來時，服務器的accept（）函數成功返回，此時服務器端進行進程分叉，父進程繼續等待客戶端的連接請求；而子進程則處理客戶端的業務請求，接收客戶端的數據，分析數據並返回結果。

相應的代碼如下；

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <errno.h>
   
5. #include <sys/socket.h>
   
6. #include <arpa/inet.h>
   
7. #include <netinet/in.h>
   
8. #include <sys/types.h>
   
9. #include <unistd.h>
   
10. #include <time.h>
    
11. 
    
12. #define BUFLEN 1024
    
13. 
    
14. /*******************併發服務器模型之三：單客戶端單進程，統一accept**********************/
    
15. 
    
16. static void handle_request(int newfd){
    
17.     char buf[BUFLEN];
    
18.     int len;
    
19.     time_t now;
    
20.     /******處理客戶端請求*******/
    
21.     bzero(buf,BUFLEN);
    
22.     len = recv(newfd,buf,BUFLEN,0);
    
23.     if(len >0 && !strncmp(buf,"TIME",4)){
    
24.         bzero(buf,BUFLEN);
    
25.         /*獲取系統當前時間*/
    
26.         now = time(NULL);
    
27.         /*ctime將系統時間轉換爲字符串，sprintf使轉化後的字符串保存在buf*/
    
28.         sprintf(buf,"%24s\r\n",ctime(&now));
    
29.         //******發送系統時間*******/
    
30.         send(newfd,buf,strlen(buf),0);
    
31.     }
    
32.     /*關閉通訊的套接字*/
    
33.     close(newfd);
    
34. }
    
35. 
    
36. static void handle_connect(int sockfd){
    
37.     int newfd;
    
38.     struct sockaddr_in c_addr;
    
39.     socklen_t len;
    
40. 
    
41.     while(1){
    
42.         len = sizeof(struct sockaddr);
    
43.         if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) == -1){
    
44.             perror("accept");        
    
45.             exit(errno);
    
46.         }else{
    
47.             /*創建進程來處理連接*/
    
48.             if(fork() > 0)
    
49.                 close(newfd);            
    
50.             else{
    
51.                 printf("\n*****************通信開始***************\n");
    
52.                 printf("正在與您通信的客戶端是：%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));
    
53.                 handle_request(newfd);
    
54.             }
    
55.         }
    
56.     }
    
57. }
    
58. 
    
59. int main(int argc, char **argv)
    
60. {
    
61.     int sockfd;
    
62.     struct sockaddr_in s_addr;
    
63.     unsigned int port, listnum;
    
64.     
    
65.     /*建立socket*/
    
66.     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
    
67.         perror("socket");
    
68.         exit(errno);
    
69.     }else
    
70.         printf("socket create success!\n");
    
71.     /*設置服務器端口*/    
    
72.     if(argv[2])
    
73.         port = atoi(argv[2]);
    
74.     else
    
75.         port = 4567;
    
76.     /*設置偵聽隊列長度*/
    
77.     if(argv[3])
    
78.         listnum = atoi(argv[3]);
    
79.     else
    
80.         listnum = 3;
    
81.     /*設置服務器ip*/
    
82.     bzero(&s_addr, sizeof(s_addr));
    
83.     s_addr.sin_family = AF_INET;
    
84.     s_addr.sin_port = htons(port);
    
85.     if(argv[1])
    
86.         s_addr.sin_addr.s_addr = inet_addr(argv[1]);
    
87.     else
    
88.         s_addr.sin_addr.s_addr = INADDR_ANY;
    
89.     /*把地址和端口幫定到套接字上*/
    
90.     if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
    
91.         perror("bind");
    
92.         exit(errno);
    
93.     }else
    
94.         printf("bind success!\n");
    
95.     /*偵聽本地端口*/
    
96.     if(listen(sockfd,listnum) == -1){
    
97.         perror("listen");
    
98.         exit(errno);    
    
99.     }else
    
100.         printf("the server is listening!\n");
     
101.     /*處理客戶端的連接*/
     
102.     handle_connect(sockfd);
     
103.     /*關閉服務器的套接字*/
     
104.     close(sockfd);
     
105.     return 0;
     
106. }

（4）單客戶單線程，統一accept

在一個主程序中，接收客戶端的連接，當客戶端連接到來的時候，使用pthread_create（）函數來建立一個線程來處理客戶端的請求。

相應的代碼爲：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <errno.h>
   
5. #include <sys/socket.h>
   
6. #include <arpa/inet.h>
   
7. #include <netinet/in.h>
   
8. #include <sys/types.h>
   
9. #include <unistd.h>
   
10. #include <time.h>
    
11. #include <pthread.h>
    
12. 
    
13. #define BUFLEN 1024
    
14. 
    
15. /*******************併發服務器模型之四：單客戶端單線程，統一accept**********************/
    
16. 
    
17. static void *handle_request(void *argv){
    
18.     int newfd = *((int *)argv);    
    
19.     char buf[BUFLEN];
    
20.     int len;
    
21.     time_t now;
    
22.     /******處理客戶端請求*******/
    
23.     bzero(buf,BUFLEN);
    
24.     len = recv(newfd,buf,BUFLEN,0);
    
25.     if(len >0 && !strncmp(buf,"TIME",4)){
    
26.         bzero(buf,BUFLEN);
    
27.         /*獲取系統當前時間*/
    
28.         now = time(NULL);
    
29.         /*ctime將系統時間轉換爲字符串，sprintf使轉化後的字符串保存在buf*/
    
30.         sprintf(buf,"%24s\r\n",ctime(&now));
    
31.         //******發送系統時間*******/
    
32.         send(newfd,buf,strlen(buf),0);
    
33.     }
    
34.     /*關閉通訊的套接字*/
    
35.     close(newfd);
    
36.     return NULL;
    
37. }
    
38. 
    
39. static void handle_connect(int sockfd){
    
40.     int newfd;
    
41.     struct sockaddr_in c_addr;
    
42.     socklen_t len;
    
43.     pthread_t thread_s;
    
44. 
    
45.     while(1){
    
46.         len = sizeof(struct sockaddr);
    
47.         if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) >0){
    
48.             printf("\n*****************通信開始***************\n");
    
49.             printf("正在與您通信的客戶端是：%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));
    
50.             /*創建線程來處理連接*/
    
51.             pthread_create(&thread_s,NULL,handle_request,(void *)&newfd);            
    
52.         }
    
53.     }
    
54. }
    
55. 
    
56. int main(int argc, char **argv)
    
57. {
    
58.     int sockfd;
    
59.     struct sockaddr_in s_addr;
    
60.     unsigned int port, listnum;
    
61.     
    
62.     /*建立socket*/
    
63.     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
    
64.         perror("socket");
    
65.         exit(errno);
    
66.     }else
    
67.         printf("socket create success!\n");
    
68.     /*設置服務器端口*/    
    
69.     if(argv[2])
    
70.         port = atoi(argv[2]);
    
71.     else
    
72.         port = 4567;
    
73.     /*設置偵聽隊列長度*/
    
74.     if(argv[3])
    
75.         listnum = atoi(argv[3]);
    
76.     else
    
77.         listnum = 3;
    
78.     /*設置服務器ip*/
    
79.     bzero(&s_addr, sizeof(s_addr));
    
80.     s_addr.sin_family = AF_INET;
    
81.     s_addr.sin_port = htons(port);
    
82.     if(argv[1])
    
83.         s_addr.sin_addr.s_addr = inet_addr(argv[1]);
    
84.     else
    
85.         s_addr.sin_addr.s_addr = INADDR_ANY;
    
86.     /*把地址和端口幫定到套接字上*/
    
87.     if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
    
88.         perror("bind");
    
89.         exit(errno);
    
90.     }else
    
91.         printf("bind success!\n");
    
92.     /*偵聽本地端口*/
    
93.     if(listen(sockfd,listnum) == -1){
    
94.         perror("listen");
    
95.         exit(errno);    
    
96.     }else
    
97.         printf("the server is listening!\n");
    
98.     /*處理客戶端的連接*/
    
99.     handle_connect(sockfd);
    
100.     /*關閉服務器的套接字*/
     
101.     close(sockfd);
     
102.     return 0;
     
103. }
104. （5）IO多路複用的方法
105. 具體的簡介：前面的服務器模型主要集中在併發服務器上，併發服務器有個比較大的缺陷，它需要建立多個並行的處理單元。當客戶端增加時，隨着處理單元的增加，系統的負載會逐漸轉移到並行單元的現場切換上。因此有一個比較新型的IO複用循環服務器。該模型在系統開始時，建立多個不同工作類型的處理單元，當客戶端的請求到來時，將客戶端的連接放到一個狀態池中，對所有客戶端的連接狀態在一個處理單元中進行輪詢處理。
106. 
     
107. 相應的代碼爲如下：
108. 1. #include <stdio.h>
        
     2. #include <stdlib.h>
        
     3. #include <string.h>
        
     4. #include <errno.h>
        
     5. #include <sys/socket.h>
        
     6. #include <arpa/inet.h>
        
     7. #include <netinet/in.h>
        
     8. #include <sys/types.h>
        
     9. #include <unistd.h>
        
     10. #include <time.h>
         
     11. #include <pthread.h>
         
     12. 
         
     13. #define BUFLEN 1024
         
     14. #define THREADNUM 2
         
     15. #define CLIENTNUM 1024
         
     16. 
         
     17. int connect_host[CLIENTNUM];
         
     18. int connect_num = 0;
         
     19. /*******************併發服務器模型之五：IO複用循環服務器**********************/
         
     20. 
         
     21. static void *handle_request(void *argv){
         
     22.     char buf[BUFLEN];
         
     23.     int len;
         
     24.     time_t now;
         
     25.     int maxfd = -1;
         
     26.     fd_set rfds;
         
     27.     struct timeval tv;
         
     28.     tv.tv_sec = 1;
         
     29.     tv.tv_usec = 0;
         
     30.     int i =0;
         
     31.     int err = -1;
         
     32. 
         
     33.     while(1){
         
     34.         FD_ZERO(&rfds);
         
     35.         for(i = 0; i < CLIENTNUM; i++){
         
     36.             if(connect_host[i] != -1){
         
     37.                 FD_SET(connect_host[i],&rfds);
         
     38.                 if(maxfd < connect_host[i])
         
     39.                     maxfd = connect_host[i];
         
     40.             }    
         
     41.         }
         
     42.         err = select(maxfd+1, &rfds, NULL, NULL, &tv);
         
     43.         switch(err){
         
     44.             case 0: break;
         
     45.             case -1: break;
         
     46.             default:
         
     47.                 if (connect_num < 0)
         
     48.                     break;
         
     49.                 for(i = 0; i < CLIENTNUM; i++){
         
     50.                     if(connect_host[i] != -1){
         
     51.                         if(FD_ISSET(connect_host[i],&rfds)){
         
     52.                             /******處理客戶端請求*******/
         
     53.                             bzero(buf,BUFLEN);
         
     54.                             len = recv(connect_host[i],buf,BUFLEN,0);
         
     55.                             if(len >0 && !strncmp(buf,"TIME",4)){
         
     56.                                 bzero(buf,BUFLEN);
         
     57.                                 /*獲取系統當前時間*/
         
     58.                                 now = time(NULL);
         
     59.                                 /*ctime將系統時間轉換爲字符串，sprintf使轉化後的字符串保存在buf*/
         
     60.                                 sprintf(buf,"%24s\r\n",ctime(&now));
         
     61.                                 //******發送系統時間*******/
         
     62.                                 send(connect_host[i],buf,strlen(buf),0);
         
     63.                             }
         
     64.                             /*關閉通訊的套接字*/
         
     65.                             close(connect_host[i]);
         
     66.                             /*更新文件描述符在數組中的值*/
         
     67.                             connect_host[i] = -1;
         
     68.                             connect_num--;    
         
     69.                         }
         
     70.                     }            
         
     71.                 }
         
     72.                 break;
         
     73.         }
         
     74.     }
         
     75.     return NULL;
         
     76. }
         
     77. 
         
     78. static void *handle_connect(void *arg){
         
     79.     int sockfd = *((int *)arg);
         
     80.     int newfd;
         
     81.     struct sockaddr_in c_addr;
         
     82.     socklen_t len;
         
     83.     int i;
         
     84. 
         
     85.     while(1){
         
     86.         len = sizeof(struct sockaddr);
         
     87.         if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) >0){
         
     88.             printf("\n*****************通信開始***************\n");
         
     89.             printf("正在與您通信的客戶端是：%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));
         
     90.             for(i = 0; i < CLIENTNUM; i++){
         
     91.                 if(connect_host[i] == -1){
         
     92.                     connect_host[i] = newfd;
         
     93.                     /*客戶端計數器*/
         
     94.                     connect_num++;
         
     95.                     /*繼續等待新的客戶端*/
         
     96.                     break;            
         
     97.                 }
         
     98.             }
         
     99.         }
         
     100.     }
          
     101.     return NULL;
          
     102. }
          
     103. 
          
     104. int main(int argc, char **argv)
          
     105. {
          
     106.     int sockfd;
          
     107.     struct sockaddr_in s_addr;
          
     108.     unsigned int port, listnum;
          
     109.     pthread_t thread_s[2];
          
     110.     
          
     111.     /**/    
          
     112.     memset(connect_host,-1,CLIENTNUM);
          
     113.     /*建立socket*/
          
     114.     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
          
     115.         perror("socket");
          
     116.         exit(errno);
          
     117.     }else
          
     118.         printf("socket create success!\n");
          
     119.     /*設置服務器端口*/    
          
     120.     if(argv[2])
          
     121.         port = atoi(argv[2]);
          
     122.     else
          
     123.         port = 4567;
          
     124.     /*設置偵聽隊列長度*/
          
     125.     if(argv[3])
          
     126.         listnum = atoi(argv[3]);
          
     127.     else
          
     128.         listnum = 3;
          
     129.     /*設置服務器ip*/
          
     130.     bzero(&s_addr, sizeof(s_addr));
          
     131.     s_addr.sin_family = AF_INET;
          
     132.     s_addr.sin_port = htons(port);
          
     133.     if(argv[1])
          
     134.         s_addr.sin_addr.s_addr = inet_addr(argv[1]);
          
     135.     else
          
     136.         s_addr.sin_addr.s_addr = INADDR_ANY;
          
     137.     /*把地址和端口幫定到套接字上*/
          
     138.     if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
          
     139.         perror("bind");
          
     140.         exit(errno);
          
     141.     }else
          
     142.         printf("bind success!\n");
          
     143.     /*偵聽本地端口*/
          
     144.     if(listen(sockfd,listnum) == -1){
          
     145.         perror("listen");
          
     146.         exit(errno);    
          
     147.     }else
          
     148.         printf("the server is listening!\n");
          
     149.     /*創建線程處理客戶端的連接*/
          
     150.     pthread_create(&thread_s[0],NULL,handle_connect,(void *)&sockfd);
          
     151.     /*創建線程處理客戶端的請求*/
          
     152.     pthread_create(&thread_s[1],NULL,handle_request, NULL);
          
     153.     /*等待線程結束*/
          
     154.     int i;
          
     155.     for(i = 0; i < THREADNUM; i++){
          
     156.         pthread_join(thread_s[i],NULL);
          
     157.     }
          
     158.     /*關閉服務器的套接字*/
          
     159.     close(sockfd);
          
     160.     return 0;
          
     161. }
     
     

還有其他的一些方法：如線程池（其實和第二種方法是類似的）之類的處理方法也是可以實現併發服務器的。