服務器設計技術有很多，按使用的協議來分有 TCP 服務器和 UDP 服務器，按處理方式來分有循環服務器和并發服務器。

循環服務器與并發服務器模型

在網絡程序里面，一般來說都是許多客戶對應一個服務器（多對一），為了處理客戶的請求，對服務端的程序就提出了特殊的要求。

目前最常用的服務器模型有：

·循環服務器：服務器在同一時刻只能響應一個客戶端的請求

·并發服務器：服務器在同一時刻可以響應多個客戶端的請求

UDP 循環服務器的實現方法

UDP 循環服務器每次從套接字上讀取一個客戶端的請求 -> 處理 -> 然后將結果返回給客戶機。

因為 UDP 是非面向連接的，沒有一個客戶端可以老是占住服務端。只要處理過程不是死循環，或者耗時不是很長，服務器對于每一個客戶機的請求在某種程度上來說是能夠滿足。

UDP 循環服務器模型為：

socket(...); // 創建套接字 bind(...); // 綁定while(1) {recvfrom(...); // 接收客戶端的請求process(...); // 處理請求sendto(...); // 反饋處理結果 }
??

示例代碼如下：

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h>int main(int argc, char *argv[]) {unsigned short port = 8080; // 本地端口int sockfd;sockfd = socket(AF_INET, SOCK_DGRAM, 0); // 創建udp套接字if(sockfd < 0){perror("socket");exit(-1);}// 初始化本地網絡信息struct sockaddr_in my_addr;bzero(&my_addr, sizeof(my_addr)); // 清空my_addr.sin_family = AF_INET; // IPv4my_addr.sin_port = htons(port); // 端口my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // ipprintf("Binding server to port %d\n", port);// 綁定int err_log;err_log = bind(sockfd, (struct sockaddr*)&my_addr, sizeof(my_addr));if(err_log != 0){perror("bind");close(sockfd); exit(-1);}printf("receive data...\n");while(1){int recv_len;char recv_buf[512] = {0};struct sockaddr_in client_addr;char cli_ip[INET_ADDRSTRLEN] = "";//INET_ADDRSTRLEN=16socklen_t cliaddr_len = sizeof(client_addr);// 接收客戶端數據recv_len = recvfrom(sockfd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&client_addr, &cliaddr_len);// 處理數據，這里只是把接收過來的數據打印inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);printf("\nip:%s ,port:%d\n",cli_ip, ntohs(client_addr.sin_port)); // 客戶端的ipprintf("data(%d):%s\n",recv_len,recv_buf); // 客戶端的數據// 反饋結果，這里把接收直接到客戶端的數據回復過去sendto(sockfd, recv_buf, recv_len, 0, (struct sockaddr*)&client_addr, cliaddr_len);}close(sockfd);return 0; }

運行結果如下：

TCP 循環服務器的實現方法

TCP 循環服務器接受一個客戶端的連接，然后處理，完成了這個客戶的所有請求后，斷開連接。TCP 循環服務器一次只能處理一個客戶端的請求，只有在這個客戶的所有請求滿足后，服務器才可以繼續后面的請求。如果有一個客戶端占住服務器不放時，其它的客戶機都不能工作了，因此，TCP 服務器一般很少用循環服務器模型的。

TCP循環服務器模型為：

socket(...);// 創建套接字 bind(...);// 綁定 listen(...);// 監聽while(1) {accept(...);// 取出客戶端的請求連接process(...);// 處理請求，反饋結果close(...);// 關閉連接套接字：accept()返回的套接字 }

示例代碼如下：

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h>int main(int argc, char *argv[]) {unsigned short port = 8080; // 本地端口 // 創建tcp套接字int sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd < 0){perror("socket");exit(-1);}// 配置本地網絡信息struct sockaddr_in my_addr;bzero(&my_addr, sizeof(my_addr)); // 清空 my_addr.sin_family = AF_INET; // IPv4my_addr.sin_port = htons(port); // 端口my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // ip// 綁定int err_log = bind(sockfd, (struct sockaddr*)&my_addr, sizeof(my_addr));if( err_log != 0){perror("binding");close(sockfd); exit(-1);}// 監聽，套接字變被動err_log = listen(sockfd, 10); if(err_log != 0){perror("listen");close(sockfd); exit(-1);} printf("listen client @port=%d...\n",port);while(1){ struct sockaddr_in client_addr; char cli_ip[INET_ADDRSTRLEN] = ""; socklen_t cliaddr_len = sizeof(client_addr); // 取出客戶端已完成的連接int connfd;connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len); if(connfd < 0){perror("accept");continue;}// 打印客戶端的ip和端口inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);printf("----------------------------------------------\n");printf("client ip=%s,port=%d\n", cli_ip,ntohs(client_addr.sin_port));// 接收數據char recv_buf[512] = {0};int len = recv(connfd, recv_buf, sizeof(recv_buf), 0);// 處理數據，這里只是打印接收到的內容printf("\nrecv data:\n");printf("%s\n",recv_buf);// 反饋結果send(connfd, recv_buf, len, 0);close(connfd); //關閉已連接套接字printf("client closed!\n");}close(sockfd); //關閉監聽套接字return 0; }

運行結果如下：

三種并發服務器實現方法

一個好的服務器,一般都是并發服務器（同一時刻可以響應多個客戶端的請求）。并發服務器設計技術一般有：多進程服務器、多線程服務器、I/O復用服務器等。

多進程并發服務器

在 Linux 環境下多進程的應用很多,其中最主要的就是網絡/客戶服務器。多進程服務器是當客戶有請求時，服務器用一個子進程來處理客戶請求。父進程繼續等待其它客戶的請求。這種方法的優點是當客戶有請求時，服務器能及時處理客戶，特別是在客戶服務器交互系統中。對于一個 TCP 服務器,客戶與服務器的連接可能并不馬上關閉，可能會等到客戶提交某些數據后再關閉，這段時間服務器端的進程會阻塞，所以這時操作系統可能調度其它客戶服務進程，這比起循環服務器大大提高了服務性能。

TCP多進程并發服務器
TCP 并發服務器的思想是每一個客戶機的請求并不由服務器直接處理，而是由服務器創建一個子進程來處理。

示例代碼如下：

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> int main(int argc, char *argv[]) {unsigned short port = 8080; // 本地端口 // 創建tcp套接字int sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd < 0){perror("socket");exit(-1);}// 配置本地網絡信息struct sockaddr_in my_addr;bzero(&my_addr, sizeof(my_addr)); // 清空 my_addr.sin_family = AF_INET; // IPv4my_addr.sin_port = htons(port); // 端口my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // ip// 綁定int err_log = bind(sockfd, (struct sockaddr*)&my_addr, sizeof(my_addr));if( err_log != 0){perror("binding");close(sockfd); exit(-1);}// 監聽，套接字變被動err_log = listen(sockfd, 10); if(err_log != 0){perror("listen");close(sockfd); exit(-1);}while(1) //主進程 循環等待客戶端的連接{char cli_ip[INET_ADDRSTRLEN] = {0};struct sockaddr_in client_addr;socklen_t cliaddr_len = sizeof(client_addr);// 取出客戶端已完成的連接int connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len);if(connfd < 0){perror("accept");close(sockfd);exit(-1);}pid_t pid = fork();if(pid < 0){perror("fork");_exit(-1);}else if(0 == pid){ //子進程 接收客戶端的信息，并發還給客戶端/*關閉不需要的套接字可節省系統資源，同時可避免父子進程共享這些套接字可能帶來的不可預計的后果*/close(sockfd); // 關閉監聽套接字，這個套接字是從父進程繼承過來char recv_buf[1024] = {0};int recv_len = 0;// 打印客戶端的 ip 和端口memset(cli_ip, 0, sizeof(cli_ip)); // 清空inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);printf("----------------------------------------------\n");printf("client ip=%s,port=%d\n", cli_ip,ntohs(client_addr.sin_port));// 接收數據while( (recv_len = recv(connfd, recv_buf, sizeof(recv_buf), 0)) > 0 ){printf("recv_buf: %s\n", recv_buf); // 打印數據send(connfd, recv_buf, recv_len, 0); // 給客戶端回數據}printf("client closed!\n");close(connfd); //關閉已連接套接字exit(0);}else if(pid > 0){ // 父進程close(connfd); //關閉已連接套接字}}close(sockfd);return 0; }

運行結果如下：

多線程服務器

多線程服務器是對多進程的服務器的改進，由于多進程服務器在創建進程時要消耗較大的系統資源，所以用線程來取代進程，這樣服務處理程序可以較快的創建。據統計，創建線程與創建進程要快 10100 倍，所以又把線程稱為“輕量級”進程。線程與進程不同的是：一個進程內的所有線程共享相同的全局內存、全局變量等信息，這種機制又帶來了同步問題。

以下是多線程服務器模板:

示例代碼如下：

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <pthread.h>/************************************************************************ 函數名稱： void *client_process(void *arg) 函數功能： 線程函數,處理客戶信息 函數參數： 已連接套接字 函數返回： 無 ************************************************************************/ void *client_process(void *arg) {int recv_len = 0;char recv_buf[1024] = ""; // 接收緩沖區int connfd = (int)arg; // 傳過來的已連接套接字// 接收數據while((recv_len = recv(connfd, recv_buf, sizeof(recv_buf), 0)) > 0){printf("recv_buf: %s\n", recv_buf); // 打印數據send(connfd, recv_buf, recv_len, 0); // 給客戶端回數據}printf("client closed!\n");close(connfd); //關閉已連接套接字return NULL; }//=============================================================== // 語法格式： void main(void) // 實現功能： 主函數，建立一個TCP并發服務器 // 入口參數： 無 // 出口參數： 無 //=============================================================== int main(int argc, char *argv[]) {int sockfd = 0; // 套接字int connfd = 0;int err_log = 0;struct sockaddr_in my_addr; // 服務器地址結構體unsigned short port = 8080; // 監聽端口pthread_t thread_id;printf("TCP Server Started at port %d!\n", port);sockfd = socket(AF_INET, SOCK_STREAM, 0); // 創建TCP套接字if(sockfd < 0){perror("socket error");exit(-1);}bzero(&my_addr, sizeof(my_addr)); // 初始化服務器地址my_addr.sin_family = AF_INET;my_addr.sin_port = htons(port);my_addr.sin_addr.s_addr = htonl(INADDR_ANY);printf("Binding server to port %d\n", port);// 綁定err_log = bind(sockfd, (struct sockaddr*)&my_addr, sizeof(my_addr));if(err_log != 0){perror("bind");close(sockfd); exit(-1);}// 監聽，套接字變被動err_log = listen(sockfd, 10);if( err_log != 0){perror("listen");close(sockfd); exit(-1);}printf("Waiting client...\n");while(1){char cli_ip[INET_ADDRSTRLEN] = ""; // 用于保存客戶端IP地址struct sockaddr_in client_addr; // 用于保存客戶端地址socklen_t cliaddr_len = sizeof(client_addr); // 必須初始化!!!//獲得一個已經建立的連接 connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len); if(connfd < 0){perror("accept this time");continue;}// 打印客戶端的 ip 和端口inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);printf("----------------------------------------------\n");printf("client ip=%s,port=%d\n", cli_ip,ntohs(client_addr.sin_port));if(connfd > 0){//由于同一個進程內的所有線程共享內存和變量，因此在傳遞參數時需作特殊處理，值傳遞。pthread_create(&thread_id, NULL, (void *)client_process, (void *)connfd); //創建線程pthread_detach(thread_id); // 線程分離，結束時自動回收資源}}close(sockfd);return 0; }

運行結果如下：

注意，上面例子給線程傳參有很大的局限性，最簡單的一種情況，如果我們需要給線程傳多個參數，這時候我們需要結構體傳參，這種值傳遞編譯都通不過，這里之所以能夠這么值傳遞，是因為， int 長度時 4 個字節， void * 長度也是 4 個字節。

int connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len); pthread_create(&thread_id, NULL, (void *)client_process, (void *)connfd);
? ?

如果考慮類型匹配的話，應該是這么傳參，pthread_create()最后一個參數應該傳地址（ &connfd ），而不是值：

int connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len); pthread_create(&thread_id, NULL, (void *)client_process, (void *)&connfd);
?

但是，如果按地址傳遞的話，又會有這么一個問題，假如有多個客戶端要連接這個服務器，正常的情況下，一個客戶端連接對應一個 connfd，相互之間獨立不受影響，但是，假如多個客戶端同時連接這個服務器，A 客戶端的連接套接字為 connfd，服務器正在用這個 connfd 處理數據，還沒有處理完，突然來了一個 B 客戶端，accept()之后又生成一個 connfd, 因為是地址傳遞， A 客戶端的連接套接字也變成 B 這個了，這樣的話，服務器肯定不能再為 A 客戶端服務器了，這時候，我們就需要考慮多任務的互斥或同步問題了，這里通過互斥鎖來解決這個問題，確保這個connfd值被一個臨時變量保存過后，才允許修改。

#include <pthread.h>pthread_mutex_t mutex; // 定義互斥鎖，全局變量pthread_mutex_init(&mutex, NULL); // 初始化互斥鎖，互斥鎖默認是打開的// 上鎖，在沒有解鎖之前，pthread_mutex_lock()會阻塞 pthread_mutex_lock(&mutex); int connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len);//給回調函數傳的參數，&connfd，地址傳遞 pthread_create(&thread_id, NULL, (void *)client_process, (void *)&connfd); //創建線程// 線程回調函數 void *client_process(void *arg) {int connfd = *(int *)arg; // 傳過來的已連接套接字// 解鎖，pthread_mutex_lock()喚醒，不阻塞pthread_mutex_unlock(&mutex); return NULL; }

修改的完整代碼如下：

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <pthread.h>pthread_mutex_t mutex; // 定義互斥鎖，全局變量/************************************************************************ 函數名稱： void *client_process(void *arg) 函數功能： 線程函數,處理客戶信息 函數參數： 已連接套接字 函數返回： 無 ************************************************************************/ void *client_process(void *arg) {int recv_len = 0;char recv_buf[1024] = ""; // 接收緩沖區int connfd = *(int *)arg; // 傳過來的已連接套接字// 解鎖，pthread_mutex_lock()喚醒，不阻塞pthread_mutex_unlock(&mutex); // 接收數據while((recv_len = recv(connfd, recv_buf, sizeof(recv_buf), 0)) > 0){printf("recv_buf: %s\n", recv_buf); // 打印數據send(connfd, recv_buf, recv_len, 0); // 給客戶端回數據}printf("client closed!\n");close(connfd); //關閉已連接套接字return NULL; }//=============================================================== // 語法格式： void main(void) // 實現功能： 主函數，建立一個TCP并發服務器 // 入口參數： 無 // 出口參數： 無 //=============================================================== int main(int argc, char *argv[]) {int sockfd = 0; // 套接字int connfd = 0;int err_log = 0;struct sockaddr_in my_addr; // 服務器地址結構體unsigned short port = 8080; // 監聽端口pthread_t thread_id;pthread_mutex_init(&mutex, NULL); // 初始化互斥鎖，互斥鎖默認是打開的printf("TCP Server Started at port %d!\n", port);sockfd = socket(AF_INET, SOCK_STREAM, 0); // 創建TCP套接字if(sockfd < 0){perror("socket error");exit(-1);}bzero(&my_addr, sizeof(my_addr)); // 初始化服務器地址my_addr.sin_family = AF_INET;my_addr.sin_port = htons(port);my_addr.sin_addr.s_addr = htonl(INADDR_ANY);printf("Binding server to port %d\n", port);// 綁定err_log = bind(sockfd, (struct sockaddr*)&my_addr, sizeof(my_addr));if(err_log != 0){perror("bind");close(sockfd); exit(-1);}// 監聽，套接字變被動err_log = listen(sockfd, 10);if( err_log != 0){perror("listen");close(sockfd); exit(-1);}printf("Waiting client...\n");while(1){char cli_ip[INET_ADDRSTRLEN] = ""; // 用于保存客戶端IP地址struct sockaddr_in client_addr; // 用于保存客戶端地址socklen_t cliaddr_len = sizeof(client_addr); // 必須初始化!!!// 上鎖，在沒有解鎖之前，pthread_mutex_lock()會阻塞pthread_mutex_lock(&mutex); //獲得一個已經建立的連接 connfd = accept(sockfd, (struct sockaddr*)&client_addr, &cliaddr_len); if(connfd < 0){perror("accept this time");continue;}// 打印客戶端的 ip 和端口inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);printf("----------------------------------------------\n");printf("client ip=%s,port=%d\n", cli_ip,ntohs(client_addr.sin_port));if(connfd > 0){//給回調函數傳的參數，&connfd，地址傳遞pthread_create(&thread_id, NULL, (void *)client_process, (void *)&connfd); //創建線程pthread_detach(thread_id); // 線程分離，結束時自動回收資源}}close(sockfd);return 0; }

I/O復用服務器

I/O 復用技術是為了解決進程或線程阻塞到某個 I/O 系統調用而出現的技術，使進程不阻塞于某個特定的 I/O 系統調用。它也可用于并發服務器的設計，常用函數 select() 或 epoll() 來實現。詳情，請看《select、poll、epoll的區別使用》。

socket(...); // 創建套接字 bind(...); // 綁定 listen(...); // 監聽while(1) {if(select(...) > 0) // 檢測監聽套接字是否可讀{if(FD_ISSET(...)>0) // 套接字可讀，證明有新客戶端連接服務器 {accpet(...);// 取出已經完成的連接process(...);// 處理請求，反饋結果}}close(...); // 關閉連接套接字：accept()返回的套接字 }

示例代碼如下：

#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <sys/socket.h> #include <sys/types.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/select.h>#define SERV_PORT 8080 #define LIST 20 //服務器最大接受連接 #define MAX_FD 10 //FD_SET支持描述符數量int main(int argc, char *argv[]) {int sockfd;int err;int i;int connfd;int fd_all[MAX_FD]; //保存所有描述符，用于select調用后，判斷哪個可讀//下面兩個備份原因是select調用后，會發生變化，再次調用select前，需要重新賦值fd_set fd_read; //FD_SET數據備份fd_set fd_select; //用于selectstruct timeval timeout; //超時時間備份struct timeval timeout_select; //用于selectstruct sockaddr_in serv_addr; //服務器地址struct sockaddr_in cli_addr; //客戶端地址socklen_t serv_len;socklen_t cli_len;//超時時間設置timeout.tv_sec = 10;timeout.tv_usec = 0;//創建TCP套接字sockfd = socket(AF_INET, SOCK_STREAM, 0);if(sockfd < 0){perror("fail to socket");exit(1);}// 配置本地地址memset(&serv_addr, 0, sizeof(serv_addr));serv_addr.sin_family = AF_INET; // ipv4serv_addr.sin_port = htons(SERV_PORT); // 端口， 8080serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // ipserv_len = sizeof(serv_addr);// 綁定err = bind(sockfd, (struct sockaddr *)&serv_addr, serv_len);if(err < 0){perror("fail to bind");exit(1);}// 監聽err = listen(sockfd, LIST);if(err < 0){perror("fail to listen");exit(1);}//初始化fd_all數組memset(&fd_all, -1, sizeof(fd_all));fd_all[0] = sockfd; //第一個為監聽套接字FD_ZERO(&fd_read); // 清空FD_SET(sockfd, &fd_read); //將監聽套接字加入fd_readint maxfd;maxfd = fd_all[0]; //監聽的最大套接字while(1){// 每次都需要重新賦值，fd_select，timeout_select每次都會變fd_select = fd_read;timeout_select = timeout;// 檢測監聽套接字是否可讀，沒有可讀，此函數會阻塞// 只要有客戶連接，或斷開連接，select()都會往下執行err = select(maxfd+1, &fd_select, NULL, NULL, NULL);//err = select(maxfd+1, &fd_select, NULL, NULL, (struct timeval *)&timeout_select);if(err < 0){perror("fail to select");exit(1);}if(err == 0){printf("timeout\n");}// 檢測監聽套接字是否可讀if( FD_ISSET(sockfd, &fd_select) ){//可讀，證明有新客戶端連接服務器cli_len = sizeof(cli_addr);// 取出已經完成的連接connfd = accept(sockfd, (struct sockaddr *)&cli_addr, &cli_len);if(connfd < 0){perror("fail to accept");exit(1);}// 打印客戶端的 ip 和端口char cli_ip[INET_ADDRSTRLEN] = {0};inet_ntop(AF_INET, &cli_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);printf("----------------------------------------------\n");printf("client ip=%s,port=%d\n", cli_ip,ntohs(cli_addr.sin_port));// 將新連接套接字加入 fd_all 及 fd_readfor(i=0; i < MAX_FD; i++){if(fd_all[i] != -1){continue;}else{fd_all[i] = connfd;printf("client fd_all[%d] join\n", i);break;}}FD_SET(connfd, &fd_read);if(maxfd < connfd){maxfd = connfd; //更新maxfd}}//從1開始查看連接套接字是否可讀，因為上面已經處理過0（sockfd）for(i=1; i < maxfd; i++){if(FD_ISSET(fd_all[i], &fd_select)){printf("fd_all[%d] is ok\n", i);char buf[1024]={0}; //讀寫緩沖區int num = read(fd_all[i], buf, 1024);if(num > 0){//收到 客戶端數據并打印printf("receive buf from client fd_all[%d] is: %s\n", i, buf);//回復客戶端num = write(fd_all[i], buf, num);if(num < 0){perror("fail to write ");exit(1);}else{//printf("send reply\n");}}else if(0 == num){ // 客戶端斷開時//客戶端退出，關閉套接字，并從監聽集合清除printf("client:fd_all[%d] exit\n", i);FD_CLR(fd_all[i], &fd_read);close(fd_all[i]);fd_all[i] = -1;continue;}}else {//printf("no data\n"); }}}return 0; }

運行結果如下：

參考于：http://blog.chinaunix.net

總結

以上是生活随笔為你收集整理的【Linux网络编程】并发服务器的三种实现模型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。