TCP套接字简单通信
学习完udp套接字通信后，再来看TCP套接字。
四个文件tcp_server.hpp， tcp_server.cc，tcp_client.cc，makefile。
makefile
.PHONY: all
all:tcp_client tcp_server
tcp_client:tcp_client.cc
g++ -o $@ $^ -std=c++11 -lpthread
tcp_server:tcp_server.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY: clean
clean:
rm -f tcp_client tcp_server
1、服务端
1、基本框架
和udp的有些一样。我们有些序列需要主机转网络，但发送的消息不需要，是因为操作系统会自动转大小端，处理交互用的消息。
tcp_server.hpp
#pragma once
#include <iostream>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
namespace ns_server
{
static const uint16_t defaultport = 8081;
class TcpServer
{
public:
TcpServer(uint16_t port = defaultport): port_(port)
{}
void initDerver()
{
//1. 创建socket
sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
std::cerr << "create socket fail" << std::endl;
exit(SOCKET_ERR);
}
//2. 绑定
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port_);
local.sin_addr.s_addr = htonl(INADDR_ANY);//也可以直接写INADDR_ANY
if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
{
std::cerr << "bind socket fail" << std::endl;
exit(BIND_ERR);
}
}
void start()
{}
~TcpServer()
{}
private:
uint16_t port_;//只要是服务器，就要有端口号
int sock;
};
};
err.hpp
#pragma once
enum
{
USAGE_ERR = 1,
SOCKET_ERR,
BIND_ERR
};
tcp_server.cc
#include "tcp_server.hpp"
using namespace std;
using namespace ns_server;
int main()
{
unique_ptr<TcpServer> tsvr(new TcpServer());
tsvr->initServer();
tsvr->start();
return 0;
}
tcp_client.cc
#include <iostream>
int main()
{
return 0;
}
接下来开始就是tcp的部分了。tcp是面向连接的，它不像udp一样可以直接接发消息，它得需要先连接再通信。
backlog先不用管，设置成一个小的数字就行。在类前设置一下
static const uint16_t defaultport = 8081;
static const int backlog = 32;
//3. 监听（先让客户端连接过来，才能通信，而服务端就得一直等着连接）
if(listen(sock, backlog) < 0)
{
std::cerr << "listen socket fail" << std::endl;
exit(LISTEN_ERR);//err.hpp就得加一个LISTEN.ERR
}
开始写start函数。
void start()
{
quit_ = false;
while(!quit_)
{
//4. 客户端要连接，服务端就要先获取连接
sleep(1);
}
}
写到这里就可以启动试试了。./tcp_server，用netstat命令来查看是否启动成功，后面的命令选项，-nltp，n把能显示成数字的显示成数字，l就是listen，t是指tcp，p是进程，打出来的内容中就有一个处于监听状态，IP地址是0.0.0.0的一个进程，显示出了它的PID，以及还有程序名字tcp_server。
2、获取连接
服务端必须处于监听状态，客户端才能来连接它。连接用的函数是accept。
addr和addrlen是客户端的数据。sockfd是一个套接字。
它的返回值实际也是一个文件描述符。accept接口，sockfd是用来监听的套接字，也就是用来连接客户端的，而它的返回值则是用来处理数据的。前面创建的sock就是这里的sockfd，为了方便，我们把它改名为listensock_。
struct sockaddr_in client;
socklen_t len = sizeof(client);
//4. 客户端要连接，服务端就要先获取连接
int sock = accept(listensock_, (struct sockaddr*)&client, &len);
连接有可能失败，比如客户端不连接这个服务端，但这对于服务端并没有什么，它继续连接其它客户端就好，所以即使失败也继续。
void start()
{
quit_ = false;
while(!quit_)
{
struct sockaddr_in client;
socklen_t len = sizeof(client);
//4. 客户端要连接，服务端就要先获取连接
int sock = accept(listensock_, (struct sockaddr*)&client, &len);
if(sock < 0)
{
std::cerr << "accept error" << std::endl;
continue;
}
std::string clientip = inet_ntoa(client.sin_addr);
uint16_t clientport = ntohs(client.sin_port);
//5. 获取新连接成功，开始业务处理
std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;
service(sock);
}
}
写用来处理数据的函数service。先写一个读写操作。我们用socket创建的tcp套接字是流式套接字，访问时也是用字节流来访问的，想要读取数据，就用read系统调用来读取。read可以读文件，也可以读网络，就对应了Linux一切皆文件。
void service(int sock)
{
char buffer[1024];
while(true)
{
ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
if(s > 0)
{
buffer[s] = 0;
std::cout << buffer << std::endl;
}
else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了
{
close(sock);
std::cout << "client quit, me too" << std::endl;
break;
}
else
{
close(sock);
std::cerr << "read error: " << strerror(errno) << std::endl;
break;
}
}
}
这里只写了打印语句。接下来用回调来完成对数据的处理。
引入头文件functional。
加上成员变量func_t func_。
命名空间里的类的前面加上using func_t = std::function<std::string(const std::string&)>。
在读取成功后，buffer[s] = 0下一行加上std::string res = func_(buffer)。
初始化里也得初始化TcpServer(func_t func, uint16_t port = defaultport): func_(func), port_(port), quit_(true)。
然后在tcp_server.cc中写上回调函数。
#include "tcp_server.hpp"
using namespace std;
using namespace ns_server;
static void usage(string proc)
{
cout << "Usage:\n\t" << proc << " port\n" << endl;
}
string echo(const string& message)
{
return message;//简单的返回
}
int main(int argc, char* argv[])
{
if(argc != 2)
{
usage(argv[0]);
exit(USAGE_ERR);
}
uint16_t port = atoi(argv[1]);
unique_ptr<TcpServer> tsvr(new TcpServer(echo, port));
tsvr->initServer();
tsvr->start();
return 0;
}
hpp文件中连接成功后调用回调函数，用的是res来接收，那么下面就不用打印buffer了，打印res就好了。然后再把res写给连接过来的客户端。
if(s > 0)
{
buffer[s] = 0;
std::string res = func_(buffer);
std::cout << res << std::endl;
write(sock, res.c_str(), res.size());
}
2、客户端
客户端全部都写在一个tcp_client.cc文件中。
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
using namespace std;
static void usage(string proc)
{
cout << "Usage:\n\t" << proc << " port\n" << endl;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
usage(argv[0]);
exit(USAGE_ERR);
}
uint16_t serverport = atoi(argv[2]);
string serverip = argv[1];
//1. 创建套接字
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
cerr << "socket error : " << strerror(errno) << endl;
exit(SOCKET_ERR);
}
return 0;
}
客户端需要绑定吗？需要绑定，但不需要自己绑定，因为客户端来源于很多处，所以靠系统来绑定，防止端口冲突。客户端需要监听吗？服务端是监听的，客户端则不需要，客户端是连接服务端的，服务端是等待被连接的，所以客户端不需要监听listen，也不需要获取连接accept。
客户端需要做的是连接。用connect接口。
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
using namespace std;
static void usage(string proc)
{
cout << "Usage:\n\t" << proc << " port\n" << endl;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
usage(argv[0]);
exit(USAGE_ERR);
}
uint16_t serverport = atoi(argv[2]);
string serverip = argv[1];
//1. 创建套接字
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
cerr << "socket error : " << strerror(errno) << endl;
exit(SOCKET_ERR);
}
//2. 发起连接
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
inet_aton(serverip.c_str(), &server.sin_addr);
int cnt = 5;
while(connect(sock, (struct sockaddr*)&server, sizeof(server)) != 0)
{
cout << "正在尝试重连，重连次数还有: " << cnt-- << endl;
if(cnt <= 0) break;
}
if(cnt <= 0)
{
cerr << "连接失败..." << endl;
exit(CONNECT_ERR);
}
//3. 连接成功
char buffer[1024];
while(true)
{
string line;
cout << "Enter>> ";
getline(cin, line);
write(sock, line.c_str(), line.size());
ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
if(s > 0)
{
buffer[s] = 0;
cout << "server echo >>>" << buffer << endl;
}
else if(s == 0)
{
cerr << "server quit" << endl;
break;
}
else
{
cerr << "read error: " << strerror(errno) << endl;
break;
}
}
close(sock);
return 0;
}
3、多进程
为了让效果更明显，我们对代码做一些变更。
服务端的这部分代码，对service改一下。除了传客户端的套接字，再传进去ip和port。
void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
std::string who = clientip + "-" + std::to_string(clientport);
char buffer[1024];
while(true)
{
ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
if(s > 0)
{
buffer[s] = 0;
std::string res = func_(buffer);
std::cout << who << ">>>" << res << std::endl;
write(sock, res.c_str(), res.size());
}
else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了
{
close(sock);
std::cout << who << "quit, me too" << endl;
break;
}
else
{
close(sock);
std::cerr << "read error: " << strerror(errno) << std::endl;
break;
}
}
}
这样就能看出来连接的是哪个客户端，哪个客户端的消息，哪个客户端退出了。
当我们把现在所有的代码编译启动后，会发现有问题。同时开两个客户端，连接好后，只有一个在服务端那里出现了连接的消息，另一个没有，并且另一个发消息，服务端也没有打印出来，只有连接上的那个能打印消息；当把两个客户端都退出时，之前连接上的那个正常退出，而紧接着，没连接上的那个这时却打印了连接成功的消息，并且文件描述符和之前连接的那个一样，也就是说，它是在上一个文件取消连接后才去连接的，所以文件描述符是同一个数字，并且之前没有打印出来的消息这时也都打印出来了。
这就说明，目前的服务端无法处理多个客户端。我们得让服务端能多进程运行。
//5. 获取新连接成功，开始业务处理
std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;
//service(sock, clientip, clientport);
pid_t id = fork();
if(id < 0)
{
close(sock);
continue;
}
//子进程会继承父进程的fd，但父子不是用同一张文件描述表的，子进程会拷贝父进程的
//子进程一定有sock和listensock
//分工明确一下，父进程负责获取连接，子进程处理数据，所以两个进程都要close不需要的部分
else if(id == 0)
{
close(listensock_);
service(sock, clientip, clientport);
exit(0);
}
close(sock);//如果父进程不关闭，一直accept，一直往下开文件描述符，文件描述符存储在数组中，总有满的时候，就会造成文件描述符泄漏
pid_t ret = waitpid(id, nullptr, 0);
if(ret == id) std::cout << "wait child " << id << " succeed" << std::endl;
这里面有个明显的问题，等待默认是阻塞的，所以父进程还是在串行运行的。我们可以用非阻塞式运行，0换成WHOHANG，但是假如最后一个客户端已经连接上了，子进程在处理，父进程回去继续accept，子进程退出后，父进程还卡在那里，没办法退出了，所以不行；还可以用signal函数，子进程退出时会发出SIG_CHILD信号，那么对它捕捉并用handler处理就行，但不如直接忽略掉这个信号更方便，所以这里采用忽略。
除了忽略，还有一个办法。
else if(id == 0)
{
close(listensock_);
if(fork() > 0) exit(0);
//到这里时，子进程已经退了，孙子进程在运行
//子进程退，父进程就wait结束，也退了
//这时候孙子进程是孤儿进程，由系统管理，所以不需要担心它的回收
service(sock, clientip, clientport);
exit(0);
}
但fork太多，对系统要求也高，所以直接忽略就好。现在再次运行，会发现所有的客户端的文件描述符都是一个数字，这是因为有了多进程后，一个客户端连接上，子进程就会把这个客户端拿过来处理，而父进程那边给关闭了这个文件描述符，再去获取下一个连接，所以父进程给客户端分配的一直都是一个文件描述符。
4、多线程
多进程还是不够高效，把处理数据的部分换成多线程。
class TcpServer;
class ThreadData
{
public:
ThreadData(int fd, const std::string &ip, const uint16_t &port, TcpServer* ts)
: sock(fd), clientip(ip), clientport(port), current(ts)
{}
public:
int sock;
std::string clientip;
uint16_t clientport;
TcpServer *current;
};
void start()
{
//signal(SIGCHLD, SIG_IGN);
quit_ = false;
while(!quit_)
{
struct sockaddr_in client;
socklen_t len = sizeof(client);
//4. 客户端要连接，服务端就要先获取连接
int sock = accept(listensock_, (struct sockaddr*)&client, &len);
if(sock < 0)
{
std::cerr << "accept error" << std::endl;
continue;
}
std::string clientip = inet_ntoa(client.sin_addr);
uint16_t clientport = ntohs(client.sin_port);
//5. 获取新连接成功，开始业务处理
std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;
pthread_t tid;
ThreadData* td = new ThreadData(sock, clientip, clientport, this);
pthread_create(&tid, nullptr, threadRoutine, td);
}
}
static void* threadRoutine(void* args)
{
ThreadData* td = static_cast<ThreadData*>(args);
td->current->service(td->sock, td->clientip, td->clientport);
delete td;//service完后退出
}
线程要不要关闭不要的套接字？不需要，因为多个线程共享文件描述符，所以不能关掉，关掉后服务端就不能正常运行了。这里要不要回收线程？肯定要，但如果create完后join后，join会阻塞，又会出现多进程里的问题。应当在threadRoutine函数里先detach，分离出当前线程，那么主线程就不需要管理这个分离出去的线程了，它运行完自己结束，而服务端可以继续做自己的工作。
5、线程池
现在的程序是客户端连接过来了，服务端才建立线程，为了更高效，我们可以用线程池来优化。
之前已经写过线程池了。ThreadPool_V4.hpp
#pragma once
#include <iostream>
#include <memory>//智能指针的头文件
#include <string>
#include <vector>
#include <queue>
#include <unistd.h>
#include <pthread.h>
#include "Thread.hpp"
#include "task.hpp"
#include "LockGuard.hpp"
const static int N = 5;
template <class T>
class ThreadPool
{
private:
ThreadPool(int num = N) : _num(num)//也可以不初始化_threads，因为我们用的是库，直接push就行
{
pthread_mutex_init(&_lock, nullptr);
pthread_cond_init(&_cond, nullptr);
}
ThreadPool(const ThreadPool<T> &tp) = delete;//去掉默认生成的拷贝构造
void operator=(const ThreadPool<T> &tp) = delete;//去掉默认生成的拷贝赋值
public:
static ThreadPool<T> *getinstance()//这个要设置成静态的，因为如果cc文件中要调用这个静态对象的函数的话，函数也应当是静态的才行
{
if(nullptr == instance) //提高效率，减少加锁的次数
{
LockGuard lockguard(&instance_lock);//用锁类
if (nullptr == instance)
{
logMessage(Debug, "线程池单例形成");
instance = new ThreadPool<T>();
instance->init();
instance->start();
}
}
return instance;
}
pthread_mutex_t *getlock() {return &_lock; }
void threadWait() {pthread_cond_wait(&_cond, &_lock); }
void threadWakeup() {pthread_cond_signal(&_cond); }
bool isEmpty() {return _tasks.empty(); }
T popTask()
{
T t = _tasks.front();
_tasks.pop();
return t;
}
static void threadRoutine(void *args)//加static？类内的线程函数，要记得加static，放在静态区，因为在类内会有this指针，导致函数参数类型不对
{
// pthread_detach(pthread_self());
ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
while (true)
{
T t;
{//括号里就是临界区
//1、检测有没有任务，有就处理，无就等待，这里一定要加锁
LockGuard lockguard(tp->getlock());
//因为是静态函数，不能直接访问类内私有成员，所以init函数那里要传this指针就可以了
while(tp->isEmpty())
{
tp->threadWait();
}
t = tp->popTask();//从公共区域拿到私有区域
}
//测试
t();
}
}
void init()
{
//插入若干个线程
for (int i = 0; i < _num; i++)
{
_threads.push_back(Thread(i, threadRoutine, this));
}
}
void start()
{
for (auto &t : _threads)
{
t.run();
}
}
void check()
{
for (auto& t : _threads)
{
std::cout << t.threadname() << " running..." << std::endl;
}
}
void pushTask(const T &t)
{
LockGuard lockgrard(&_lock);//V2是调用系统接口，V3就是调用我们自己写的类，初始化，函数结束时自动析构，也就是释放锁
_tasks.push(t);
threadWakeup();
}
~ThreadPool()
{
for (auto &t : _threads)
{
t.join();
}
pthread_mutex_destroy(&_lock);
pthread_cond_destroy(&_cond);
}
private:
std::vector<Thread> _threads;//pthread_t是用库中的
int _num;
std::queue<T> _tasks; // 使用STL的自动扩容
pthread_mutex_t _lock;
pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制
static ThreadPool<T> *instance;//对象
static pthread_mutex_t instance_lock;//静态锁
};
template <class T>
ThreadPool<T> *ThreadPool<T>::instance = nullptr;
template <class T>
pthread_mutex_t ThreadPool<T>::instance_lock = PTHREAD_MUTEX_INITIALIZER;
在tcp_server.hpp里引入这个头文件。这个线程池是默认有5个线程可供使用的。task.hpp要改，不同的场景有不同的任务。
task.hpp先写一个框架
#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
class Task
{
public:
Task()
{}
Task(int sock): _sock(sock)
{}
void operator()()//仿函数，在tcp_server.hpp中用t()来调用
{
}
~Task()
{}
private:
int _sock;
};
接着看tcp_server.hpp文件。
//5. 获取新连接成功，开始业务处理
std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;
Task t(sock, clientip, clientport, std::bind(&TcpServer::service, this, std::placeholder::_1, std::placeholder::_2, std::placeholder::_3));//绑定类内用的方法，三个是占位符，前面三个是这个方法的参数
ThreadPool<Task>::getinstance()->pushTask(t);
task.hpp中使用回调函数。
#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <functional>
using cb_t = std::function<void(int, const std::string&, const uint16_t&)>;
class Task
{
public:
Task()
{}
Task(int sock, const std::string& ip, const std::uint16_t& port, cb_t cb)
: _sock(sock), _ip(ip), _port(port), _cb(cb)
{}
void operator()()
{
_cb(_sock, _ip, _port);
}
~Task()
{}
private:
int _sock;
std::string _ip;
std::uint16_t _port;
cb_t _cb;
};
写好后整体运行起来，会有以下的现象。程序貌似不是很快；有的客户端会连接不上，只能重连；文件描述符依次增大，如果有客户端退出，紧接着连接上的客户端就会用上退出的客户端的文件描述符；连不上的客户端等其它客户端退出一些，它们才能连上。因为service函数是一个死循环，一个线程进去执行任务后就出不来了，没有执行任务才会break，线程池也只有5个线程，这样的设计就注定如果5个线程都用上了，其它来连接的就得等着，只能处理短任务。我们也可以使用多线程的办法，在service函数中要调用函数去处理数据时在动用线程池，这样就是多线程内带着线程池。
比较简单的做法就是service变成一次的，而不是死循环，去掉while。线程池的个数也加多一些。
void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
std::string who = clientip + "-" + std::to_string(clientport);
char buffer[1024];
ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
if(s > 0)
{
buffer[s] = 0;
std::string res = func_(buffer);
std::cout << who << ">>>" << res << std::endl;
write(sock, res.c_str(), res.size());
}
else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了
{
close(sock);
std::cout << who << "quit, me too" << endl;
}
else
{
close(sock);
std::cerr << "read error: " << strerror(errno) << std::endl;
}
close(sock);
}
这样的改动也只是处理简单的操作，IO数据的时候就要有更详细的做法。
6、简单的日志系统
上面的代码一直是用cout来打印消息，但实际上就写日志来记录这些信息。这里要写的日志不是完整的，而是简易版本，用来完成简单的TCP通信。创建一个log.hpp。日志中要使用v开头的几个函数。
日志是有等级的，编译器会给警告，会给报错，就是在打印日志消息。日志要处理多种类的信息。
#pragma once
#include <cstdio>
#include <cstring>
#include <cstdarg>
#define DEBUG 0//调试信息
#define INFO 1//正常信息
#define WARNING 2//告警，不影响运行
#define ERROR 3//一般错误
#define FATAL 4//严重错误
void logMessage(int level, char* format, ...)//...就是可变参数，format是输出格式
{
}
要用可变参数，需要用到几个宏
void logMessage(int level, char* format, ...)//...就是可变参数，format是输出格式
{
//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数
va_list p;//char*
//下面是三个宏函数
int a = va_arg(p, int);//根据类型提取参数
va_start(p, format);//让p指向可变参数部分的起始地址
va_end(p);//把p置为空, p = NULL
}
下面写出整个功能实现。
#pragma once
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdarg>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>
enum
{
Debug = 0,//调试信息
Info,//正常信息
Warning,//告警，不影响运行
Error,//一般错误
Fatal,//严重错误
Unknown
};
static std::string toLevelString(int level)
{
switch(level)
{
case Debug:
return "Debug";
case Info:
return "Info";
case Warning:
return "Warning";
case Error:
return "Error";
case Fatal:
return "Fatal";
default:
return "Unknown";
}
}
static std::string getTime()
{
time_t curr = time(nullptr);//拿到当前时间
struct tm *tmp = localtime(&curr);//这个结构体有对于时间单位的int变量
char buffer[128];
snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, \
tmp->tm_hour, tmp->tm_min, tmp->tm_sec);//这些tm_的变量就是结构体中自带的，tm_year是从1900年开始算的，所以+1900；月份从0开始，要+1
return buffer;
}
//日志格式: 日志等级 时间 pid 消息体
//logMessage(DEBUG, "hello: %d, %s", 12, s.c_str()); 12以%d形式打印, s.c_str()以%s形式打印
void logMessage(int level, const char* format, ...)//...就是可变参数，format是输出格式
{
//写入到两个缓冲区中
char logLeft[1024];//用来显示日志等级，时间，pid
std::string level_string = toLevelString(level);
std::string curr_time = getTime();
snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d] ", level_string.c_str(), curr_time.c_str(), getpid());
char logRight[1024];//用来显示消息体
va_list p;
va_start(p, format);
//直接用这个接口来对format进行操作，提取信息
vsnprintf(logRight, sizeof(logRight), format, p);
va_end(p);
//打印
printf("%s%s\n", logLeft, logRight);
//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数
//va_list p;//char*
//下面是三个宏函数
//int a = va_arg(p, int);//根据类型提取参数
//va_start(p, format);//让p指向可变参数部分的起始地址
//va_end(p);//把p置为空, p = NULL
}
tcp_server.hpp引入这个头文件，以及线程池头文件，都用日志来打印消息，这个在最后的代码链接中会看到。
先放上几句
//5. 获取新连接成功，开始业务处理
logMessage(Info, "获取新连接成功: %d from %d, who: %s - %d", sock, listensock_, clientip.c_str(), clientport);
void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
std::string who = clientip + "-" + std::to_string(clientport);
char buffer[1024];
ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
if(s > 0)
{
buffer[s] = 0;
std::string res = func_(buffer);
logMessage(Debug, "%s# %s", who.c_str(), res.c_str());
write(sock, res.c_str(), res.size());
}
else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了
{
close(sock);
logMessage(Info, "%s quit,me too", who.c_str());
}
else
{
close(sock);
logMessage(Error, "read error, %d:%s", errno, strerror(errno));
}
close(sock);
}
7、守护进程
如果关闭服务端，整个程序就不能继续了，但服务端应当一直存在，无论什么时候访问都行，所以我们要写守护进程。创建daemon.hpp。
通常./运行起来程序后都是前台运行，还可以在命令后加上空格和&做到后台运行，但也不能解决问题。
系统有sleep进程，我们可以sleep 10000就可以打开这个可执行文件， 然后用ps ajx | head -1 && axj | grep sleep来查看。进程有进程组，组有组号PGID。SID是会话ID，TTY是终端，有问号的就是对应的进程和终端无关，不是问号的显示的就是终端文件，这个进程打开了这个终端，并向这个终端文件放入内容。用户使用命令ls，pwd这样的时候，就是进程运行时在用户这里打开了终端文件，向这个文件输入内容。
打开的几个程序，如果以管道连接起来，那么PGID，会话id（SID）和终端文件都是一样的，都是第一个进程的，第一个进程也是组长，不过如果我们分为几个前台工作，几个后台工作，假如都是sleep进程，那么后台和前台不同的是PGID，但都是一个会话，打开一个终端文件。sleep的会话id其实就是bash。
会话包含多个线程组，一个线程组包含多个线程；会话关联一个终端文件；进程之间有组关系，组长都是多个进程中的第一个。
当用户登录云服务器时，登录成功会分配一个命令行提示符，也就是用户输入命令时前面的[…@…]这部分，这本质也是一个进程，也属于一个进程组，组内只有它自己，也属于一个会话，这个会话是由bash创建的，这个会话以它来起名，之后所有的用户建立的进程都属于这个会话，只是进程组不同。进程组在会话中，一个会话里，操作系统就给用户创建多个进程组。每次登录都会创建一个新的会话。
为什么要有进程组？jobs命令可以查看当前会话中所有的后台程序，每个后台程序最前面都有1个数字，从1开始，只要增加一个程序就数字就加1，每次创建的一个程序，自成一个进程组，所以PGID不同。前面的数字编号，叫做任务编号，用命令fg 任务编号就可以把这个程序放到前台（后台的任务编号不变），用Ctrl + Z就会让这个程序停止，就会自动回到后台，用bg 任务编号会让这个程序再次运行起来。所以进程组创建是为了完成任务的，一个任务可以由多个进程完成，也可以由一个进程完成。所以用户用命令启动的一个进程，其实就是在启动一个任务。
进程组有前台和后台任务，如果把后台任务提到前台，老的前台任务就无法运行，前台任务只能有一个在运行，比如提到前台后，输入命令就不起作用了，所以用户在用命令行启动一个进程时，bash无法运行。登录云服务器时就是在创建一个会话，会话里有bash任务，启动进程时就是在当前会话中创建新的前台任务，而退出则是销毁会话，会影响会话内部的所有任务。销毁会话就是注销，通常的网络服务器，为了不受到用户登录注销的影响，会以守护进程的方式运行。既然创建的进程都会在一开始登录时创建的会话里，注销时也会注销这个会话，那就让被守护的进程放入另外一个会话，这样注销就不会受影响了，这就是守护进程的做法。
需要用到setsid接口
创建一个会话，设置进程组ID，谁调用这个接口，谁就是组长。返回新会话的ID，也就是这个进程的ID，失败返回-1，错误码被设置。
如何创建守护进程？
核心是setsid接口，但不止这点。要想调用这个接口，不能是组长调用，这样就得保证调用者不是组长。守护进程要忽略异常信号，并对文件描述符012做特殊处理，改变工作路径。进程的工作路径默认为当前路径，但守护进程不想这样，它会放在根目录下，不属于某个用户目录。更改路径这个操作用daemon这个接口，两个参数分别表示要不要更改路径，要不要关闭012。
不过一般是自己来更改路径，不用这个接口。外部的调用逻辑是这样的，也就是tcp_server.cc中
tsvr->initServer();
//将服务器守护进程化
Daemon();
tsvr->start();
err.hpp中加上SETSID_ERR这个错误
#pragma once
enum
{
USAGE_ERR = 1,
SOCKET_ERR,
BIND_ERR,
LISTEN_ERR,
CONNECT_ERR,
SETSID_ERR
};
如果daemon.hpp这样写
#pragma once
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include "log.hpp"
#include "err.hpp"
void Daemon()
{
pid_t ret = setsid();
if((int)ret == -1)
{
lodMessage(Fatal, "daemon error, code: %d, string: %s", errno, strerror(errno));
exit(SETSID_ERR);
}
}
./运行起服务端肯定出错，因为新创建的这个进程自成一组，它是组长，就不行，所以得先让它不是组长，只要不是第一个进程就好了。
void Daemon()
{
if(fork() > 0) exit(0);
//下面的就是子进程了
pid_t ret = setid();
if((int)ret == -1)
{
lodMessage(Fatal, "daemon error, code: %d, string: %s", errno, strerror(errno));
exit(SETSID_ERR);
}
}
以及还需要忽略异常信号等其它。
#pragma once
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "log.hpp"
#include "err.hpp"
void Daemon()
{
//1. 忽略信号
//这里就忽略两个信号，还可以忽略其它信号
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
//2. 避免成为组长
if(fork() > 0) exit(0);
//下面的就是子进程了
//3. 新建会话，自己成为会话的话首进程
pid_t ret = setid();
if((int)ret == -1)
{
logMessage(Fatal, "daemon error, code: %d, string: %s", errno, strerror(errno));
exit(SETSID_ERR);
}
//4. 可选: 更改守护进程的工作路径
//因为我们自定义的一些头文件，这里就不改路径了
//chdir("/")//更改为根目录
//5. 处理012问题
//Linux中有个/dev/null文件，任何向里面输入的内容都会被抛弃，不会被提取内容
int fd = open("/dev/null", O_RDWR);//读写方式打开
if(fd < 0)
{
logMessage(Fatal, "open error, code: %d, string: %s", errno, strerror(errno));
exit(OPEN_ERR);
}
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, 2);
close(fd);
}
在tcp_server.cc文件中，守护进程后还会有start函数，这个函数里可能有cout，cin等，守护进程后使用这些就会出错，所以要把错误重定向到/dev/null中。守护进程本质是孤儿进程的一种。这时候再次启动服务端就可以了。启动后用命令
ps ajx | head -1 && ps -axj | grep tcp_server
grep后面的就是进程名字。可以发现TTY是?，SID是一个新的组。关闭云服务器后，这个服务端依然可以提供服务。用jobs查看不到。
想要关闭服务端，kill -9 SID就可以。但是还有一个问题，把标准输入输出错误都重定向到/dev/null了，那么日志打印的消息程序员也就看不到了，就不知道服务器会出什么问题了，所以我们还得更改一下log.hpp，让它把消息打印到当前路径的一个文件中。
#pragma once
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdarg>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>
const std::string filename0 = "log/tcpserver.log.Debug";
const std::string filename1 = "log/tcpserver.log.Info";
const std::string filename2 = "log/tcpserver.log.Warning";
const std::string filename3 = "log/tcpserver.log.Error";
const std::string filename4 = "log/tcpserver.log.Fatal";
const std::string filename5 = "log/tcpserver.log.Unknown";
enum
{
Debug = 0,//调试信息
Info,//正常信息
Warning,//告警，不影响运行
Error,//一般错误
Fatal,//严重错误
Unknown
};
static std::string toLevelString(int level, std::string& filename)
{
switch(level)
{
case Debug:
filename = filename0;
return "Debug";
case Info:
filename = filename1;
return "Info";
case Warning:
filename = filename2;
return "Warning";
case Error:
filename = filename3;
return "Error";
case Fatal:
filename = filename4;
return "Fatal";
default:
filename = filename5;
return "Unknown";
}
}
static std::string getTime()
{
time_t curr = time(nullptr);//拿到当前时间
struct tm *tmp = localtime(&curr);//这个结构体有对于时间单位的int变量
char buffer[128];
snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, \
tmp->tm_hour, tmp->tm_min, tmp->tm_sec);//这些tm_的变量就是结构体中自带的，tm_year是从1900年开始算的，所以+1900
return buffer;
}
//日志格式: 日志等级 时间 pid 消息体
//logMessage(DEBUG, "hello: %d, %s", 12, s.c_str()); 12以%d形式打印, s.c_str()以%s形式打印
void logMessage(int level, const char* format, ...)//...就是可变参数，format是输出格式
{
//写入到两个缓冲区中
char logLeft[1024];//用来显示日志等级，时间，pid
std::string filename;
std::string level_string = toLevelString(level, filename);
std::string curr_time = getTime();
snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d] ", level_string.c_str(), curr_time.c_str(), getpid());
char logRight[1024];//用来显示消息体
va_list p;
va_start(p, format);
//直接用这个接口来对format进行操作，提取信息
vsnprintf(logRight, sizeof(logRight), format, p);
va_end(p);
//打印
printf("%s%s\n", logLeft, logRight);
//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数
//保存到文件中
FILE* fp = fopen(filename.c_str(), "a");
if(fp == nullptr) return ;
fprintf(fp, "%s%s\n", logLeft, logRight);
fflush(fp);
fclose(fp);
//va_list p;//char*
//下面是三个宏函数
//int a = va_arg(p, int);//根据类型提取参数
//va_start(p, format);//让p指向可变参数部分的起始地址
//va_end(p);//把p置为空, p = NULL
}
8、其它
man inet_addr会看到很多接口，inet_ntoa是把四字节IP转换为字符串，但它是C接口，返回类型是char*，也就是说返回了指针，返回了地址，而字符串是系统在内存中申请了一块空间来存储，这个位置不需要我们手动释放，但频繁调用，后面的会覆盖前面的地址，也就是说这个接口不是线程安全的，所以在多线程场景中会出问题。不过到现在为止，应当是加上了线程安全，可以用这段代码测试
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
void* Func1(void* p)
{
struct sockaddr_in* addr = (struct sockaddr_in*)p;
while (1)
{
char* ptr = inet_ntoa(addr->sin_addr);
printf("addr1: %s\n", ptr);
}
return NULL;
}
void* Func2(void* p)
{
struct sockaddr_in* addr = (struct sockaddr_in*)p;
while (1)
{
char* ptr = inet_ntoa(addr->sin_addr);
printf("addr2: %s\n", ptr);
}
return NULL;
}
int main()
{
pthread_t tid1 = 0;
struct sockaddr_in addr1;
struct sockaddr_in addr2;
addr1.sin_addr.s_addr = 0;
addr2.sin_addr.s_addr = 0xffffffff;
pthread_create(&tid1, NULL, Func1, &addr1);
pthread_t tid2 = 0;
pthread_create(&tid2, NULL, Func2, &addr2);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
四字节ip转为字符串还可以用inet_ntop，把IP地址转为字符串，把二进制转为文本，src参数就是IP地址，dst是一个char类型的缓冲区，定义一个buffer[]来保存转化好的字符串。
TCP协议中，服务器监听后，客户端就可以连接了，客户端的connect实际上是在发送报文，操作系统底层进行三次握手处理连接过程，处理完后服务端的accept接口就把这个创建好的连接给用户使用；close时是进行四次挥手来断开连接。建立和断开连接是用户让系统做的。建立时，客户端完成两次操作，服务端完成一次；断开时，双方都close，一次close对应两次操作。
结束。
1977
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
