简单的TCP网络步伐：英译汉服务器

一、服务器的初始化

下面先容步伐中用到的socket API,这些函数都在sys/socket.h中。
1.创建套接字

socket()：

   ⭐参数先容：
  

• socket()打开一个网络通讯端口,如果乐成的话,就像open()一样返回一个文件描述符;
  
• 应用步伐可以像读写文件一样用read/write在网络上收发数据;
  
• 如果socket()调用堕落则返回-1;
  
• 对于IPv4, family参数指定为AF_INET;
  
• 对于TCP协议,type参数指定为SOCK_STREAM, 表示面向流的传输协议
  
• protocol参数的先容从略,指定为0即可。
  

1. class TcpServer
2. {
3. public:
4.     TcpServer()
5.         : _sockfd(defaultsockfd)
6.     {
7.     }
8.     void Init()
9.     {
10.         _sockfd = socket(AF_INET, SOCK_STREAM, 0);
11.         if (_sockfd < 0) // 创建套接字失败
12.         {
13.             lg(Fatal, "create socket, errno : %d, errstring: %s", errno, strerror(errno));
14.             exit(SocketError);
15.         }
16.         lg(Info, "create socket success, socket: %d", _sockfd);
17.     }
18.     ~TcpServer()
19.     {
20.         close(_sockfd);
21.     }
23. private:
24.     int _sockfd; // 套接字
25. };

复制代码

2.绑定端口号和ip

bind()：

   ⭐参数先容：
  

• 服务器步伐所监听的网络地点和端口号通常是固定不变的,客户端步伐得知服务器步伐的地点和端口号后 就可以向服务器发起毗连; 服务器必要调用bind绑定一个固定的网络地点和端口号;
  
• bind()乐成返回0,失败返回-1。
  
• bind()的作用是将参数sockfd和myaddr绑定在一起, 使sockfd这个用于网络通讯的文件描述符监听 myaddr所描述的地点和端口号;
  
• 前面讲过,struct sockaddr *是一个通用指针类型,myaddr参数现实上可以接受多种协议的sockaddr结 构体,而它们的长度各不相同,所以必要第三个参数addrlen指定布局体的长度;
  

  我们先来看看地点转换函数
本节只先容基于IPv4的socket网络编程,sockaddr_in中的成员struct in_addr sin_addr表示32位 的IP 地点 但是我们通常用点分十进制的字符串表示IP 地点,以下函数可以在字符串表示 和in_addr表示之间转换;
字符串转in_addr的函数:

in_addr转字符串的函数:

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void *addrptr。inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是 否必要调用者手动释放呢?

man手册上说, inet_ntoa函数, 是把这个返回结果放到了静态存储区. 这个时候不必要我们手动举行释放. 那么问题来了, 如果我们调用多次这个函数, 会有什么样的效果呢? 参见如下代码:

因为inet_ntoa把结果放到自己内部的一个静态存储区, 如许第二次调用时的结果会覆盖掉上一次的结果

• 思考: 如果有多个线程调用 inet_ntoa, 是否会出现异常情况呢?
  
• 在APUE中, 明确提出inet_ntoa不是线程安全的函数;
  
• 但是在centos7上测试, 并没有出现问题, 可能内部的实现加了互斥锁;
  
• 自己写步伐验证一下在自己的机器上inet_ntoa是否会出现多线程的问题;
  
• 在多线程情况下, 保举利用inet_ntop, 这个函数由调用者提供一个缓冲区保存结果, 可以规避线程安全问 题;
  

我们的步伐中对myaddr参数是如许初始化的：

   

• 1. 将整个布局体清零；
  
• 2. 设置地点类型为AF_INET；
  
• 3. 网络地点为0.0.0.0, 这个宏表示本地的恣意IP地点,因为服务器可能有多个网卡,每个网卡也可能绑定多个IP 地点, 如许设置可以在所有的IP地点上监听,直到与某个客户端建立了毗连时才确定下来到底用 哪个IP 地点；
  

1. class TcpServer
2. {
3. public:
4.     TcpServer(const uint16_t& port, const string& ip = defaultip)
5.         : _sockfd(defaultsockfd)
6.         , _port(port)
7.         , _ip(ip)
8.     {
9.     }
10.     void Init()
11.     {
12.         // 1.创建套接字
13.         _sockfd = socket(AF_INET, SOCK_STREAM, 0);
14.         if (_sockfd < 0) // 创建套接字失败
15.         {
16.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
17.             exit(SocketError);
18.         }
19.         lg(Info, "create socket success, socket: %d", _sockfd);
21.         //2.绑定端口号
22.         // 使用这个结构体需要包头文件
23.         struct sockaddr_in local;
24.         memset(&local, 0, sizeof(local));
25.         local.sin_family = AF_INET;
26.         // 转化为网络序列
27.         local.sin_port = htons(_port);
28.         // 字符串转化为点时分形式的ip
29.         inet_aton(_ip.c_str(), &(local.sin_addr));
30.         //此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
31.         int n = bind(_sockfd, (const struct sockaddr*)&local, sizeof(local));
32.         if(n < 0)
33.         {
34.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
35.             exit(BindError);
36.         }
37.     }
38.     ~TcpServer()
39.     {
40.         close(_sockfd);
41.     }
43. private:
44.     int _sockfd; // 套接字
45.     uint16_t _port; // 端口号
46.     string _ip; // ip地址
47. };

复制代码

3.设置监听状态

listen():

   

• listen()声明sockfd处于监听状态, 并且最多允许有backlog个客户端处于毗连等待状态, 如果接收到更多 的毗连请求就忽略, 这里设置不会太大(一样平常是5);
  
• listen()乐成返回0,失败返回-1;
  

1. #pragma onec
3. #include <iostream>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <cstdlib>
8. #include <cstring>
9. #include <arpa/inet.h>
10. #include <netinet/in.h>
11. #include "log.hpp"
12. using namespace std;
14. const int defaultsockfd = -1;
15. const string defaultip = "0.0.0.0";
16. const int backlog = 10; // 但是一般不要设置的太大
17. Log lg;
19. enum
20. {
21.     UsageError = 1,
22.     SocketError = 2,
23.     BindError = 3,
24.     ListenError = 4
25. };
27. class TcpServer
28. {
29. public:
30.     TcpServer(const uint16_t& port, const string& ip = defaultip)
31.         : _sockfd(defaultsockfd)
32.         , _port(port)
33.         , _ip(ip)
34.     {
35.     }
36.     void Init()
37.     {
38.         // 1.创建套接字
39.         _sockfd = socket(AF_INET, SOCK_STREAM, 0);
40.         if (_sockfd < 0) // 创建套接字失败
41.         {
42.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
43.             exit(SocketError);
44.         }
45.         lg(Info, "create socket success, socket: %d", _sockfd);
47.         //2.绑定端口号
48.         // 使用这个结构体需要包头文件
49.         struct sockaddr_in local;
50.         memset(&local, 0, sizeof(local));
51.         local.sin_family = AF_INET;
52.         // 转化为网络序列
53.         local.sin_port = htons(_port);
54.         // 字符串转化为点时分形式的ip
55.         inet_aton(_ip.c_str(), &(local.sin_addr));
56.         //此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
57.         int n = bind(_sockfd, (const struct sockaddr*)&local, sizeof(local));
58.         if(n < 0)
59.         {
60.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
61.             exit(BindError);
62.         }
63.         lg(Info, "bind socket success, socket: %d", _sockfd);
66.         // 3.设置监听状态
67.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
68.         if (listen(_sockfd, backlog) < 0)
69.         {
70.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
71.             exit(ListenError);
72.         }   
73.         lg(Info, "bind socket success, socket: %d", _sockfd);
75.         
76.     }
77.     ~TcpServer()
78.     {
79.         close(_sockfd);
80.     }
82. private:
83.     int _sockfd; // 套接字
84.     uint16_t _port; // 端口号
85.     string _ip; // ip地址
86. };

复制代码

4.设置服务器的端口号和ip

未来我们向让用户设置端口号，所以我们可以在main函数中借助命令行参数通报，对于ip我们就直接利用默认的ip参数"0.0.0.0"即可。

1. #include "TcpServer.hpp"
3. #include <memory>
5. void Usage(std::string proc)
6. {
7.     std::cout << "\n\rUsage: " << proc << " port[1024+]\n" << std::endl;
8. }
10. // ./tcpserver 8080
11. int main(int argc, char* argv[])
12. {
13.     if(argc != 2)
14.     {
15.         Usage(argv[0]);
16.         exit(UsageError);
17.     }
18.     uint16_t port = std::stoi(argv[1]);
19.     unique_ptr<TcpServer> tcpSvr(new TcpServer(port));
20.     tcpSvr->Init();
21.     //tcpSvr->Start();
22.     return 0;
23. }

复制代码

现在我们就可以来测试一下啦！

二、服务器的运行

1.建立新链接

accept()：

   

• 三次握手完成后, 服务器调用accept()接受毗连;
  
• 如果服务器调用accept()时还没有客户端的毗连请求,就阻塞等待直到有客户端毗连上来;
  
• addr是一个传出参数,accept()返回时传出客户端的地点和端口号;
  
• 如果给addr参数传NULL,表示不关心客户端的地点;
  
• addrlen参数是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区addr的长度 以避免缓冲区溢出问题, 传出的是客户端地点布局体的现实长度(有可能没有占满调用者提供的缓冲区);
  
• 获取毗连乐成返回接收到的套接字的文件描述符，获取毗连失败返回-1，同时错误码会被设置。
  

  ⭐accept函数返回的套接字是什么？
调用accept函数获取毗连时，是从监听套接字当中获取的。如果accept函数获取毗连乐成，此时会返回接收到的套接字对应的文件描述符。
⭐监听套接字与accept函数返回的套接字的作用：
   

• 监听套接字：用于获取客户端发来的毗连请求。accept函数会不断从监听套接字当中获取新毗连。
  
• accept函数返回的套接字：用于为本次accept获取到的毗连提供服务。监听套接字的任务只是不断获取新毗连，类似于餐厅门口的迎宾，而真正为这些毗连提供服务的套接字是accept函数返回的套接字，类似于餐厅的服务员，而不是监听套接字。
  

  所以初始化TCP服务器时创建的套接字应该叫做监听套接字。为了表明寓意，我们将代码中套接字的名字由_sockfd改为_listensocket，如许写着更清楚明了。

1. #pragma onec
3. #include <iostream>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <cstdlib>
8. #include <cstring>
9. #include <arpa/inet.h>
10. #include <netinet/in.h>
11. #include "log.hpp"
12. using namespace std;
14. const int defaultsockfd = -1;
15. const string defaultip = "0.0.0.0";
16. const int backlog = 10; // 但是一般不要设置的太大
17. Log lg;
19. enum
20. {
21.     UsageError = 1,
22.     SocketError = 2,
23.     BindError = 3,
24.     ListenError = 4
25. };
27. class TcpServer
28. {
29. public:
30.     TcpServer(const uint16_t& port, const string& ip = defaultip)
31.         : _listensocket(defaultsockfd)
32.         , _port(port)
33.         , _ip(ip)
34.     {
35.     }
36.     void Init()
37.     {
38.         // 1.创建套接字
39.         _listensocket = socket(AF_INET, SOCK_STREAM, 0);
40.         if (_listensocket < 0) // 创建套接字失败
41.         {
42.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
43.             exit(SocketError);
44.         }
45.         lg(Info, "create socket success, socket: %d", _listensocket);
47.         //2.绑定端口号
48.         // 使用这个结构体需要包头文件
49.         struct sockaddr_in local;
50.         memset(&local, 0, sizeof(local));
51.         local.sin_family = AF_INET;
52.         // 转化为网络序列
53.         local.sin_port = htons(_port);
54.         // 字符串转化为点时分形式的ip
55.         inet_aton(_ip.c_str(), &(local.sin_addr));
56.         //此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
57.         int n = bind(_listensocket, (const struct sockaddr*)&local, sizeof(local));
58.         if(n < 0)
59.         {
60.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
61.             exit(BindError);
62.         }
63.         lg(Info, "bind socket success, socket: %d", _listensocket);
66.         // 3.设置监听状态
67.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
68.         if (listen(_listensocket, backlog) < 0)
69.         {
70.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
71.             exit(ListenError);
72.         }   
73.         lg(Info, "bind socket success, socket: %d", _listensocket);
74.     }
76.     void Start()
77.     {
78.         lg(Info, "tcpServer is running....");
79.         for (;;)
80.         {
81.             // 1. 获取新连接 - 知道客户端的ip地址和端口号
82.             struct sockaddr_in client;
83.             socklen_t len = sizeof(client);
84.             // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾
85.             // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
86.             int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
87.             if (sockfd < 0)
88.             {
89.                 // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
90.                 lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
91.                 continue; // 所以这里使用continue
92.             }
93.             lg(Info, "get a new link..., sockfd: %d", sockfd);
94.         }
95.     }
97.     ~TcpServer()
98.     {
99.         close(_listensocket);
100.     }
102. private:
103.     int _listensocket; // 套接字
104.     uint16_t _port; // 端口号
105.     string _ip; // ip地址
106. };

复制代码

此时我们想来测试一下，但是我们的客户端还没有写，咋办呢？

1. telnet 127.0.0.1 8888

复制代码

是一个网络诊断命令，它的作用是尝试通过Telnet协议毗连到本田主机（本机）的8888端口。这里：

• telnet 是命令自己，用于举行长途登录和管理。
  
• 127.0.0.1 是IPv4环回地点，指向本地盘算机。利用这个地点，你现实上是尝试毗连到你自己的机器。
  
• 8888 是端口号，很多应用步伐和服务会监听特定的端口来接收数据。8888是一个常见的测试或备用端口。
  

上一个知识点我们提到udp它是不能绑定我们云服务器的公网ip的，但是绑定本地环回127.0.0.1可以的，我们看看tcp可不可以。

答案是也不可以绑定我们云服务器的公网ip的。那么绑定本地环回127.0.0.1可以嘛？

所以为了能毗连我们的与服务器的公网ip，我们将服务器的ip设置为0.0.0.0，这就意味着该tcp服务器可以读取服务器任何一个ip，保证一定能毗连上我们的服务器。
2.举行通讯

建立通讯我们起首就要获取到给服务器发送请求的端口号和ip地点

我们来测试一下，看看此时能不能接收到客户端的端口号和ip地点。

此时我们就能知道我们确实有毗连到我们的服务器了。
⭐注意：我们利用的云服务默认是将端口号禁用了，我们必要在云服务器后台将我们的端口号取消禁用，否则的话我们只能在本地通讯，我们可以利用windows毗连一下服务器，看看出现上面情况。

所以就必要前去服务器举行安全组的设置。

随后我们再来测试一下哈。

同时我们这里还有一个问题，我们之前的端口号和网络序列都要转成网络序列，我们都利用了相应的接口，但是为什么用户发送来的数据，我们不必要手动调用接口转化为网络序列呢？在利用套接字通讯的时候，会默认将用户发送来的数据转化成网络序列，而端口号和网络序列比力特殊，必要写给操作系统的，所以必要我们自己去转的。现在我们就可以举行通讯了，由于tcp是基于数据流的，所以直接利用write和read接口即可。

1. void Service( int sockfd,const string& ip,const uint16_t& port)
2. {
3.     char buffer[4096];
4.     while(true)
5.     {
6.         // 读取用户发送的请求
7.         ssize_t n = read(sockfd, buffer, sizeof(buffer));
8.         if(n > 0)
9.         {
10.             buffer[n] = '\0';
11.             cout << "client says: " << buffer << endl;
12.             string echo_string = "tcpserver echo# ";
13.             echo_string += buffer;
15.             write(sockfd, echo_string.c_str(), echo_string.size());
16.         }
17.         
18.     }
19. }

复制代码

我们来运行一下：

此时我们发现就可以通讯啦！！！但是上面的客户端不是我们写的，我们自己来写一个。
三、客户端的初始化

1.创建套接字

1. int sockfd = socket(AF_INET, SOCK_STREAM, 0);
2. if(sockfd < 0)
3. {
4.     cerr << "socket error" << endl;
5. }

复制代码

2.绑定端口号和ip

由于客户端不必要固定的端口号,因此不必调用bind(),客户端的端口号由内核自动分配
注意:

• 客户端不是不允许调用bind(), 只是没有必要调用bind()固定一个端口号. 否则如果在同一台机器上启动 多个客户端, 就会出现端口号被占用导致不能正确建立毗连;
  
• 服务器也不是必须调用bind(), 但如果服务器不调用bind(), 内核会自动给服务器分配监听端口, 每次启动 服务器时端口号都不一样, 客户端要毗连服务器就会遇到麻烦;
  

测试多个毗连的情况
再启动一个客户端, 尝试毗连服务器, 发现第二个客户端, 不能正确的和服务器举行通讯. 分析缘故原由, 是因为我们accecpt了一个请求之后, 就在一直while循环尝试read, 没有继续调用到accecpt, 导致不能接 受新的请求. 我们当前的这个TCP, 只能处置惩罚一个毗连, 这是不科学的.后面我们会改成多线程版本的。
3.毗连服务器

connect：

   

• 客户端必要调用connect()毗连服务器;
  
• connect和bind的参数形式同等, 区别在于bind的参数是自己的地点, 而connect的参数是对方的地点;
  
• connect()乐成返回0,堕落返回-1;
  

1. #include <iostream>
2. #include <arpa/inet.h>
3. #include <netinet/in.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <string.h>
9. using namespace std;
10. void Usage(const string &proc)
11. {
12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
13.          << endl;
14. }
16. // ./tcpclient serverip serverport
17. int main(int argc, char *argv[])
18. {
19.     if (argc != 3)
20.     {
21.         Usage(argv[0]);
22.         exit(1);
23.     }
24.     string serverip = argv[1];
25.     uint16_t serverport = stoi(argv[2]);
27.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
28.     if (sockfd < 0)
29.     {
30.         cerr << "socket error" << endl;
31.     }
33.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
34.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
35.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
36.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
37.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
38.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
39.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
40.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
42.     // 可是客户端此时不知道服务器的ip和端口号
43.     // 使用命令行参数来解决
44.     struct sockaddr_in server;
45.     memset(&server, 0, sizeof(server));
46.     server.sin_family = AF_INET;
47.     server.sin_port = htons(serverport);
48.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
49.    
50.     int n = connect(sockfd, (const struct sockaddr*)&server, sizeof(server));
51.     if(n < 0)
52.     {
53.         cerr << "connect error..." << endl;
54.         exit(2);
55.     }
56.     close(sockfd);
57.     return 0;
58. }

复制代码

4.给服务端发送信息

1. string message;
2. while (true)
3. {
4.     cout << "Please Enter# ";
5.     getline(cin, message);
6.     // 发送数据
7.     int n = write(sockfd, message.c_str(), message.size());
8.     // 读取数据
9.     char inbuffer[4096];
10.     n = read(sockfd, inbuffer, sizeof(inbuffer));
11.     if (n > 0)
12.     {
13.         inbuffer[n] = 0;
14.         std::cout << inbuffer << std::endl;
15.     }
16. }

复制代码

此时我们的服务器和客户端就可以运行啦！

四、一些安全问题的处置惩罚

1.客户端直接退出，服务器处置惩罚

客户端直接退出，服务器会怎么样，服务器读取不到客户端发来的请求，此时read返回值为0，应该关闭网络文件描述符，剩余一种情况就是读取失败，我们直接打印警告日志信息。

1. void Service( int sockfd,const string& ip,const uint16_t& port)
2. {
3.     char buffer[4096];
4.     while(true)
5.     {
6.         // 读取用户发送的请求
7.         ssize_t n = read(sockfd, buffer, sizeof(buffer));
8.         if(n > 0)
9.         {
10.             buffer[n] = '\0';
11.             cout << "client says: " << buffer << endl;
12.             string echo_string = "tcpserver echo# ";
13.             echo_string += buffer;
15.             write(sockfd, echo_string.c_str(), echo_string.size());
16.         }
17.         else if(n == 0)
18.         {
19.             // 此时需要关闭文件描述符
20.             // 我们在返回调用该函数的地方该关闭文件描述符
21.             lg(Info, "%s:%d quit, server close sockfd: %d", ip.c_str(), port, sockfd);
22.             break;
23.         }
24.         else
25.         {
26.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
27.             break;
28.         }
29.     }
30. }

复制代码

运行一下：

2.单进程服务器，多个客户端毗连

我们直接来看现象

然后我们让客户端分别写一条数据

我们发现此时客户端1能乐成发送数据并接收数据，但是客户端2不行，随后我们来关闭客户端1.

此时客户端1一退出，客户端2立马毗连，并且将刚刚的数据发送给服务器并乐成并接收数据。为什么呢？因为此时我们的服务器是一个单进程，一个服务器为一个客户端提供服务时，此时由于我们写的是while循环，此时必须等客户端1退出，才气关闭文件描述符(让)，然后这个服务器才会空闲，然后此时客户端2才气建立毗连，服务器才会提供服务。此时就相当于餐厅只有一个服务员，等这个服务员服务好了客户端1，才气接待客户端2，所以我们这里必要改一下，让多个客户端共同利用。

1. void Start()
2. {
3.     lg(Info, "tcpServer is running....");
4.     for (;;)
5.     {
6.         // 1. 获取新连接 - 知道客户端的ip地址和端口号
7.         struct sockaddr_in client;
8.         socklen_t len = sizeof(client);
9.         // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾
10.         // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
11.         int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
12.         if (sockfd < 0)
13.         {
14.             // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
15.             lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
16.             continue; // 所以这里使用continue
17.         }
18.         lg(Info, "get a new link..., sockfd: %d", sockfd);
20.         // 2.根据新连接来进行通信
21.         // 获取客户端的ip地址和端口号
22.         uint16_t clientport = ntohs(client.sin_port);
23.         char clientip[32];
24.         // 转化成主机序列
25.         inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
26.         cout << "clientport: " << clientport << ", clientip: " << clientip << endl;
27.         // 单进程版本
28.         // Service(sockfd, clientip, clientport);
29.         // close(sockfd);
31.         // 多进程版本
32.         pid_t id = fork();
33.         if(id == 0)
34.         {
35.             // 子进程
36.             // 子进程会继承父进程的文件描述符
37.             close(_listensocket);
38.             if(fork() > 0) exit(0); // 此时子进程退出了
39.             Service(sockfd, clientip, clientport); // 孙子进程执行
40.             // 对于孙子进程,它的父进程已经退出了,此时孙子进程被系统领养
41.             close(sockfd);
42.             exit(0);
43.         }
44.         // 父进程
45.         // 文件描述符使用的是引用计数
46.         // 关闭父进程的文件描述符不会影响子进程
47.         close(sockfd);
48.         // 这里等待回收子进程的方式不能是阻塞等待
49.         pid_t rid = waitpid(id, nullptr, 0);
50.     }
51. }

复制代码

此时我们再来测试一下：

此时我们无论来多少个客户端，我们的服务器都能解决！！！除了上面一种方法，我们还可以利用信号的方式，注意利用这个必要带上头文件<signal.h>

1. signal(SIGVHLD, SIG_IGN);

复制代码

如果我们此时来了一大批客户，那么此时就会为每一个客户创建一个进程，而我们之前学过，创建子进程的本钱是非常大的，所以此时我们可以利用多线程来解决。

1. #pragma onec
3. #include <iostream>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <cstdlib>
8. #include <cstring>
9. #include <arpa/inet.h>
10. #include <netinet/in.h>
11. #include <sys/wait.h>
12. #include <pthread.h>
13. #include "log.hpp"
14. using namespace std;
16. const int defaultsockfd = -1;
17. const string defaultip = "0.0.0.0";
18. const int backlog = 10; // 但是一般不要设置的太大
19. Log lg;
21. enum
22. {
23.     UsageError = 1,
24.     SocketError = 2,
25.     BindError = 3,
26.     ListenError = 4
27. };
29. class TcpServer;
31. class ThreadData
32. {
33. public:
34.     ThreadData(int fd, const std::string &ip, const uint16_t &p, TcpServer *t)
35.     : sockfd(fd)
36.     , clientip(ip)
37.     , clientport(p)
38.     , tsvr(t)
39.     {}
40. public:
41.     int sockfd;
42.     string clientip;
43.     uint16_t clientport;
44.     TcpServer *tsvr;
45. };
48. class TcpServer
49. {
50. public:
51.     TcpServer(const uint16_t &port, const string &ip = defaultip)
52.         : _listensocket(defaultsockfd), _port(port), _ip(ip)
53.     {
54.     }
55.     void Init()
56.     {
57.         // 1.创建套接字
58.         _listensocket = socket(AF_INET, SOCK_STREAM, 0);
59.         if (_listensocket < 0) // 创建套接字失败
60.         {
61.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
62.             exit(SocketError);
63.         }
64.         lg(Info, "create socket success, listensocket: %d", _listensocket);
66.         // 2.绑定端口号
67.         //  使用这个结构体需要包头文件
68.         struct sockaddr_in local;
69.         memset(&local, 0, sizeof(local));
70.         local.sin_family = AF_INET;
71.         // 转化为网络序列
72.         local.sin_port = htons(_port);
73.         // 字符串转化为点时分形式的ip
74.         inet_aton(_ip.c_str(), &(local.sin_addr));
75.         // local.sin_addr.s_addr = INADDR_ANY;
76.         // 此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
77.         int n = bind(_listensocket, (const struct sockaddr *)&local, sizeof(local));
78.         if (n < 0)
79.         {
80.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
81.             exit(BindError);
82.         }
83.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
85.         // 3.设置监听状态
86.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
87.         if (listen(_listensocket, backlog) < 0)
88.         {
89.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
90.             exit(ListenError);
91.         }
92.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
93.     }
95.     void Start()
96.     {
97.         lg(Info, "tcpServer is running....");
98.         for (;;)
99.         {
100.             // 1. 获取新连接 - 知道客户端的ip地址和端口号
101.             struct sockaddr_in client;
102.             socklen_t len = sizeof(client);
103.             // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾
104.             // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
105.             int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
106.             if (sockfd < 0)
107.             {
108.                 // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
109.                 lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
110.                 continue;                                                                      // 所以这里使用continue
111.             }
112.             lg(Info, "get a new link..., sockfd: %d", sockfd);
114.             // 2.根据新连接来进行通信
115.             // 获取客户端的ip地址和端口号
116.             uint16_t clientport = ntohs(client.sin_port);
117.             char clientip[32];
118.             // 转化成主机序列
119.             inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
120.             cout << "clientport: " << clientport << ", clientip: " << clientip << endl;
121.             // 单进程版本
122.             // Service(sockfd, clientip, clientport);
123.             // close(sockfd);
125.             // 多进程版本
126.             // pid_t id = fork();
127.             // if(id == 0)
128.             //{
129.                 // 子进程
130.                 // 子进程会继承父进程的文件描述符
131.                 // close(_listensocket);
132.                 // if(fork() > 0) exit(0); // 此时子进程退出了
133.                 // Service(sockfd, clientip, clientport); // 孙子进程执行
134.                 // 对于孙子进程,它的父进程已经退出了,此时孙子进程被系统领养
135.                 // close(sockfd);
136.                 // exit(0);
137.             //}
138.             // 父进程
139.             // 文件描述符使用的是引用计数
140.             // 关闭父进程的文件描述符不会影响子进程
141.             // close(sockfd);
142.             // 这里等待回收子进程的方式不能是阻塞等待
143.             // pid_t rid = waitpid(id, nullptr, 0);
145.             // 多线程版本
146.             ThreadData* td = new ThreadData(sockfd, clientip, clientport, this);
147.             pthread_t tid;
148.             pthread_create(&tid, nullptr, Rountine, td);
150.             // 这里不用join,因为它是阻塞等待
151.             // pthread_join(tid, nullptr);
153.         }
154.     }
156.     static void* Rountine(void* args)
157.     {
158.         pthread_detach(pthread_self()); // 设置分离状态
159.         // 文件描述符共享,此时我们就不能关闭
160.         // 多线程只拥有tcb
161.         ThreadData *td = static_cast<ThreadData *>(args);
162.         // static静态成员方法无法使用非静态成员方法和成员
163.         // 1.将Service放到TcpServer类外
164.         // 2.将当前对象的this指针传入
165.         td->tsvr->Service(td->sockfd, td->clientip, td->clientport);
166.         delete td;
167.         return nullptr;
168.     }
170.     void Service(int sockfd, const string &ip, const uint16_t &port)
171.     {
172.         char buffer[4096];
173.         while (true)
174.         {
175.             // 读取用户发送的请求
176.             ssize_t n = read(sockfd, buffer, sizeof(buffer));
177.             if (n > 0)
178.             {
179.                 buffer[n] = '\0';
180.                 cout << "client says: " << buffer << endl;
181.                 string echo_string = "tcpserver echo# ";
182.                 echo_string += buffer;
184.                 write(sockfd, echo_string.c_str(), echo_string.size());
185.             }
186.             else if (n == 0)
187.             {
188.                 // 此时需要关闭文件描述符
189.                 lg(Info, "%s:%d quit, server close sockfd: %d", ip.c_str(), port, sockfd);
190.                 break;
191.             }
192.             else
193.             {
194.                 lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
195.                 break;
196.             }
197.         }
198.     }
199.     ~TcpServer()
200.     {
201.         close(_listensocket);
202.     }
204. private:
205.     int _listensocket; // 套接字
206.     uint16_t _port;    // 端口号
207.     string _ip;        // ip地址
208. };

复制代码

此时我们再来运行一下：

此时我们是每次来一个客户端，然后就创建一个线程，也有点消耗，毕竟俺们每次都要创建，我们来写一个线程池，一开始我们就创建一大批进程，来一个客户端直接给它一个线程。并且我们上面的代码还存在一个问题，我们的服务是一直服务用户请求的，只要客户端不退，即使客户端不发信息，我们为该用户创建的线程也不会销毁，如许就会导致系统中的线程越来越多，直接来写代码。

1. #pragma once
3. #include <iostream>
4. #include <vector>
5. #include <string>
6. #include <queue>
7. #include <pthread.h>
8. #include <unistd.h>
10. struct ThreadInfo
11. {
12.     pthread_t tid;
13.     std::string name;
14. };
16. static const int defalutnum = 10;
18. template <class T>
19. class ThreadPool
20. {
21. public:
22.     void Lock()
23.     {
24.         pthread_mutex_lock(&mutex_);
25.     }
26.     void Unlock()
27.     {
28.         pthread_mutex_unlock(&mutex_);
29.     }
30.     void Wakeup()
31.     {
32.         pthread_cond_signal(&cond_);
33.     }
34.     void ThreadSleep()
35.     {
36.         pthread_cond_wait(&cond_, &mutex_);
37.     }
38.     bool IsQueueEmpty()
39.     {
40.         return tasks_.empty();
41.     }
42.     std::string GetThreadName(pthread_t tid)
43.     {
44.         for (const auto &ti : threads_)
45.         {
46.             if (ti.tid == tid)
47.                 return ti.name;
48.         }
49.         return "None";
50.     }
52. public:
53.     static void *HandlerTask(void *args)
54.     {
55.         ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
56.         std::string name = tp->GetThreadName(pthread_self());
57.         while (true)
58.         {
59.             tp->Lock();
61.             while (tp->IsQueueEmpty())
62.             {
63.                 tp->ThreadSleep();
64.             }
65.             T t = tp->Pop();
66.             tp->Unlock();
68.             t();
69.         }
70.     }
71.     void Start()
72.     {
73.         int num = threads_.size();
74.         for (int i = 0; i < num; i++)
75.         {
76.             threads_[i].name = "thread-" + std::to_string(i + 1);
77.             pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
78.         }
79.     }
80.     T Pop()
81.     {
82.         T t = tasks_.front();
83.         tasks_.pop();
84.         return t;
85.     }
86.     void Push(const T &t)
87.     {
88.         Lock();
89.         tasks_.push(t);
90.         Wakeup();
91.         Unlock();
92.     }
93.     static ThreadPool<T> *GetInstance()
94.     {
95.         if (nullptr == tp_) // ???
96.         {
97.             pthread_mutex_lock(&lock_);
98.             if (nullptr == tp_)
99.             {
100.                 std::cout << "log: singleton create done first!" << std::endl;
101.                 tp_ = new ThreadPool<T>();
102.             }
103.             pthread_mutex_unlock(&lock_);
104.         }
106.         return tp_;
107.     }
109. private:
110.     ThreadPool(int num = defalutnum) : threads_(num)
111.     {
112.         pthread_mutex_init(&mutex_, nullptr);
113.         pthread_cond_init(&cond_, nullptr);
114.     }
115.     ~ThreadPool()
116.     {
117.         pthread_mutex_destroy(&mutex_);
118.         pthread_cond_destroy(&cond_);
119.     }
120.     ThreadPool(const ThreadPool<T> &) = delete;
121.     const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
122. private:
123.     std::vector<ThreadInfo> threads_;
124.     std::queue<T> tasks_;
126.     pthread_mutex_t mutex_;
127.     pthread_cond_t cond_;
129.     static ThreadPool<T> *tp_;
130.     static pthread_mutex_t lock_;
131. };
133. template <class T>
134. ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;
136. template <class T>
137. pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

复制代码

我们上面实现的线程池是一个单例模式，只允许创建一个对象，并且我们的线程池可以发送任务，它可以处置惩罚好，所以我们可以把服务器接收到的任务给我们的线程池，所以我们再来写一个任务。

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include "log.hpp"
5. #include <string.h>
7. extern Log lg;
8. using namespace std;
10. class Task
11. {
12. public:
13.     Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
14.         : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
15.     {
16.     }
17.     void run()
18.     {
19.         char buffer[4096];
21.         // 读取用户发送的请求
22.         ssize_t n = read(sockfd_, buffer, sizeof(buffer));
23.         if (n > 0)
24.         {
25.             buffer[n] = '\0';
26.             cout << "client says: " << buffer << endl;
27.             string echo_string = "tcpserver echo# ";
28.             echo_string += buffer;
30.             write(sockfd_, echo_string.c_str(), echo_string.size());
31.         }
32.         else if (n == 0)
33.         {
34.             // 此时需要关闭文件描述符
35.             lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
36.         }
37.         else
38.         {
39.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
40.         }
41.         close(sockfd_);
42.     }
43.     void operator()()
44.     {
45.         run();
46.     }
47.     ~Task()
48.     {
49.     }
51. private:
52.     int sockfd_;
53.     std::string clientip_;
54.     uint16_t clientport_;
55. };

复制代码

此时对于客户端，我们让它输入一次信息就不要再输入了，你要是再输入就必要重新毗连服务器。

1. #include <iostream>
2. #include <arpa/inet.h>
3. #include <netinet/in.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <string.h>
9. using namespace std;
10. void Usage(const string &proc)
11. {
12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
13.          << endl;
14. }
16. // ./tcpclient serverip serverport
17. int main(int argc, char *argv[])
18. {
19.     if (argc != 3)
20.     {
21.         Usage(argv[0]);
22.         exit(1);
23.     }
24.     string serverip = argv[1];
25.     uint16_t serverport = stoi(argv[2]);
27.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
28.     if (sockfd < 0)
29.     {
30.         cerr << "socket error" << endl;
31.     }
33.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
34.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
35.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
36.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
37.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
38.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
39.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
40.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
42.     // 可是客户端此时不知道服务器的ip和端口号
43.     // 使用命令行参数来解决
44.     struct sockaddr_in server;
45.     memset(&server, 0, sizeof(server));
46.     server.sin_family = AF_INET;
47.     server.sin_port = htons(serverport);
48.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
50.     int n = connect(sockfd, (const struct sockaddr *)&server, sizeof(server));
51.     if (n < 0)
52.     {
53.         cerr << "connect error..." << endl;
54.         exit(2);
55.     }
57.     string message;
58.    
59.    
60.         cout << "Please Enter# ";
61.         getline(cin, message);
62.         // 发送数据
63.         n = write(sockfd, message.c_str(), message.size());
64.         // 读取数据
65.         char inbuffer[4096];
66.         n = read(sockfd, inbuffer, sizeof(inbuffer));
67.         if (n > 0)
68.         {
69.             inbuffer[n] = 0;
70.             std::cout << inbuffer << std::endl;
71.         }
72.    
74.     close(sockfd);
75.     return 0;
76. }

复制代码

此时我们就不必要再创建线程了，并且用户发一次信息，服务处置惩罚完该线程就退了，用户如果还有就必要重新毗连服务器。

3.服务端写入失败，写入必要判断

此时我们再来看看结果：

此时就符合我们的预期结果啦！
4.服务器未写，sockfd链接断开

当我们的服务器已经读到数据的时候，但是此时文件描述符的链接一键断开，此时再向这个失效的文件描述符写那么步伐就会出问题，这个就相当于之前的管道，如果读端关掉，那么写端继续写当前举行就会收到SIGPIPE信号，将进程终止掉，此时步伐就会出现SIGPIPE信号，我们直接将其直接终止。

5.客户端多次链接，服务器提供多次服务

然后我们来测试一下：

这里我们再次链接的到时候为什么失败了呢？这是因为我们第一次发出请求的时候，服务器处置惩罚完了之后就将文件描述符关掉了，而链接的时候利用的文件描述符已经被关了，此时会链接失败，所以要想再次链接，就必须要再次创建套接字。

此时就解决问题啦！
6.客户端未发送，服务器断开

当客户端向服务器写的时候，此时服务器断开了，此时我们渴望能够重新毗连服务器，如果重连5次还没有毗连上，用户也离线。

1. #include <iostream>
2. #include <arpa/inet.h>
3. #include <netinet/in.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <string.h>
9. using namespace std;
10. void Usage(const string &proc)
11. {
12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
13.          << endl;
14. }
16. // ./tcpclient serverip serverport
17. int main(int argc, char *argv[])
18. {
19.     if (argc != 3)
20.     {
21.         Usage(argv[0]);
22.         exit(1);
23.     }
24.     string serverip = argv[1];
25.     uint16_t serverport = stoi(argv[2]);
27.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
28.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
29.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
30.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
31.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
32.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
33.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
34.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
36.     // 可是客户端此时不知道服务器的ip和端口号
37.     // 使用命令行参数来解决
38.     struct sockaddr_in server;
39.     memset(&server, 0, sizeof(server));
40.     server.sin_family = AF_INET;
41.     server.sin_port = htons(serverport);
42.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
44.     while (true)
45.     {
46.         int cnt = 5; // 重连的次数
47.         bool isreconnect = false;
48.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);
49.         if (sockfd < 0)
50.         {
51.             cerr << "socket error" << endl;
52.         }
53.         do
54.         {
55.             int n = connect(sockfd, (const struct sockaddr *)&server, sizeof(server));
56.             if (n < 0)
57.             {
58.                 isreconnect = true;
59.                 cnt--;
60.                 std::cerr << "connect error..., reconnect: " << cnt << std::endl;
61.                 close(sockfd);
62.                 sleep(2);
63.             }
64.             else
65.             {
66.                 break;
67.             }
68.         } while (cnt && isreconnect);
69.         if (cnt == 0)
70.         {
71.             std::cerr << "user offline..." << std::endl;
72.             break;
73.         }
75.         string message;
77.         cout << "Please Enter# ";
78.         getline(cin, message);
79.         // 发送数据
80.         n = write(sockfd, message.c_str(), message.size());
81.         if (n < 0)
82.         {
83.             isreconnect = true;
84.             std::cerr << "write error..." << std::endl;
85.             continue;
86.         }
87.         // 读取数据
88.         char inbuffer[4096];
89.         n = read(sockfd, inbuffer, sizeof(inbuffer));
90.         if (n > 0)
91.         {
92.             inbuffer[n] = 0;
93.             std::cout << inbuffer << std::endl;
94.         }
95.         close(sockfd);
96.     }
98.     return 0;
99. }

复制代码

运行结果：

上面这个情况就是我们打游戏的时候，我们的网断开了，就相当于毗连不上服务器了，此时就会多次毗连，如果毗连了很多次都没有毗连上，此时游戏也就会退出啦。
五、英译汉服务器

   makefile

1. .PHONY:all
2. all:tcpserver tcpclient
3. tcpserver:Main.cc
4.         g++ -o $@ $^ -std=c++11 -lpthread
5. tcpclient:TcpClient.cc
6.         g++ -o $@ $^ -std=c++11
8. .PHONY:clean
9. clean:
10.         rm -f tcpserver tcpclient

复制代码

  dict.txt

1. apple:苹果...
2. banana:香蕉...
3. red:红色...
4. yellow:黄色...
5. the: 这
6. be: 是
7. to: 朝向/给/对
8. and: 和
9. I: 我
10. in: 在...里
11. that: 那个
12. have: 有
13. will: 将
14. for: 为了
15. but: 但是
16. as: 像...一样
17. what: 什么
18. so: 因此
19. he: 他
20. her: 她
21. his: 他的
22. they: 他们
23. we: 我们
24. their: 他们的
25. his: 它的
26. with: 和...一起
27. she: 她
28. he: 他（宾格）
29. it: 它

复制代码

  Main.cc

1. #include "TcpServer.hpp"
3. #include <memory>
5. void Usage(std::string proc)
6. {
7.     std::cout << "\n\rUsage: " << proc << " port[1024+]\n" << std::endl;
8. }
10. // ./tcpserver 8080
11. int main(int argc, char* argv[])
12. {
13.     if(argc != 2)
14.     {
15.         Usage(argv[0]);
16.         exit(UsageError);
17.     }
18.     uint16_t port = std::stoi(argv[1]);
19.     unique_ptr<TcpServer> tcpSvr(new TcpServer(port));
20.     tcpSvr->Init();
21.     tcpSvr->Start();
22.     return 0;
23. }

复制代码

  Task.hpp

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include "log.hpp"
5. #include "Init.hpp"
6. #include <string.h>
8. extern Log lg;
9. Init init;
10. using namespace std;
12. class Task
13. {
14. public:
15.     Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
16.         : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
17.     {
18.     }
19.     void run()
20.     {
21.         char buffer[4096];
23.         // 读取用户发送的请求
24.         ssize_t n = read(sockfd_, buffer, sizeof(buffer));
25.         if (n > 0)
26.         {
27.             buffer[n] = '\0';
28.             cout << "client keys: " << buffer << endl;
29.             string echo_string = init.translation(buffer);
30.             int n = write(sockfd_, echo_string.c_str(), echo_string.size());
31.             if(n < 0)
32.             {
33.                 lg(Warning, "write error, errno : %d, errstring: %s", errno, strerror(errno));
34.             }
35.         }
36.         else if (n == 0)
37.         {
38.             // 此时需要关闭文件描述符
39.             lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
40.         }
41.         else
42.         {
43.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
44.         }
45.         close(sockfd_);
46.     }
47.     void operator()()
48.     {
49.         run();
50.     }
51.     ~Task()
52.     {
53.     }
55. private:
56.     int sockfd_;
57.     std::string clientip_;
58.     uint16_t clientport_;
59. };

复制代码

  Init.pp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <fstream>
6. #include <unordered_map>
7. #include "log.hpp"
9. Log lg;
11. const std::string dictname = "./dict.txt";
12. const std::string sep = ":";
14. static bool Split(std::string &s, std::string *part1, std::string *part2)
15. {
16.     auto pos = s.find(sep);
17.     if (pos == std::string::npos)
18.         return false;
19.     *part1 = s.substr(0, pos);
20.     *part2 = s.substr(pos + 1);
21.     return true;
22. }
24. class Init
25. {
26. public:
27.     Init()
28.     {
29.         std::ifstream in(dictname); // 打开配置文件
30.         if (!in.is_open())          // 打开配置文件失败
31.         {
32.             lg(Fatal, "ifstream open %s error", dictname.c_str());
33.             exit(1);
34.         }
35.         std::string line;
36.         while (std::getline(in, line))
37.         {
38.             std::string part1, part2;
39.             Split(line, &part1, &part2);
40.             dict.insert({part1, part2});
41.         }
42.         in.close();
43.     }
44.     std::string translation(const std::string &key)
45.     {
46.         auto iter = dict.find(key);
47.         if (iter == dict.end())
48.             return "Unknow";
49.         else
50.             return iter->second;
51.     }
53. private:
54.     std::unordered_map<std::string, std::string> dict;
55. };

复制代码

  log.hpp

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include "log.hpp"
5. #include "Init.hpp"
6. #include <string.h>
8. extern Log lg;
9. Init init;
10. using namespace std;
12. class Task
13. {
14. public:
15.     Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
16.         : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
17.     {
18.     }
19.     void run()
20.     {
21.         char buffer[4096];
23.         // 读取用户发送的请求
24.         ssize_t n = read(sockfd_, buffer, sizeof(buffer));
25.         if (n > 0)
26.         {
27.             buffer[n] = '\0';
28.             cout << "client keys: " << buffer << endl;
29.             string echo_string = init.translation(buffer);
30.             int n = write(sockfd_, echo_string.c_str(), echo_string.size());
31.             if(n < 0)
32.             {
33.                 lg(Warning, "write error, errno : %d, errstring: %s", errno, strerror(errno));
34.             }
35.         }
36.         else if (n == 0)
37.         {
38.             // 此时需要关闭文件描述符
39.             lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
40.         }
41.         else
42.         {
43.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
44.         }
45.         close(sockfd_);
46.     }
47.     void operator()()
48.     {
49.         run();
50.     }
51.     ~Task()
52.     {
53.     }
55. private:
56.     int sockfd_;
57.     std::string clientip_;
58.     uint16_t clientport_;
59. };

复制代码

  TcpServer.hpp

1. #pragma onec
3. #include <iostream>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <cstdlib>
8. #include <cstring>
9. #include <arpa/inet.h>
10. #include <netinet/in.h>
11. #include <sys/wait.h>
12. #include <signal.h>
13. #include <pthread.h>
14. #include "log.hpp"
15. #include "ThreadPool.hpp"
16. #include "Task.hpp"
17. using namespace std;
19. const int defaultsockfd = -1;
20. const string defaultip = "0.0.0.0";
21. const int backlog = 10; // 但是一般不要设置的太大
22. extern Log lg;
24. enum
25. {
26.     UsageError = 1,
27.     SocketError = 2,
28.     BindError = 3,
29.     ListenError = 4
30. };
32. class TcpServer;
34. class ThreadData
35. {
36. public:
37.     ThreadData(int fd, const std::string &ip, const uint16_t &p, TcpServer *t)
38.     : sockfd(fd)
39.     , clientip(ip)
40.     , clientport(p)
41.     , tsvr(t)
42.     {}
43. public:
44.     int sockfd;
45.     string clientip;
46.     uint16_t clientport;
47.     TcpServer *tsvr;
48. };
51. class TcpServer
52. {
53. public:
54.     TcpServer(const uint16_t &port, const string &ip = defaultip)
55.         : _listensocket(defaultsockfd), _port(port), _ip(ip)
56.     {
57.     }
58.     void Init()
59.     {
60.         // 1.创建套接字
61.         _listensocket = socket(AF_INET, SOCK_STREAM, 0);
62.         if (_listensocket < 0) // 创建套接字失败
63.         {
64.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
65.             exit(SocketError);
66.         }
67.         lg(Info, "create socket success, listensocket: %d", _listensocket);
69.         // 2.绑定端口号
70.         //  使用这个结构体需要包头文件
71.         struct sockaddr_in local;
72.         memset(&local, 0, sizeof(local));
73.         local.sin_family = AF_INET;
74.         // 转化为网络序列
75.         local.sin_port = htons(_port);
76.         // 字符串转化为点时分形式的ip
77.         inet_aton(_ip.c_str(), &(local.sin_addr));
78.         // local.sin_addr.s_addr = INADDR_ANY;
79.         // 此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
80.         int n = bind(_listensocket, (const struct sockaddr *)&local, sizeof(local));
81.         if (n < 0)
82.         {
83.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
84.             exit(BindError);
85.         }
86.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
88.         // 3.设置监听状态
89.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
90.         if (listen(_listensocket, backlog) < 0)
91.         {
92.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
93.             exit(ListenError);
94.         }
95.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
96.     }
98.     void Start()
99.     {
100.         signal(SIGPIPE, SIG_IGN);
101.         ThreadPool<Task>::GetInstance()->Start();
102.         lg(Info, "tcpServer is running....");
103.         for (;;)
104.         {
105.             // 1. 获取新连接 - 知道客户端的ip地址和端口号
106.             struct sockaddr_in client;
107.             socklen_t len = sizeof(client);
108.             // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾
109.             // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
110.             int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
111.             if (sockfd < 0)
112.             {
113.                 // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
114.                 lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
115.                 continue;                                                                      // 所以这里使用continue
116.             }
117.             lg(Info, "get a new link..., sockfd: %d", sockfd);
119.             // 2.根据新连接来进行通信
120.             // 获取客户端的ip地址和端口号
121.             uint16_t clientport = ntohs(client.sin_port);
122.             char clientip[32];
123.             // 转化成主机序列
124.             inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
125.             cout << "clientport: " << clientport << ", clientip: " << clientip << endl;
126.             // 单进程版本
127.             // Service(sockfd, clientip, clientport);
128.             // close(sockfd);
130.             // 多进程版本
131.             // pid_t id = fork();
132.             // if(id == 0)
133.             //{
134.                 // 子进程
135.                 // 子进程会继承父进程的文件描述符
136.                 // close(_listensocket);
137.                 // if(fork() > 0) exit(0); // 此时子进程退出了
138.                 // Service(sockfd, clientip, clientport); // 孙子进程执行
139.                 // 对于孙子进程,它的父进程已经退出了,此时孙子进程被系统领养
140.                 // close(sockfd);
141.                 // exit(0);
142.             //}
143.             // 父进程
144.             // 文件描述符使用的是引用计数
145.             // 关闭父进程的文件描述符不会影响子进程
146.             // close(sockfd);
147.             // 这里等待回收子进程的方式不能是阻塞等待
148.             // pid_t rid = waitpid(id, nullptr, 0);
150.             // 多线程版本
151.             // ThreadData* td = new ThreadData(sockfd, clientip, clientport, this);
152.             // pthread_t tid;
153.             // pthread_create(&tid, nullptr, Rountine, td);
154.             // 这里不用join,因为它是阻塞等待
155.             // pthread_join(tid, nullptr);
157.             // 线程池版本
158.             Task t(sockfd, clientip, clientport);
159.             // 单例模式
160.             ThreadPool<Task>::GetInstance()->Push(t);
161.         }
162.     }
164.     //static void* Rountine(void* args)
165.     //{
166.        // pthread_detach(pthread_self()); // 设置分离状态
167.         // 文件描述符共享,此时我们就不能关闭
168.         // 多线程只拥有tcb
169.         //ThreadData *td = static_cast<ThreadData *>(args);
170.         // static静态成员方法无法使用非静态成员方法和成员
171.         // 1.将Service放到TcpServer类外
172.         // 2.将当前对象的this指针传入
173.         //td->tsvr->Service(td->sockfd, td->clientip, td->clientport);
174.         //delete td;
175.         //return nullptr;
176.     //}
178.     ~TcpServer()
179.     {
180.         close(_listensocket);
181.     }
183. private:
184.     int _listensocket; // 套接字
185.     uint16_t _port;    // 端口号
186.     string _ip;        // ip地址
187. };

复制代码

  TcpClient.cc

1. #include <iostream>
2. #include <arpa/inet.h>
3. #include <netinet/in.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <unistd.h>
7. #include <string.h>
9. using namespace std;
10. void Usage(const string &proc)
11. {
12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
13.          << endl;
14. }
16. // ./tcpclient serverip serverport
17. int main(int argc, char *argv[])
18. {
19.     if (argc != 3)
20.     {
21.         Usage(argv[0]);
22.         exit(1);
23.     }
24.     string serverip = argv[1];
25.     uint16_t serverport = stoi(argv[2]);
27.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
28.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
29.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
30.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
31.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
32.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
33.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
34.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
36.     // 可是客户端此时不知道服务器的ip和端口号
37.     // 使用命令行参数来解决
38.     struct sockaddr_in server;
39.     memset(&server, 0, sizeof(server));
40.     server.sin_family = AF_INET;
41.     server.sin_port = htons(serverport);
42.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
44.     while (true)
45.     {
46.         int cnt = 5; // 重连的次数
47.         bool isreconnect = false;
48.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);
49.         if (sockfd < 0)
50.         {
51.             cerr << "socket error" << endl;
52.         }
53.         do
54.         {
55.             int n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));
56.             if (n < 0)
57.             {
58.                 isreconnect = true;
59.                 cnt--;
60.                 std::cerr << "connect error..., reconnect: " << cnt << std::endl;
61.                 sleep(2);
62.             }
63.             else
64.             {
65.                 break;
66.             }
67.         } while (cnt && isreconnect);
68.         if (cnt == 0)
69.         {
70.             std::cerr << "user offline..." << std::endl;
71.             break;
72.         }
74.         string message;
76.         cout << "Please Enter# ";
77.         getline(cin, message);
78.         // 发送数据
79.         int n = write(sockfd, message.c_str(), message.size());
80.         if (n < 0)
81.         {
82.             isreconnect = true;
83.             std::cerr << "write error..." << std::endl;
84.             continue;
85.         }
86.         // 读取数据
87.         char inbuffer[4096];
88.         n = read(sockfd, inbuffer, sizeof(inbuffer));
89.         if (n > 0)
90.         {
91.             inbuffer[n] = 0;
92.             std::cout << inbuffer << std::endl;
93.         }
94.         close(sockfd);
95.     }
97.     return 0;
98. }

复制代码

服务端：

客户端：

然后我们再来测试一下如果服务器断开了我们还能不能重新连上。

我们发现此时不能重现毗连乐成，这是因为我们的端口号不能重现启动，所以我们要在服务器端加两句代码。

1. int opt = 1;
2. setsockopt(_listensocket, SOL_SOCKET, SO_REUSEADDR|SO_REUSEPORT, &opt, sizeof(opt));
3. // 防止偶发性的服务器无法进行立即重启(tcp协议的时候再说)

复制代码

此时我们来看看运行结果：

六、前台和后台进程

可是万一有一天我们不警惕将我们的xshell关掉了呢？此时服务器就断开了，我们想xshell关掉了服务器依然能跑，要做到这个，我们要理解前台进程和后台进程，先来测试一下它们的特点。

1. #include <iostream>
2. #include <string>
3. #include <unistd.h>
5. int main()
6. {
7.     while(true)
8.     {
9.         std::cout << "hello ...." << std::endl;
10.         sleep(1);
11.     }
12.     return 0;
13. }

复制代码

前台进程：

后台进程：

前台进程：

• 直接交互：前台进程直接与用户交互，意味着用户可以通过命令行与这些进程举行输入和输出操作。
  
• 终端阻塞：当一个进程在前台运行时，它通常会阻塞用户终端，直到该进程完成或被挂起。这意味着用户不能在同一终端启动其他必要交互的进程。
  
• 数目限制：在一个会话中，同时只能有一个进程组在前台运行，只管这个进程组内可能包含多个进程。
  

后台进程：

• 非交互式运行：后台进程在后台运行，不直接与用户交互，即利用户没有自动与其互动，也能连续实行任务。
  
• 不阻塞终端：用户可以在后台进程运行的同时，在同一个终端上实行其他命令或启动其他进程，因为它不阻塞用户界面。
  
• 启动方式：可以通过在命令末端添加符号&来将进程置于后台启动。
  

此时我们可以把进程运行的结果重定向到文件中，如果交给我们的前台进程，那么此时只能实行一个写入文件操作，因为我们的前台进程只有一个，但是后台进程有多个，我们可以交给后台进程，并且还能通过jobs来查看后台进程。

如果我们向终止任务，可以利用fg 任务号将这个任务提到前台进程，但是此时bash就会变成后台进程，然后将它干掉即可。如果我们不想干掉，想重新仍会后台进程呢？

此时我们停息前台进程，系统要不要把bash提到前台进程，把停息的进程提到后台进程，要的，bash必须变成前台进程，所以在命令行中，前台进程一定存在。

随后我们再来理解一下后台进程。

每次登录的时候，我们的session都是差别的，所以session id也是差别的。

这里我们在开启两个终端。

如果我们的前台进程退了，开启的后台进程呢？它会自己退嘛？

此时我们发现后台进程也退出了，所以用户在退出的时候，会将自己启动的所有进程关掉，这就是注销，如果我们不想让我们的后台进程不随任何用户的登录大概退出受影响，此时我们就要保卫进程化，我们将自成session自成进程组的进程，称为保卫进程。

注意：如果调用进程不是一个进程组组长，则创建一个新的会话，但是我们怎么保证不是进程组组长的呢？我们可以创建一个子进程，然后父进程退出，此时的子进程就不是一个进程组组长，则创建一个新的会话，所以保卫进程的本质，也是孤儿进程！但是该孤儿进程很刚强，它把自己设置成新的session，它就是一个独立的session，如许不从属于任何用户登录和注销的影响。

1. #pragma onec
3. #include <unistd.h>
4. #include <iostream>
5. #include <signal.h>
6. #include <cstdlib>
7. #include <sys/types.h>
8. #include <sys/stat.h>
9. #include <fcntl.h>
11. const std::string nullfile = "/dev/null";
13. // 让服务器调用还函数,以守护进程的形式进行运行
14. void Daemon(const std::string &cwd = "")
15. {
16.     // 1.忽略其他异常信号
17.     signal(SIGCLD, SIG_IGN);
18.     signal(SIGPIPE, SIG_IGN);
19.     signal(SIGSTOP, SIG_IGN);
21.     // 2.将自己变成独立的会话
22.     // 父进程退出
23.     if(fork() > 0) exit(0);
24.     setsid();
26.     // 3. 更改当前调用进程的工作目录
27.     if (!cwd.empty())
28.         chdir(cwd.c_str());
30.     // 4.关闭? 标准输入,标准输出,标准错误
31.     // 但是如果我们关闭了,那此时日志里面的打印全都会出错
32.     // 系统为我们提供了一个/dev/null文件,它像一个垃圾桶
33.     // 凡是向/dev/null文件里面写入的信息全部都会被丢弃
34.     // 4.标准输入,标准输出,标准错误 -> 重定向到/dev/null文件
35.     // 此时日志的信息都会丢弃,那么我们看不到错误的信息了嘛?是滴
36.     // 所以日志的信息我们可以将它写到文件中,反正不应该出现在显示器文件
37.     int fd = open(nullfile.c_str(), O_RDWR); // 读写方式打开
38.     if(fd > 0) // 打开成功
39.     {
40.         dup2(fd, 0);
41.         dup2(fd, 1);
42.         dup2(fd, 2);
43.         close(fd);
44.     }
45. }

复制代码

随后我们将保卫进程的代码加入服务器启动的最开始的地方。

随后我们开始运行一下：

并且此时我们能够确定我们的服务器的进程不从属于bash的session，而是单成session。

bash的session id和我们的服务器的session id不一样哦！

此时我们能够发现我们已经将日志重定向到垃圾桶啦！随后我们再将我们的xshell关掉，然后我们再打开xshell，运行我们的服务器，看看结果：

此时只要我们一运行我们的客户端，就可以访问，真正做到了24小时提供服务，那我们怎么关掉我们的服务器呢？直接kill就行啦！！！

注意：为了标识保卫进程，我们一样平常给文件名为末端加上d。
如果我们想保留日志文件，那么我们就要传入写入的方式。

此时我们就能在日志里面看到该日志文件，但是保卫进程还是太麻烦了，要自己来写，其实系统也为我们实现了。

这个函数接受两个整型参数：
   

• nochdir:
  
  
  
  • 如果 nochdir 参数为0，daemon() 函数将会把当前工作目录更改为根目录（"/"）。这是保卫进程的标准行为，避免因当前工作目录被卸载而导致的问题。
    
  • 如果 nochdir 为非0值，则不改变当前工作目录。
    
  
  
• noclose:
  
  
  
  • 如果 noclose 参数为0，daemon() 函数会关闭标准输入、标准输出和标准错误，并将它们都重定向到 /dev/null。这可以防止保卫进程因为试图写入终端而阻塞或产生不必要的输出。
    
  • 如果 noclose 为非0值，标准输入、输出和错误保持不变。但通常情况下，为了确保保卫进程的无终端运行，我们会选择关闭它们。
    
  
  

  利用 daemon() 函数的根本步调通常包括：

• 调用 fork() 创建子进程，父进程退出，如许新进程就不再与终端关联。
  
• 在子进程中调用 setsid() 成为新的会话向导并脱离控制终端。
  
• 调用 umask() 设置符合的权限掩码。
  
• 根据必要调用 chdir("/") 更改当前工作目录到根目录。
  
• 重定向标准输入、输出和错误流，大概通过 daemon() 函数自动处置惩罚。
  
• 继续实行保卫进程的详细任务。
  

七、TCP协议通讯流程

下图是基于TCP协议的客户端/服务器步伐的一样平常流程：

服务器初始化:

• 调用socket, 创建文件描述符;
  
• 调用bind, 将当前的文件描述符和ip/port绑定在一起;
  
• 如果这个端口已经被其他进程占用了, 就会bind失败;
  
• 调用listen, 声明当前这个文件描述符作为一个服务器的文件描述符, 为后面的accept做好准备; 调用accecpt, 并阻塞, 等待客户端毗连过来;
  

建立毗连的过程:

• 调用socket, 创建文件描述符;
  
• 调用connect, 向服务器发起毗连请求;
  
• connect会发出SYN段并阻塞等待服务器应答;
  
• (第一次) 服务器收到客户端的SYN, 会应答一个SYN-ACK段表示"同意建立毗连"; (
  
• 第二次) 客户端收到SYN-ACK后会从connect()返回, 同时应答一个ACK段; (第三次)
  

这个建立毗连的过程, 通常称为 三次握手;
数据传输的过程

• 建立毗连后,TCP协议提供全双工的通讯服务;
  
• 所谓全双工的意思是, 在同一条毗连中, 同一时候, 通讯两边 可以同时写数据;
  
• 相对的概念叫做半双工, 同一条毗连在同一时候, 只能由一方来写数据;
  
• 服务器从accept()返回后立即调 用read(), 读socket就像读管道一样, 如果没有数据到达就阻塞等待;
  
• 这时客户端调用write()发送请求给服务器, 服务器收到后从read()返回,对客户端的请求举行处置惩罚, 在此期 间客户端调用read()阻塞等待服务器的应答;
  
• 服务器调用write()将处置惩罚结果发回给客户端, 再次调用read()阻塞等待下一条请求;
  
• 客户端收到后从read()返回, 发送下一条请求,如此循环下去;
  

断开毗连的过程:

• 如果客户端没有更多的请求了, 就调用close()关闭毗连, 客户端会向服务器发送FIN段(第一次);
  
• 此时服务器收到FIN后, 会回应一个ACK, 同时read会返回0 (第二次);
  
• read返回之后, 服务器就知道客户端关闭了毗连, 也调用close关闭毗连, 这个时候服务器会向客户端发送 一个FIN;(第三次)
  
• 客户端收到FIN, 再返回一个ACK给服务器; (第四次)
  

这个断开毗连的过程, 通常称为 四次挥手
在学习socket API时要注意应用步伐和TCP协议层是如何交互的:

• 应用步伐调用某个socket函数时TCP协议层完成什么动作,好比调用connect()会发出SYN段
  
• 应用步伐如何知道TCP协议层的状态变化,好比从某个阻塞的socket函数返回就表明TCP协议收到了某些 段,再好比read()返回0就表明收到了FIN段
  

谈恋爱例子

八、TCP全双工通讯

全双工通讯：

• 在全双工模式下，数据可以同时在两个方向上传输，即通讯的两边能够同时举行发送和接收操作，互不影响。这就像两个人在打电话，两边可以同时说话和凝听，无需等待对方说完再回应。
  

半双工通讯：

• 半双工模式允许数据在两个方向上传输，但不能同时举行。这意味着在任何给定的时间点，数据只能在一个方向流动。一旦一方开始发送数据，另一方就必须停止发送并转为接收模式，直到前一方发送完毕。这种模式类似于对讲机，利用者必须等待对方讲完并说“Over”后，才可开始自己的发言。
  

我们为什么要讲这个呢？因为我们的tcp是全双工通讯的，它是如何做到的呢？

每个TCP毗连都有独立的发送缓冲区和接收缓冲区。这意味着一个端点可以在其发送缓冲区列队待发送的数据，同时从接收缓冲区读取对方发送过来的数据。这两个操作可以并发举行，从而实现了数据的双向同时传输，所以未来我们可以对一个套接字多进程的并发的读和写，但是两个线程不能同时读和同时写。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。