一. 高并发服务器

高并发服务器简单说就是：服务器可以同时容许多个客户端同时并发访问常用的有多进程并发服务器和多线程并发服务器。

二. 多进程并发服务器

父进程循环accept，当父进程接收到连接请求之后，立即fork出一个新的子进程去处理通信，而父进程继续循环等待接收accept()(没有连接请求父进程则阻塞，但是不会影响到子进程通信)。而对于自己进程回收，父进程可以用一个单独的子进程去回收用于通信的子进程。子进程也可以自己fork出新的子进程与原进程分别处理读与写(发与收)，以致于读写之间不受阻塞限制。
注意：子进程会继承父进程文件描述符，对于用不到的文件描述符listenfd需要关闭，并且父进程中在创建fork之后也需要关闭confd。防止文件描述符无意义的耗费过度。

使用多进程并发服务器时要考虑以下几点：

1. 父进程最大文件描述个数(父进程中需要close关闭accept返回的新文件描述符)
2. 系统内创建进程个数(与内存大小相关)
3. 进程创建过多是否降低整体服务性能(进程调度)

**多进程服务器分析**
1. Socket();		创建 监听套接字 lfd
2. Bind()	绑定地址结构 Strcut scokaddr_in addr;
3. Listen();	
4. while (1) {cfd = Accpet();			接收客户端连接请求。pid = fork();if (pid == 0){			子进程 read(cfd) --- 小-》大 --- write(cfd)close(lfd)		关闭用于建立连接的套接字 lfd ，子进程不需要监听连接read()操作函数write()} else if （pid > 0）{	close(cfd);		父进程不需要传递数据，关闭用于与客户端通信的套接字 cfd	contiue;}}
5. 子进程：close(lfd)read()操作函数write()	父进程：close(cfd);注册信号捕捉函数：	SIGCHLD在回调函数中， 完成子进程回收while （waitpid()）;

示例代码：

1.	#include <stdio.h>  
2.	#include <ctype.h>  
3.	#include <stdlib.h>  
4.	#include <sys/wait.h>  
5.	#include <string.h>  
6.	#include <strings.h>  
7.	#include <unistd.h>  
8.	#include <errno.h>  
9.	#include <signal.h>  
10.	#include <sys/socket.h>  
11.	#include <arpa/inet.h>  
12.	#include <pthread.h>  
13.	  
14.	#include "wrap.h"  
15.	  
16.	#define SRV_PORT 9999  
17.	  
18.	void catch_child(int signum)  
19.	{  
20.	     //循环回收子进程，利用信号函数
21.	    while ((waitpid(0, NULL, WNOHANG)) > 0);  
22.	    return ;  
23.	}  
24.	  
25.	int main(int argc, char *argv[])  
26.	{  
27.	    int lfd, cfd;  
28.	    pid_t pid;  
29.	    struct sockaddr_in srv_addr, clt_addr;  
30.	    socklen_t clt_addr_len;   
31.	    char buf[BUFSIZ];  
32.	    int ret, i;  
33.	  
34.	    //memset(&srv_addr, 0, sizeof(srv_addr));                 // 将地址结构清零  
35.	    bzero(&srv_addr, sizeof(srv_addr));  
36.	  
37.	    srv_addr.sin_family = AF_INET;  
38.	    srv_addr.sin_port = htons(SRV_PORT);  
39.	    srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  
40.	  
41.	    lfd = Socket(AF_INET, SOCK_STREAM, 0);  
42.	  
43.	    Bind(lfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr));  
44.	  
45.	    Listen(lfd, 128);  
46.	  
47.	    clt_addr_len = sizeof(clt_addr);  
48.	  
49.	    while (1) {  
50.	  
51.	        cfd = Accept(lfd, (struct sockaddr *)&clt_addr, &clt_addr_len);  
52.	  
53.	        pid = fork();  
54.	        if (pid < 0) {  
55.	            perr_exit("fork error");  
56.	        } else if (pid == 0) {  
57.	            close(lfd);  
58.	            break;          
59.	        } else {  
60.	            struct sigaction act;  
61.	  
62.	            act.sa_handler = catch_child;  
63.	            sigemptyset(&act.sa_mask);  
64.	            act.sa_flags = 0;  
65.	  
66.	            ret = sigaction(SIGCHLD, &act, NULL);  
67.	            if (ret != 0) {  
68.	               perr_exit("sigaction error");  
69.	            }  
70.	            close(cfd);   
71.	            continue;  
72.	        }  
73.	    }  
74.	  
75.	    if (pid == 0) {  
76.	        for (;;) {  
77.	            ret = Read(cfd, buf, sizeof(buf));  
78.	            if (ret == 0) {  
79.	                close(cfd);  
80.	                exit(1);  
81.	            }   
82.	  
83.	            for (i = 0; i < ret; i++)  
84.	                buf[i] = toupper(buf[i]);  
85.	  
86.	            write(cfd, buf, ret);  
87.	            write(STDOUT_FILENO, buf, ret);  
88.	        }  
89.	    }  
91.	    return 0;  
92.	}  

代码中子进程回收用信号捕捉来实现。运行结果：

多进程服务器测试IP地址调整，使用桥接模式，让自己主机和其他人主机处于同一个网段这样就可以相互访问。

服务器程序上传外网服务器并访问
scp -r 命令，将本地文件拷贝至远程服务器上目标位置
scp -r 源地址 目标地址
将自己的服务器程序发送到网络服务器端。需要输入密码。

三. 多线程程并发服务器

多线程并发服务器： server.c 1. Socket();		创建 监听套接字 lfd2. Bind()		绑定地址结构 Strcut scokaddr_in addr;3. Listen();		4. while (1) {		cfd = Accept(lfd, );pthread_create(&tid, NULL, tfn, (void *)cfd);pthread_detach(tid);  // pthead_join(tid, void **);  新线程---专用于回收子线程。}5. 子线程：void *tfn(void *arg) {// close(lfd)			不能关闭。 主线程要使用lfdread(cfd)操作函数write(cfd)pthread_exit（(void *)10）;	}

1.	#include <stdio.h>  
2.	#include <string.h>  
3.	#include <arpa/inet.h>  
4.	#include <pthread.h>  
5.	#include <ctype.h>  
6.	#include <unistd.h>  
7.	#include <fcntl.h>  
8.	  
9.	#include "wrap.h"  
10.	  
11.	#define MAXLINE 8192  
12.	#define SERV_PORT 8000  
13.	  
14.	struct s_info {                     //定义一个结构体, 将地址结构跟cfd捆绑  
15.	    struct sockaddr_in cliaddr;  
16.	    int connfd;  
17.	};  
18.	  
19.	void *do_work(void *arg)  
20.	{  
21.	    int n,i;  
22.	    struct s_info *ts = (struct s_info*)arg;  
23.	    char buf[MAXLINE];  
24.	    char str[INET_ADDRSTRLEN];      //#define INET_ADDRSTRLEN 16  可用"[+d"查看  
25.	  
26.	    while (1) {  
27.	        n = Read(ts->connfd, buf, MAXLINE);                     //读客户端  
28.	        if (n == 0) {  
29.	            printf("the client %d closed...\n", ts->connfd);  
30.	            break;                                              //跳出循环,关闭cfd  
31.	        }  
32.	        printf("received from %s at PORT %d\n",  
33.	                inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),  
34.	                ntohs((*ts).cliaddr.sin_port));                 //打印客户端信息(IP/PORT)  
35.	  
36.	        for (i = 0; i < n; i++)   
37.	            buf[i] = toupper(buf[i]);                           //小写-->大写  
38.	  
39.	        Write(STDOUT_FILENO, buf, n);                           //写出至屏幕  
40.	        Write(ts->connfd, buf, n);                              //回写给客户端  
41.	    }  
42.	    Close(ts->connfd);  
43.	  
44.	    return (void *)0;  
45.	}  
46.	  
47.	int main(void)  
48.	{  
49.	    struct sockaddr_in servaddr, cliaddr;  
50.	    socklen_t cliaddr_len;  
51.	    int listenfd, connfd;  
52.	    pthread_t tid;  
53.	  
54.	    struct s_info ts[256];      //创建结构体数组.  
55.	    int i = 0;  
56.	  
57.	    listenfd = Socket(AF_INET, SOCK_STREAM, 0);                     //创建一个socket, 得到lfd  
58.	  
59.	    bzero(&servaddr, sizeof(servaddr));                             //地址结构清零  
60.	    servaddr.sin_family = AF_INET;  
61.	    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);                               //指定本地任意IP  
62.	    servaddr.sin_port = htons(SERV_PORT);                                       //指定端口号   
63.	  
64.	    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));             //绑定  
65.	  
66.	    Listen(listenfd, 128);                                                      //设置同一时刻链接服务器上限数  
67.	  
68.	    printf("Accepting client connect ...\n");  
69.	  
70.	    while (1) {  
71.	        cliaddr_len = sizeof(cliaddr);  
72.	        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);   //阻塞监听客户端链接请求  
73.	        ts[i].cliaddr = cliaddr;  
74.	        ts[i].connfd = connfd;  
75.	  
76.	        pthread_create(&tid, NULL, do_work, (void*)&ts[i]);  
77.	        pthread_detach(tid);                                                    //子线程分离,防止僵线程产生.  
78.	        i++;  
79.	    }  
80.	  
81.	    return 0;  
82.	}  

编译运行，结果如下：

多进程占用资源大，但是一个进程挂了不会影响另一个。这与多线程刚好相反，多线程服务器不稳定。