一.编写TCP服务器

1.先搭一个架子

2.创建sockfd

domain参数依然是AF_INET(因为是IPV4)

type方式选择SOCK_STREAM（提供可靠的连接方式）

protocol协议类型默认缺省0

当然创建套接字是有可能失败的，所以这里加了一个日志(lg)文件，如果失败就打印日志（下面也会有该日志的完整源代码），注意：也可以直接打印在显示器上，但用日志更规范。

3创建并填充结构体

这里需要注意的是，填port时要使用htons函数转换成网络字节序（也就是大端），同时ip也要从字符串类型转换成int类型(有多种函数，这里选择inet_aton)。具体原因可以看上一篇博客（Udp）。

4.绑定内核

参数：1.绑定的套接字，2.绑定的结构体，3.结构体大小。

5.进行监听

TCP与UDP不同的是，它是面向连接的，服务器一般是比较“被动”的，服务器一直要处于等待连接的状态，我们一般称为监听。

6.对main函数进行构建，使用命令行传参方式传入端口号

7.接着编写Start部分代码

主要分为两步：1.获取新连接，2.根据新连接来通信。

这里的三个参数不必多说，关键在它的返回值也是一个套接字。它与最开始创建的套接字的功能划分不同，返回的这个套接字才是主要提供服务的。而最开始的套接字是帮助创建监听的，所以一般称它为listensock_。

8.编写服务代码

由于Tcp是面向字节流的，所以我们可以直接使用文件操作函数进行操作。

9.进行阶段性测试

由于还没有写客户端，所以我们可以使用telnet，它可以指定服务远程登陆，ip：127.0.0.1表示本地环回，端口号8888。如果没有该命令，可以yum -y install telnet。注意：下面我将Main.cc文件编译成了Tcpserver，启动该文件，在后面跟上端口号8888.

接着ctrl+6+]，然后回车，就可以发消息了。

退出：ctrl+6+]，输入quit。

二.编写Tcp客户端

1.创建套接字

2.绑定

客户端需要进行绑定吗？答案是需要的，但是不需要像服务器一样显示的绑定。因为无论是Udp还是Tcp，它都是socket进行通信，一定需要ip+port来进行区别，这样多个主机间才能进行区分。对于服务器来说，这个端口号要确定，因为其它客户端要对服务器发消息，就需要知道服务器的端口号。对于客户端来说，这个端口号是多少不重要，重要的是唯一，因为客户端对服务器发消息后，服务器就能通过结构体知道你的端口号和ip，所以客户端不需要显示的绑定。

Udp是在第一次发消息时绑定，而Tcp在发起connect时进行绑定。

在生活中，我们通过各种广告推广或者商店来获取服务器的ip和port，在这里我们修改一下main函数来收到传入服务器的ip和port。

3.测试

这样算是完成了一个框架，但有一个问题是目前是单进程，也就是说同时只能有一个客户端，很明显不符合预期，接下来改成多进程版。

三.多进程

首先为什么要close(listensockfd_)呢？因为我们只需要父进程一个提供监听功能就行了。为什么要close(sockfd)呢？因为我们将具体的服务功能交给了子进程，所以父进程就不需要这个fd了。当然这并没有完成多进程版，因为父进程会一直阻塞，有多种解决办法，这里选择再创建孙子进程，让子进程直接释放，孙子进程交给OS管理，这样父进程就不会阻塞了。（不了解的可以看看博客进程等待）

但是这种创建进程的成本实在太高了，一般连个三四十个就无了，所以为了高性能，我们可以搞一个多线程版本。

四.多线程版本

在创建线程后，我们使用pthread_detach，将主线程和其它线程分离，这样在其它线程提供服务时，主线程依然能自主运行。（不了解该函数的可以看博客线程（二））

对于线程创建不熟悉的可以看看博客线程（一），这里因为线程函数是在类内创建的，会自带一个this指针，不符合参数要求，所以改成静态的。接下来给线程函数进行传参。（由于线程函数是静态的，不能直接使用类内函数，所以我们可以将Tcpserver类一并当参数传入）

显然创建线程依然有代价，服务器在运行时一直有用户进入退出，所以会不断创建销毁，那么我们如何将线程多次利用呢？下面来线程池版。

五.线程池版+完整源代码

具体线程池代码如何写，可以看我的博客线程池，这里就直接使用了。简单来说就是向线程池里不断push任务，然后多个线程去竞争任务。 可以使用该命令检测线程个数ps -aL | head -1 && ps -aL | grep 程序名。

注意：为了保证服务器不被长时间连接，当前服务是只提供一次，使用客户端发消息时，每发一条就会重新建立一个连接。

makefile

.PHONY:all
all:Tcpserver TcpclientTcpserver:Main.ccg++ -o $@ $^ -std=c++11 -lpthread
Tcpclient:Tcpclient.ccg++ -o $@ $^ -std=c++11.PHONY:clean
clean:rm -f Tcpclient Tcpserver

log.hpp

#pragma once#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>#define SIZE 1024#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4#define Screen 1
#define Onefile 2
#define Classfile 3#define LogFile "log.txt"class Log
{
public:Log(){printMethod = Screen;path = "./log/";}void Enable(int method){printMethod = method;}std::string levelToString(int level){switch (level){case Info:return "Info";case Debug:return "Debug";case Warning:return "Warning";case Error:return "Error";case Fatal:return "Fatal";default:return "None";}}void printLog(int level, const std::string &logtxt){switch (printMethod){case Screen:std::cout << logtxt << std::endl;break;case Onefile:printOneFile(LogFile, logtxt);break;case Classfile:printClassFile(level, logtxt);break;default:break;}}void printOneFile(const std::string &logname, const std::string &logtxt){std::string _logname = path + logname;int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666); // "log.txt"if (fd < 0)return;write(fd, logtxt.c_str(), logtxt.size());close(fd);}void printClassFile(int level, const std::string &logtxt){std::string filename = LogFile;filename += ".";filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"printOneFile(filename, logtxt);}~Log(){}void operator()(int level, const char *format, ...){time_t t = time(nullptr);struct tm *ctime = localtime(&t);char leftbuffer[SIZE];snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,ctime->tm_hour, ctime->tm_min, ctime->tm_sec);va_list s;va_start(s, format);char rightbuffer[SIZE];vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);va_end(s);// 格式：默认部分+自定义部分char logtxt[SIZE * 2];snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);// printf("%s", logtxt); // 暂时打印printLog(level, logtxt);}private:int printMethod;std::string path;
};Log lg;

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;

Task.hpp

#pragma once
#include <iostream>
#include <string>
#include <string.h>
#include "log.hpp"extern Log lg;class Task
{
public:Task(int sockfd, const std::string &clientip, const uint16_t &clientport): sockfd_(sockfd), clientip_(clientip), clientport_(clientport){}Task(){}void run(){// 测试代码，收一个消息再发回去char buffer[4096];ssize_t n = read(sockfd_, buffer, sizeof(buffer));if (n > 0){buffer[n] = 0;std::cout << "client say#" << buffer << std::endl;std::string echo_string = "tcpserver echo#";echo_string += buffer;n=write(sockfd_, echo_string.c_str(), echo_string.size());if(n<0){lg(Warning, "write error,errorno:%d,errstring:%s", errno, strerror(errno));}}else if (n == 0) // 结束服务{lg(Info, "quit,sever close sockfd:%d", sockfd_);}else // 出错{lg(Warning, "read error,sockfd:%d,client port:%d,client ip:%s", sockfd_, clientport_, clientip_.c_str());}close(sockfd_);}void operator()(){run();}~Task(){}private:int sockfd_;std::string clientip_;uint16_t clientport_;
};

Tcpserver.hpp

#pragma once#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <signal.h>
#include <signal.h>
#include "Task.hpp"
#include "log.hpp"
#include "ThreadPool.hpp"
const int defaultfd = -1;
const std::string defaultip = "0.0.0.0";
const int backlog = 10; // 一般不要设置太大// 枚举错误代码，方便查阅
enum
{UseageError = 1,SocketError,BindError,ListenError,
};// //线程传参
// class ThreadData
// {
// public:
//   ThreadData(int fd,const std::string &ip,uint16_t &p,TcpServer*tp): sockfd(fd),clientip(ip),clientport(p),tsvr(tp)
//   {}
// public:
//   int sockfd;
//   std::string clientip;
//   uint16_t clientport;
//   TcpServer* tsvr;
// };class TcpServer
{
public:TcpServer(const uint16_t &port, const std::string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip){}void InitServer(){listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);if (listensockfd_ < 0) // 创建失败{lg(Fatal, "create listensockfd,errno:%d,errstring:%s", errno, strerror(errno));exit(SocketError);}// 如果成功，打印成功信息lg(Info, "create listensockfd sucess:%d", listensockfd_);// 创建并填充结构体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)); // 填充ip地址// 绑定if (bind(listensockfd_, (struct sockaddr *)&local, sizeof(local))) // 如果绑定失败{lg(Fatal, "bind listensockfd,errno:%d,errstring:%s", errno, strerror(errno));exit(BindError);}// 监听if (listen(listensockfd_, backlog) < 0) // 如果失败{lg(Fatal, "listen error,errno:%d,errstring:%s", errno, strerror(errno));exit(ListenError);}lg(Info, "listen sucess,listensockfd:%d", listensockfd_);}// //线程函数// static void* Routine(void*args)// {//   pthread_detach(pthread_self());//分离线程//   ThreadData*td=static_cast<ThreadData*>(args);//   td->tsvr->Serverce(td->sockfd,td->clientip,td->clientport);//提供服务//   delete td;//   return nullptr;// }void Start(){signal(SIGPIPE,SIG_IGN);ThreadPool<Task>::GetInstance()->Start();//启动线程池lg(Info, "tcpServer if running.....");while (true){// 1.获取新连接struct sockaddr_in client;socklen_t len = sizeof(client);int sockfd = accept(listensockfd_, (struct sockaddr *)&client, &len);if (sockfd < 0){lg(Warning, "accept error,errorno:%d,errstring:%s", errno, strerror(errno));continue;}// 接收客户端的port和ipuint16_t clientport = ntohs(client.sin_port);char clientip[32];inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));// 2.根据新连接进行通信lg(Info, "get a new link,sockfd:%d,client port:%d,client ip:%s", sockfd, clientport, clientip);// 3.服务//3.1 单进程版//Serverce(sockfd, clientip, clientport);//close(sockfd);//3.2 多进程版// pid_t id=fork();// if(id==0)//子进程// {//   close(listensockfd_);//   if(fork()>0) exit(0);//创建孙子进程，释放子进程//   Serverce(sockfd, clientip, clientport);//孙子进程提供服务//   close(sockfd);//服务完成，关闭服务//   exit(0);//退出进程// }// //父进程// close(sockfd);// pid_t rid=waitpid(id,nullptr,0);// (void)rid;//3.3多线程版本// ThreadData*td=new ThreadData(sockfd,clientip,clientport,this);// pthread_t tid;// pthread_create(&tid,nullptr,Routine,td);//3.4线程池版本Task t(sockfd, clientip, clientport);ThreadPool<Task>::GetInstance()->Push(t);}}// void Serverce(const int sockfd, const std::string &clientip, const uint16_t clientport)// {//   // 测试代码，收一个消息再发回去//   while (true)//   {//     char buffer[4096];//     ssize_t n = read(sockfd, buffer, sizeof(buffer));//     if (n > 0)//     {//       buffer[n] = 0;//       std::cout << "buffer say#" << buffer << std::endl;//       std::string echo_string = "tcpserver echo#";//       echo_string += buffer;//       write(sockfd, echo_string.c_str(), echo_string.size());//     }//     else if(n==0)//结束服务//     {//       lg(Info,"quit,sever close sockfd:%d",sockfd);//       break;//     }//     else//出错//     {//       lg(Warning, "read error,sockfd:%d,client port:%d,client ip:%s", sockfd, clientport, clientip.c_str());//       break;//     }//   }// }~TcpServer(){}private:int listensockfd_; // 监听套接字std::string ip_;   // ip地址uint16_t port_;    // 端口号
};

Tcpclient.cc

#include <iostream>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>void Usage(char *proc)
{std::cout << "\n\rUsage:" << proc << "severip serverport" << std::endl;
}int main(int argc, char *argv[])
{if (argc != 3){Usage(argv[0]);exit(1);}// 获取服务器的ip和portstd::string serverip = argv[1];uint16_t serverport = std::stoi(argv[2]);// 填充结构体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));while (true){// 创建套接字int sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0){std::cerr << "socket error" << std::endl;return 1;}// 进行连接int n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));if (n < 0) // 如果连接失败{std::cerr << "connect error...." << std::endl;return 2;}// 测试代码std::string message;std::cout << "Please Enter#";getline(std::cin, message);n = write(sockfd, message.c_str(), message.size());if (n < 0){std::cerr << "write error....." << std::endl;continue;}char buffer[4096];n = read(sockfd, buffer, sizeof(buffer));if (n > 0){buffer[n] = 0;std::cout << buffer << std::endl;}close(sockfd);}return 0;
}

Main.cc

#include"Tcpserver.hpp"
#include<memory>void Usage(std::string proc)
{std::cout<<"\n\rUsage:"<<proc<<"port[1024+]\n"<<std::endl;
}int main(int argc,char*argv[])
{if(argc!=2)//如果传参数不对，提醒一下{Usage(argv[0]);exit(UseageError);}uint16_t port=std::stoi(argv[1]);std::unique_ptr<TcpServer> tcp_svr(new TcpServer(port));tcp_svr->InitServer();tcp_svr->Start();return 0;
}

六.使用示例