一.思路
实现一个服务器可以连接多个客户端，每当accept函数等待到客户端进行连接时 就创建一个子进程;
核心思路：让accept循环阻塞等待客户端，每当有客户端连接时就fork子进程，让子进程去和客户端进行通信，父进程用于监听并使用信号捕捉回收子进程；(子进程关闭用于监听的套接字lfd，父进程关闭用于通信的cfd)
二.多进程并发服务器代码实现:
1.利用while 和 accept 阻塞等待客户端连接，一旦有一个客户端连接上，就创建一个新的子进程执行服务逻辑。
2.子进程结束时，利用信号捕捉函数sigaction回收子进程
3.注意，当主进程阻塞在accept时，若子进程发出信号，accept会被打断(一系列慢速系统调用的特点)从而直接执行接下来的fork函数，这就会导致一个子进程刚好被回收后，又会产生一个新的子进程，为了防止这种情况，使用again和goto维护accept，防止被信号打断后产生错误。
1 #include<iostream>
2 #include<unistd.h>
3 #include<sys/socket.h>
4 #include<arpa/inet.h>
5 #include<signal.h>
6 #include<sys/wait.h>
7 using namespace std;
8
9 void huidiao(int signo)
10 {
11 pid_t pid;
12 while((pid = waitpid(-1,NULL,WNOHANG))>0)
13 {
14 cout<<pid<<endl;
15 }
16 return ;
17 }
18
19 int main()
20 {
21 struct sigaction act;
22 act.sa_handler = huidiao; sigemptyset(&act.sa_mask);
24 act.sa_flags = 0;
25 sigaction(SIGCHLD,&act,NULL);
26 //socket bind listen accept
27 int fd = socket(AF_INET,SOCK_STREAM,0);
28 struct sockaddr_in serveraddr,clientaddr;
29 serveraddr.sin_family = AF_INET;
30 serveraddr.sin_port = htons(9876);
31 serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
32 bind(fd,(struct sockaddr*)&serveraddr,sizeof(serveraddr));
33
34 listen(fd,128);
35
36 socklen_t clientaddr_len = sizeof(clientaddr);
37 int sfd,flag;
38 while(true)
39 {
40 sfd = accept(fd,(struct sockaddr*)&clientaddr,&clientaddr_len);
41 flag = fork();
42
43 if(flag == 0)
44 { close(fd);
46 break;
47 }
48 else if(flag <0)
49 {
50 exit(1);
51 }
52 else if(flag>0)
53 {
54 close(sfd);
55 continue;
56 }
57 }
58
59 if(flag == 0)
60 {
61 for(;;)
62 {
63 char buf[1024];
64 int n = read(sfd,buf,sizeof(buf));
65 if(n==0)
66 { close(sfd);
68 cout<<"jieshu"<<endl;
69 exit(0);
70 }
71 for(int i = 0;i<n;i++)
72 {
73 buf[i] = toupper(buf[i]);
74 }
75 write(STDOUT_FILENO,buf,n);
76 write(sfd,buf,n);
77 }
78 }
79 return 0;
80 }
三. 多线程并发服务器代码实现：
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.}
