一 前言
前面已经写过udp服务器的实现了，那里说了很多编写服务器的所需知识，在tcp服务器实现中就不再赘述了。
二 服务端编写
大致接口如下。
./server + port端口号 启动时指明端口号
void usage(const std::string proc)
{
std::cout<<"Usage "<<proc<<" port"<<std::endl;
}
int main(int argc,char*argv[]) 解析命令行参数,第二个就是端口号
{
if(argc != 2)
{
usage(argv[1]);
std::cout<<"port error"<<strerror(errno)<<std::endl;
exit(USAGE_ERR);
}
u_int16_t port = atoi(argv[1]);将字符串的端口号转为数字,后续传给服务端类。
tcp->InitServer();
tcp->start();
return 0;
}然后我们就去实现类了，首先服务端必定要有端口号，而且一个公司部署的服务端的端口号是分配好的。还有个成员是保存套接字的，这个后面具体实现再提。
namespace server
{
class TcpServer
{
public:
TcpServer()
{
;
}
~TcpServer()
{
;
}
void InitServer()
{
}
void start()
{
}
private:
int listensocket_;
int port_;
};
};1 创建套接字
初始化，显然就是要打开网络文件，创建套接字，直接复制udp的实现。
// 1 创建套接字
listensocket_ = socket(AF_INET, SOCK_STREAM, 0);
if (listensocket_ < 0)
{
std::cout << "socket err" << std::endl;
exit(SOCKET_ERR);
}
std::cout << "socket success" << std::endl;2 开始绑定
注意:recv和sendto函数内部不会实现大小端转化，需要我们自己主机转网络序列。
// 2 绑定端口号和ip地址
struct sockaddr_in sock; // 头文件<netinet/in.h>
bzero(&sock, sizeof(sock));
sock.sin_addr.s_addr = INADDR_ANY; // 设置ip地址 表示所有的ip的地址
sock.sin_port = htons(port_);
sock.sin_family = AF_INET;
if (bind(listensocket_, (sockaddr *)(&sock), sizeof(sock)) < 0)
{
std::cout << "bind error " << strerror(errno) << std::endl;
exit(BIND_ERR);
}
std::cout << "bind success" << std::endl;3 监听
参数2后面提及协议再说。可以设个不大不小的整数。
listensocket_是我们先前创建套接字返回的文件描述符，这个描述符被用来监听了，监听的是客户端的链接请求，因为请求也是通信，所以我们要先创建套接字，如果有链接请求从网络中来，os会把链接请求转成数据保存在监听套接字对应的文件中，上层就从这个文件中读取链接。
// 3 开始监听
if (listen(listensocket_, backlog)) // 返回0,监听成功
{
std::cout << "listen error " << strerror(errno) << std::endl;
exit(LISTEN_ERR);
}4 启动服务器
当有请求来了，我们当然要调用函数去处理，参数很熟悉，sockfd是我们先前用的listensockt_，因为请求都在这个文件内。
void start()
{
while (true)
{
// 获取链接
struct sockaddr_in sock; // 头文件<netinet/in.h>
socklen_t len = sizeof(sock);
int socket = accept(listensocket_, (sockaddr *)&sock, &len); // 不保存吗
if (socket < 0)
{
// std::cout << "accept err" << std::endl;
exit(SOCKET_ERR);
}
std::cout << "accept success" << std::endl;
// 开始发消息,此时我们不能让主线程去发消息,不然就无法链接其它的客户端了
std::string clientip = inet_ntoa(sock.sin_addr);
u_int16_t clientport = ntohs(sock.sin_port);
server(sock,clientip, clientport)；
}
}
void server(int sock, std::string ip, uint16_t port)
{
;
}此时收到请求后，我们也就获得了客户端的ip和端口，接下来就用ip和端口传给server函数实现通信。可是为什么accept又返回一个文件描述符，为什么要有两个套接字呢?在udp服务器中我们只创建了一个文件，意味着所有客户端发来的消息都在这个文件中，读取的时候其实很容易读取到a客户端的数据处理完发给了b客户端，那对于a客户端来说，数据就缺失了，所以udp的通信确实是不考虑完不完整的，所以tcp为了保证客户端数据的独立性，就每接收一次链接就创建一个文件，内部一定会把客户端的ip和端口号和这个文件绑定，这样下次客户端的数据来的时候就会根据ip和端口号判断放在哪个文件中了。
接下来看看server函数内如何通信。直接调用read函数读，调用write函数写，奇怪，为什么先前udp服务器不可以用read，而是用recvfrom，也不是用write，而是用sendto，据我了解，read和write是面向字节流的，udp服务端我们打开文件的时候是指明面向数据报的，read用面向字节流读取面向数据报的文件会出问题。后面讲tcp，udp协议，了解了面向字节流和面向数据报就理解得更深刻了。
void server(int sock, std::string ip, uint16_t port)
{
char buffer[1024] = {0};
int n = read(sock, buffer, sizeof(buffer) - 1);
if (n > 0)
{
buffer[n] = 0;
// 写回给客户端
write(sock, ret.c_str(), ret.size());
}
else if (n == 0)
{
close(sock);
std::cout << name << " 断开连接" << std::endl;
}
else
{
close(sock);
exit(READ_ERR);
}
}可是直接输出又有点单调，所以我们做了些修改。调用回调方法对数据做处理。
func_就是func_t定义的变量，可以接收一个可调用对象，这个可调用对象的类型是string(string)，也就是返回值是string，参数也是string。
数据处理方法由外部定义。如下就是完整的定义服务端对象和启动。
std::string echo(std::string message)
{
return message;
}
int main(int argc,char*argv[])
{
if(argc != 2)
{
usage(argv[1]);
std::cout<<"port error"<<strerror(errno)<<std::endl;
exit(USAGE_ERR);
}
u_int16_t port = atoi(argv[1]);
std::shared_ptr<TcpServer> tcp = std::make_shared<TcpServer>(echo,port);
tcp->InitServer();
tcp->start();
return 0;
}相应构造函数也要修改。
三 客户端编写
同样客户端不用自己bind。那要不要listen，accept呢? 我认为是不需要的，这两个函数的意义在于等待别人来链接，一般来说都是客户端主动连接服务端，很少有服务端来主动找客户端的，并且获取链接方便后面给对方发数据，前面还说了可以保证服务端收到来自客户端数据的独立和安全。
而客户端本身不用担心多个服务端发来的数据混杂，虽然我们手机上有多个客户端，但是我们的客户端都是一个个进程，创建的套接字文件是独立的，服务端是因为会有多个客户端和它通信才要创建多个文件，我们这里是一个客户端对应一个服务端。所以通信步骤如下。
1 创建套接字
2 发起链接
用的是下面这个connect函数，参数列表也是非常熟悉。
直接开始准备初始化sock结构体。
因为我们不能一链接失败就退出，要尝试重连几次，就像我们打游戏没网，也是会有尝试重连选项的。
int main(int argc, char *argv[]) ip地址不能是任意的，必须知道服务端的ip地址和端口号
{
if (argc != 3)
{
usage(argv[0]);
std::cout << "stage error" << strerror(errno) << std::endl;
exit(USAGE_ERR);
}
const std::string ip_ = argv[1];
u_int16_t port = atoi(argv[2]);
int socket_ = socket(AF_INET, SOCK_STREAM, 0);
if (socket_ < 0)
{
std::cout << "create socket error" << strerror(errno) << std::endl;
exit(SOCKET_ERR);
}
std::cout << "create socket successs" << std::endl;
// 打开网络文件
// 不用客户端自己绑定端口号和ip地址
struct sockaddr_in sock;
sock.sin_addr.s_addr = inet_addr(ip_.c_str()); // 将字符串类型的地址转为四字节地址,而且是网络字节序了
sock.sin_port = htons(port);
sock.sin_family = AF_INET;
int len = sizeof(sock);
// 开始连接
int timenum = 5;
while (connect(socket_, (sockaddr *)&sock, len) < 0)
{
sleep(1);
std::cout << "开始重连:" << std::endl;
timenum--;
if (timenum == 0)
break;
}
if (timenum <= 0)
{
std::cout << "链接失败" << std::endl;
exit(CON_ERR);
}
return 0;
}接下来就是我们客户端直接把消息写到文件中，然后read读取服务端返回的数据。
四 实验测试
测试1
服务端bug：如果客户端不给我们发消息，我们就会阻塞在read这里，就不能调用accept接收新连接了，所以我们应该安排一个线程去调用server函数来收发消息。
注意:我服务端代码里的server函数只能读一次和发一次消息给客户端，如果写成死循环后面引进线程池还会出问题，因为线程数量有限，多个客户端来链接，线程就会不够，这里不会，因为此时我们是一个线程负责收发消息给一个客户端。
void *recv(void *arg)
{
// 收消息
int socket_ = *((int *)arg);
while (true)
{
char buffer[1024] = {0};
int n = read(socket_, buffer, sizeof(buffer) - 1);
if (n > 0)
{
buffer[n] = '\0';
std::cout << "server echo# " << buffer << std::endl;
}
else if (n == 0)
{
close(socket_);
std::cout << "server quit" << std::endl;
}
else
{
close(socket_);
std::cout << "client read err" << strerror(errno) << std::endl;
exit(READ_ERR);
}
}
}
void start()
{
while (true)
{
// 获取链接
struct sockaddr_in sock; // 头文件<netinet/in.h>
bzero(&sock, sizeof(sock));
socklen_t len = sizeof(sock);
int socket = accept(listensocket_, (sockaddr *)&sock, &len); // 不保存吗
if (socket < 0)
{
lg_(ErrorLevel::Info,"accept err");
// std::cout << "accept err" << std::endl;
exit(SOCKET_ERR);
}
std::cout << "accept success" << std::endl;
// 开始发消息,此时我们不能让主线程去发消息,不然就无法链接其它的客户端了
std::string clientip = inet_ntoa(sock.sin_addr);
u_int16_t clientport = ntohs(sock.sin_port);
pthread_t id;
pthread_create(&id,nullptr,recv,ThreadDta);
}
}
ThreadData类内包含ip和端口，server函数实现也被放入了静态成员函数recv中，我这里只是演示一下，只会把最后版本放出来下面我们引入线程池来做优化，我们希望在accept链接前就创建好线程了，提高响应速度。
引进线程池
线程池:内部负责创建线程，我们外部构建任务，放入线程池中，内部线程池会去执行。
先来看看任务构建，外部传入一个套接字，ip，端口号，可调用对象构建任务，线程拿到任务后调用可调用对象。
#define NUM 5
class Task
{
public:
using func_t = std::function<void(int,std::string,u_int16_t)>;
Task()
{
;
}
Task(int sock,std::string ip,uint16_t port,func_t func)
: socket_(sock), ip_(ip), port_(port),func_(func)
{
;
}
void operator()()
{
func_(socket_,ip_,port_);
}
int socket_;
func_t func_;
std::string ip_;
u_int16_t port_;
};
使用如下，构建任务，并且入队列，这里面还用了bind语法。
然后我大致说一下线程池内部实现，以及我们什么时候控制线程池去执行任务。成员如下，有任务队列保存任务，还有vector<Thread>保存多个线程。
我们线程池内存的也不是线程id，而是封装后的Thread类。代码如下，可以不关心内部实现。
class Thread
{
public:
typedef enum
{
NEW = 1,
RUNING,
EXIT
}status;
typedef void* (*fun_t)(void*);
Thread()
{
;
}
Thread(int num, fun_t fun, void* arg)
:id_(0),fun_(fun),arg_(arg),status_(NEW)
{
name_ = "thread->" + std::to_string(num);
}
~Thread()
{
;
}
static void * threadRun(void*arg)
{
Thread* th = (Thread*) arg;
th->fun_(th->arg_);
return nullptr;
}
void Run()
{
int n = pthread_create(&id_,nullptr,threadRun,(void*)this);
if(n != 0)//成功返回0，不成功返回错误码
exit(4);
status_ = RUNING;
}
void join()
{
pthread_join(id_,nullptr);
status_ = EXIT;
}
std::string getname()
{
return name_;
}
int getstatus()
{
return status_;
}
pthread_t getid()
{
if(status_ == RUNING)
return id_;
else
{
std::cout<<name_<<" not create ";
return 1;
}
}
pthread_t id_;
std::string name_;//线程名
status status_;//线程状态
fun_t fun_;//线程执行函数
void* arg_;//线程参数
};我们只需要知道我们要线程池初始化thread对象时要传一个执行函数和参数即可，i就是内部用来构建线程名的，不用关心。
外部通过线程池的静态函数获取单例对象。
线程池内调用Thread类内方法创建线程。
Thread类内的Run方法。
线程池内部实现。
template <class T>
class threadPool
{
threadPool(int size = NUM) // vp_存的自定义类型要有默认构造,不然这里初始化会找不到默认构造!
: vp_(size)
{
pthread_mutex_init(&mutex_, nullptr);
pthread_cond_init(&Consumer, nullptr);
pthread_cond_init(&Productor, nullptr);
}
~threadPool()
{
for (auto &e : vp_) // 复用Thread join方法回收线程
{
e.join();
}
pthread_mutex_destroy(&mutex_);
pthread_cond_destroy(&Consumer);
pthread_cond_destroy(&Productor);
}
threadPool(const threadPool<T>& sh) = delete;
threadPool<T> operator=(const threadPool<T>& sh) = delete;
public:
void init()
{
for (int i = 0; i < NUM; i++)
{
vp_[i] = (Thread(i, threadRun, this));//this指针是给内部传参数的
}
}
void Lock()
{
pthread_mutex_lock(&mutex_);
}
void Unlock()
{
pthread_mutex_unlock(&mutex_);
}
static void *threadRun(void *arg)
{
// pthread_detach(pthread_self());
threadPool<T> *tp = static_cast<threadPool<T> *>(arg);
// 执行任务
while (true)
{
T data;
tp->pop(data);
data();
}
}
bool Full()
{
return tasks_.size() == NUM;
}
bool Empty()
{
return tasks_.size() == 0;
}
void start()
{
for (auto &e : vp_) // 复用Thread Run方法创建线程
{
e.Run();
}
}
void push(const T &data)
{
{
LockGuard lg(&mutex_);
while (Full())
{
pthread_cond_wait(&Productor, &mutex_);
}
tasks_.push(data);
}
pthread_cond_signal(&Consumer);
}
void pop(T &data)
{
{
LockGuard lg(&mutex_);
// 检查是否有任务
while (Empty())
{
pthread_cond_wait(&Consumer, &mutex_);
}
data = tasks_.front();
tasks_.pop();
}
pthread_cond_signal(&Productor);
}
static threadPool<T>* getthreadPool()
{
if(tp_ == nullptr)//减少加锁次数
{
LockGuard lg(&Poolmutex_);
if (tp_ == nullptr)
{
tp_ = new threadPool<T>();
tp_->init();
tp_->start();
}
}
return tp_;
}
std::queue<T> tasks_; // 任务队列
std::vector<Thread> vp_; // 线程池,不能存指针,内部要解引用访问的
pthread_mutex_t mutex_;
pthread_cond_t Consumer;
pthread_cond_t Productor;
static threadPool<T>* tp_;
static pthread_mutex_t Poolmutex_;
};
template<class T>
threadPool<T>*threadPool<T>::tp_ = nullptr;
template<class T>
pthread_mutex_t threadPool<T>::Poolmutex_ = PTHREAD_MUTEX_INITIALIZER;
综上，外部线程获取单例线程池对象并且push任务到队列，内部线程pop任务出来并执行。由于我们的线程池并没有设计扩容功能，所以线程是有限的，而线程池内部线程执行的任务是我们外部传入的server函数，如果server函数是个死循环，就会导致无法执行其它客户端的任务，所以我们把server函数内的死循环改了。
五 守护进程
1 概念介绍
为什么要有守护进程呢?
因为我们目前起的进程如果把中端窗口一关闭，此时就会导致服务停了，那总不能让屏幕一直开着吧，所以我们让这个进程在后台运行，也就是守护进程化。
我们以前在讲进程状态的时候，用过下面这条命令，但是有几个成员一直没提及，那就是PGID和SID以及TTY。
PGID表是进程组，我们在命令行可以一次性起多个进程，这些进程都被归属于某个进程组被管理起来，进程组id一般是第一个创建的进程id，例如我们./server起了一个进程，这个进程内部也起了多个进程，此时这些进程都会被划分在一个进程组中，此时组长是server。
tty表示终端文件，终端就是我们打开xshell显示的那个窗口，所以当我们在命令行输入指令，都是云服务将结果输出到文件，文件经过网络发送到我们的主机上。
在一个终端下起的进程的终端文件是一样的，父进程是一样的，都是bash，而且还都属于某个进程组，进程组以第一个创建的进程id命名，不是bash。例如sleep 100 | sleep 100 &我们就在后台一次性起了两个进程，它们属于一个进程组。
所以./server不再是启动一个进程了，我们应该说是启动一个任务，因为serve程序内部可能也会创建进程，所以需要一个更大的概念-任务来描述，jobs可以查看当前会话的任务。
左侧的是任务码，我们可以把一个后台拉到前台运行，fg+ 任务码，然后ctrl+c就可以结束这个进程了。
将前台的任务回退为后台，Ctrl+z。
细节，当我们把sleep拉回前台运行时，此时bash命令就没了，因为我们./server就是把一个任务变成了前台，bash就变成后台，一个终端只能有一个前台进程，可以简单理解前台进程就是要和我们的键盘交互的，我们只能给一个进程喂指令，所以一个终端只有一个前台进程，当我们ctrl+z把前台进程变成后台进程后，此时bash命令行又回来了，因为它自动把自己变成前台进程了。
那什么是SID呢，我们称为会话id，22103其实是我们的bash进程，会话id以一个会话内的首进程id命名，什么是会话呢?当我们登录xshell时，linux就会建立一个会话，将bash以及bash创建进程管理在其中，有时候bash创建的进程(例如./server)内部又创建了许多进程，为了将server和它创建的进程关联起来，就有了进程组。
注销的理解：以前我们的电脑上是有个注销选项的，注销和重启是不同的，注销是删掉会话内的所有进程，重启则是整个系统进程都要重启了。守护进程化，就是对server进程独立开一个会话，这样用户注销就不会影响我这个守护进程了。使用如下接口。
返回值:会话ID。
2 守护进程化实现
void Daemon()
{
pid_t ret = setsid();
if((int)ret == -1)
{
cout<<"setsid err:错误码: "<<errno<<" 错误信息:"<<strerror(errno)<<endl;
exit(SETSID_ERR);
}
}然后我们在server.cc中调用一下，我们整个进程就变成守护进程啦。对进程组的其它进程无影响?如果我们是像这里一样实现的话，大概率会出错，首先我们这里只有一个server进程，
server进程就必定是组长，组长进程不能从会话中独立出去，为什么不能走呢，我想是因为组长进程内有着管理组内进程的方法，如果走了就管理不了其它的进程了，深究的话就得讨论为什么组长走了就不能管理其它进程了，难道我们不能再选一个组长吗? 当然我说的容易，实现起来可能比较冗余，所以就禁止我们对组长进程进行守护进程化。
优化如下。
我们在Daemon()函数中创建子进程，让父进程退出，此时子进程就变成孤儿进程了，被os接管了，此时这个孤儿进程不会是组长，此时孤儿进程再将自己独立出去。
变成守护进程后，一直在后台执行start函数，这个函数内是在接收链接，并且创建任务到队列中，让内部的线程池去执行通信任务。
然后我们还要忽略一些常见错误信号，让我们的守护进程不会随随便便就退出。
signal(SIGPIPE,SIG_IGN);
signal(SIGCHLD,SIG_IGN);已经成为守护进程了，就不应该和键盘显示器关联了，我们可以直接关闭显示器和键盘文件，但是这样我们使用cout,cin会直接出错。所以我们打开一个特殊文件，让cin读不到数据，直接返回，写入的数据也会被丢弃。
//守护进程化
void Daemon()
{
子进程去创建新会话
if(fork() > 0)
exit(0);
pid_t ret = setsid();
if((int)ret == -1)
{
cout<<"setsid err:错误码: "<<errno<<" 错误信息:"<<strerror(errno)<<endl;
exit(SETSID_ERR);
}
int fd = open("/dev/null",O_RDWR);
if(fd < 0)
{
cout<<"open err:错误码: "<<errno<<" 错误信息:"<<strerror(errno)<<endl;
exit(OPEN_ERR);
}
//关闭输入输出
dup2(fd,0);
dup2(fd,1);
dup2(fd,2);
}守护进程只能kill掉。
