linux网络编程：并发服务器的模型

这篇博客主要是参考了http://renwen0524.blog.163.com/blog/static/7301945520116116016141/，这篇博客把linux网络编程的并发服务器的模型整理得很详细了，这里我是在此基础上加上了一些我自己的理解。

对于进行套接字编程，选择一个号的服务器模型是非常重要的，为了实现并发的服务，有以下几种方法可以做到：

1、并发服务器模型之一：预先分配进程个数。
2、并发服务器模型之二：预先分配多线程个数，使用互斥锁。
3、并发服务器模型之三：单客户端单进程，统一accept。
4、并发服务器模型之四：单客户端单线程，统一accept。
5、并发服务器模型之五：IO复用循环服务器。

（1）预先分配进程个数：

方法：在服务器端，主程序提前构建多个子进程，当客户端的请求到来的时候，系统从进程池中选取一个子进程来处理客户端的连接，每个子进程处理一个客户端的请求。具体模型为如下：

服务器端的代码为：

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include


#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. }
     
     

还有其他的一些方法：如线程池（其实和第二种方法是类似的）之类的处理方法也是可以实现并发服务器的。