【网络】tcp_socket

---

一、tcp_server与udp_server一样的部分

#pragma once#include <iostream>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>        
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h> 
#include "Log.hpp"Log lg;const int defaultfd = -1;
const std::string defaultip = "0.0.0.0";
const uint16_t defaultport = 8080;enum
{SocketERR=2,BINDERR=3
};class TcpServer
{
public:TcpServer(const uint16_t& port = defaultport, const std::string& ip = defaultip): _socketfd(defaultfd), _port(port), _ip(ip){}void InitServer(){_socketfd = socket(AF_INET, SOCK_STREAM, 0);if (_socketfd < 0){lg(Fatal, "create socket err, errno: %d, errst: %s", errno, strerror(errno));exit(SocketERR);}lg(Info, "create socket successful, sockfd:%d", _socketfd);struct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(_port);inet_aton(_ip.c_str(), &(local.sin_addr));int n = bind(_socketfd, (struct sockaddr*)&local, sizeof(local));if (n < 0){lg(Fatal, "bind socket err, errno: %d, errst: %s", errno, strerror(errno));exit(BINDERR);}lg(Info, "bind sucessful");// 监听套接字  -- 因为tcp是要等待别人来连接的，所以要有个监听套接字进行监听等待别人来连接}void RunServer(){}~TcpServer(){}
private:int _socketfd;uint16_t _port;std::string _ip;
};

这里我们用inet_aton将本地序列转化成为网络序列。

二、listen接口（监听）

启动服务器，状态是listen：

三、accept接收套接字

1、为什么还要多一个套接字（明明已经有了个socket套接字文件了，为什么要多一个accept套接字文件？）

各司其职呗~~_socketfd是接客用的，面对随时来的新连接先接客到底层去，而accept的返回值才真正是服务的套接字，也就是I/O端口进行服务的，从底层拿出来进行服务！所以_socketfd只有一个，而accept返回值却有多个！（一个接客，多个服务员）

修改一下socket套接字为listen套接字：

2、底层拿到新连接并根据连接进行通信

3、类比理解监听套接字和连接套接字的区别

相当于我们去一家饭店，监听套接字是外面迎客的人，把人都迎进来，里面肯定有服务员吧，服务员就是连接套接字，服务员去服务，迎客的人去迎客。我们目前实现的是迎客连接一条龙，也就是来一群人，一个个迎客，再进来一个个服务，太慢了，所以我们的目标是实现迎客和服务两条线，来了人和迎客互不耽误，两者并发式的运行，就需要我们用多线程版本，但是会出现很多问题我们在下面一一进行讲解。

四、服务端提供服务（向客户端回消息）

那我们就写一个Server函数进行封装来将服务端进行提供服务！我们传参传accept从底层拿到的套接字和拿到的套接字的ip地址和port，我们找到ip地址用的是inet_ntop函数接口。

小问题：我上来通信的字符串和数字等难道到网络中不考虑大小端问题？我地址需要转大端，难道通信的字符串不用转吗？答案是肯定要转的，但是它网络里面自动帮忙转了。

我们用简单的Server函数中的代码为接收到消息，拼接一下再返回给服务器：

五、tcp_client客户端编写

1、框架

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <sys/types.h>        
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>void Usage(const std::string& proc)
{std::cout << "\n\rUsages: " << proc << "serverip serverport\n" << std::endl;
}// ./tcpclient serverip serverport
int main(int argc, char* argv[])
{if (argc != 3){Usage(argv[0]);exit(1);}std::string serverip = argv[1];uint16_t serverport = std::stoi(argv[2]);int socketfd = socket(AF_INET, SOCK_STREAM, 0);if (socketfd < 0){std::cerr << "socket create error " << std::endl; return 1;}struct sockaddr_in server;memset(&server, 0, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));// tcp客户端要绑定，不需要显示绑定，os随机分配// 向网络服务器请求连接，客户端发起connect的时候，进行自动随机绑定int n = connect(socketfd, (struct sockaddr*)&server, sizeof(server));if (n < 0){std::cerr << "connect err " << std::endl;return 2;}// 连接成功std::string message;while (true){std::cout << "Please Enter@ ";std::getline(std::cin, message);char inbuffer[4096];write(socketfd, message.c_str(), message.size()); // 写进socketfdint n = read(socketfd, inbuffer, sizeof(inbuffer)); // 从socketfd读入inbufferif (n <= 0){std::cerr << "read err " << std::endl;return 3;}inbuffer[n] = 0;std::cout << inbuffer << std::endl;}close(socketfd);return 0;
}

2、客户端卡退了，服务端怎么处理？(read返回值为0)

客户端卡退了，服务端怎么办？
服务端保存好消息，其余不管，也就是我们的服务器read的返回值为0，也就是从底层拿到的连接的文件描述符值为0的时候，表示客户端退出。

3、一个有趣的现象–两个一样的客户端去连接客户端？（单进程服务）

理由是单进程版，得等一个进程搞好退出后才能实现另一个进程的使用。

4、方法1：子进程关listensock，父进程关sockfd

因为子进程会有很多没必要的listensock套接字，父进程会有很多没必要的sockfd套接字，子进程是进行监听，父进程是进行连接，其套接字本质不一样，子进程负责监听，父进程负责连接，所以把这些没必要的套接字都关了。

但这种情况父进程用waitpid还是有很大问题，因为父进程得等子进程退出！所以跟单进程没什么区别了，下面我们介绍怎么解决这个问题：

5、处理waitpid问题：孙子进程处理机制或者signal忽略信号

因为父进程等待子进程是阻塞的方式，导致的使父进程要一直等待子进程退出，子进程退出需要一定的时间，并且连的子进程多了，子进程就会一直运行，等待一个运行后再等下一个运行，时间太久了，所以我们使用一下子进程创建孙子进程的方法，子进程创建完立马退出，告诉父进程我退出了，父进程就能够执行下一步操作，而孙子进程去跑服务，并且孙子进程给操作系统进行托孤，孙子进程不受爷爷进程控制，并发的去跑进程。

但上面这个方法还是有很大的问题的，因为子进程的创建代价太大了，要有进程地址空间等很多需要创建的东西，很麻烦，所以我们用下面的这种方法：

6、方法2：多线程版本

上面的做法仍然有不合理之处，就是假如说是几亿个用户连接，那岂不是要几亿个线程，所以我们用线程池版本来解决！

7、方法3：线程池版本

（1）线程池代码ThreadPool.hpp

#pragma once#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <pthread.h>
#include <unistd.h>struct ThreadInfo
{pthread_t tid;std::string name;
};static const int defalutnum = 5;template <class T>
class ThreadPool
{
public:void Lock(){pthread_mutex_lock(&mutex_);}void Unlock(){pthread_mutex_unlock(&mutex_);}void Wakeup(){pthread_cond_signal(&cond_);}void ThreadSleep(){pthread_cond_wait(&cond_, &mutex_);}bool IsQueueEmpty(){return tasks_.empty();}std::string GetThreadName(pthread_t tid){for (const auto &ti : threads_){if (ti.tid == tid)return ti.name;}return "None";}public:static void *HandlerTask(void *args){ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);std::string name = tp->GetThreadName(pthread_self());while (true){tp->Lock();while (tp->IsQueueEmpty()){tp->ThreadSleep();}T t = tp->Pop();tp->Unlock();t();}}void Start(){int num = threads_.size();for (int i = 0; i < num; i++){threads_[i].name = "thread-" + std::to_string(i + 1);pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);}}T Pop(){T t = tasks_.front();tasks_.pop();return t;}void Push(const T &t){Lock();tasks_.push(t);Wakeup();Unlock();}static ThreadPool<T> *GetInstance(){if (nullptr == tp_) // ???{pthread_mutex_lock(&lock_);if (nullptr == tp_){std::cout << "log: singleton create done first!" << std::endl;tp_ = new ThreadPool<T>();}pthread_mutex_unlock(&lock_);}return tp_;}private:ThreadPool(int num = defalutnum) : threads_(num){pthread_mutex_init(&mutex_, nullptr);pthread_cond_init(&cond_, nullptr);}~ThreadPool(){pthread_mutex_destroy(&mutex_);pthread_cond_destroy(&cond_);}ThreadPool(const ThreadPool<T> &) = delete;const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:std::vector<ThreadInfo> threads_;std::queue<T> tasks_;pthread_mutex_t mutex_;pthread_cond_t cond_;static ThreadPool<T> *tp_;static pthread_mutex_t lock_;
};template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

（2）任务代码Task.hpp

#pragma once
#include <iostream>
#include <string>
#include "Log.hpp"
extern Log lg;class Task
{
public:Task(int sockfd, const std::string &ipstr, const uint16_t &clientport): _sockfd(sockfd), _clientip(ipstr), _clientport(clientport){}void run(){char buffer[4096];// 因为是面向字节流的，所以读网络跟读文件一样简单// 先读到bufferssize_t n = read(_sockfd, buffer, sizeof(buffer)); // 从套接字信息中读取消息存到buffer中if (n < 0){lg(Warning, "read err, readip:%s, readport:%d\n", _clientip.c_str(), _clientport);}else if (n == 0) // 客户端退出{lg(Info, "%s:%d quit, server close fd:%d", _clientip.c_str(), _clientport, _sockfd);}else{buffer[n] = 0;std::cout << "client say# " << buffer << std::endl;std::string echo_string = "tcpserver echo@ ";echo_string += buffer;// 再写入write(_sockfd, echo_string.c_str(), echo_string.size()); // 处理完的消息写回sockfd文件}close(_sockfd);}void operator()(){run();}private:int _sockfd;std::string _clientip;uint16_t _clientport;
};

（3）代码改进

void RunServer(){ThreadPool<Task>::GetInstance()->Start(); // 开启线程池的单例模式// signal(SIGCHLD, SIG_IGN); // 信号忽略lg(Info, "tcp_server is running...");while (true){struct sockaddr_in client;socklen_t len = sizeof(client);// 1.获取新连接int sockfd = accept(_listensocketfd, (struct sockaddr*)&client, &len);if (sockfd < 0){lg(Warning, "accept err, errno: %d, errst: %s", errno, strerror(errno));continue;}uint16_t clientport = ntohs(client.sin_port);char ipstr[32]; // 自定义的缓冲区inet_ntop(AF_INET, &(client.sin_addr), ipstr, sizeof(ipstr));// 2.根据新连接来通信lg(Info, "get a new link, sockfd:%d, clentip:%s, clientport:%d", sockfd, ipstr, clientport);// 3.4 线程池版本Task t(sockfd, ipstr, clientport);ThreadPool<Task>::GetInstance()->Push(t);}}

（4）结果

发送一则消息则退出线程。

六、服务端翻译小程序

Init.hpp:

#pragma once 
#include <iostream>
#include <fstream>
#include <string>
#include <unordered_map>
#include "Log.hpp"extern Log lg;const std::string dicname = "./dict.txt";
const std::string sep = ":";static bool Split(std::string &line, std::string* part1, std::string* part2) // line输入性参数 part1/2都是输出型参数
{auto pos = line.find(sep);if (pos == std::string::npos){return false;}*part1 = line.substr(0, pos);*part2 = line.substr(pos + 1);return true;
}class Init
{
public:Init(){std::ifstream in(dicname);if (!in.is_open()){lg(Fatal, "ifstream open %s error", dicname.c_str());exit(1);}std::string line;while (std::getline(in, line)){std::string part1, part2;Split(line, &part1, &part2);dict.insert({part1, part2});}in.close();}std::string Translation(const std::string& key){auto it = dict.find(key);if (it == dict.end()) return "Unkonw";else return it->second;}
private:std::unordered_map<std::string, std::string> dict;
};

Task.hpp:

#pragma once
#include <iostream>
#include <string>
#include "Log.hpp"
#include "Init.hpp"
extern Log lg;
Init init;
class Task
{
public:Task(int sockfd, const std::string &ipstr, const uint16_t &clientport): _sockfd(sockfd), _clientip(ipstr), _clientport(clientport){}void run(){char buffer[4096];// 因为是面向字节流的，所以读网络跟读文件一样简单// 先读到bufferssize_t n = read(_sockfd, buffer, sizeof(buffer)); // 从套接字信息中读取消息存到buffer中if (n < 0){lg(Warning, "read err, readip:%s, readport:%d\n", _clientip.c_str(), _clientport);}else if (n == 0) // 客户端退出{lg(Info, "%s:%d quit, server close fd:%d", _clientip.c_str(), _clientport, _sockfd);}else{buffer[n - 2] = 0;std::cout << "client key# " << buffer << std::endl;std::string echo_string = init.Translation(buffer);// 再写入write(_sockfd, echo_string.c_str(), echo_string.size()); // 处理完的消息写回sockfd文件}close(_sockfd);}void operator()(){run();}private:int _sockfd;std::string _clientip;uint16_t _clientport;
};

七、进化版：出现错误的细节问题

1、向一个已经关闭的文件描述符的文件中进行写入，读端已经关掉了，写端继续写，OS会把客户端进程杀掉

所以我们在write的时候都需要用返回值做一层判断，防止向已经关闭掉的文件描述符中写信息。要么就加信号忽略：

2、重连

tcpclient.cc:

八、在线翻译服务+重连

我们先来这些词汇：

九、地址复用

十、守护进程介绍

守护进程

守护进程的启动bash：

带上日志文件（日志信息打印到当前路径下）：

接口：默认00

十一、tcp的通信原理

tcp是全双工的：两个人吵架。