目录
之前有讲过基于UDP的网络编程一些基础的知识，现在看看基于TCP的网络编程。
首先TCP与UDP最大的不同是TCP是面向连接的，可靠传输。所以在编程实现方面有很多不同的地方，接下来看看具体的细节。
服务器端
在初始化的过程中，与UDP的方式有很多相同的地方，例如创建套接字，绑定端口号。而在TCP除了上述的操作以外还需要进行监听，即把套接字变成监听套接字。
初始化
class tcpServer
{
private:
int _port;
int _lsock;
public:
tcpServer(int port = 8080)
:_port(port)
{}
//初始化
void initServer()
{
_lsock = socket(AF_INET,SOCK_STREAM,0);//创建套接字
if(_lsock < 0)
{
cerr<<"sock error!"<<endl;
exit(1);
}
sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(_port);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(_lsock,(struct sockaddr*)&local,sizeof(local)) < 0)//绑定端口和ip地址
{
cerr<<"bind error!"<<endl;
exit(2);
}
//进行监听
if(listen(_lsock,5) < 0)//队列长度设置为5（实际底层大小为6）
{
cerr<<"listen error!"<<endl;
exit(3);
}
}
};
listen 函数
listen函数将套接字变为监听套接字，第一个参数就是传递创建好的套接字，第二个参数使用来确定最大接收连接的数量，这个地方涉及到全连接队列的知识，在后面说TCP协议的细节的时候在说一下这个参数，本身的目的是让系统效率最大化，不过这个参数不能太大。
服务器启动
当服务器启动之后需要接收来自客户端的连接。
accept函数
第一个参数是监听套接字（listen过后的套接字），第二个参数、第三个参数是输出型参数。
返回值
注意：返回值是一个文件描述符，也是一个socket，很关键，这个文件描述符就是实际通信过程中所需的文件描述符。
如果队列上不存在挂起的连接，并且套接字未标记为非阻塞，则accept（）会阻塞调用方，直到存在连接为止。如果套接字标记为非阻塞，并且队列中不存在挂起的连接，则accept（）将失败，并出现错误EAGAIN或EWOLDBLOCK。
void start()
{
sockaddr_in remote;
socklen_t len = sizeof(remote);
while(true)
{
int sock = accept(_lsock,(struct sockaddr*)&remote,&len);
if(sock < 0)
{
cerr<<"accept error"<<endl;
continue;//这里失败不退出，继续等待连接
}
cout<<"get a new link"<<endl;
service(sock);//对连接进行处理
}
}
当获得到连接之后，需要对连接进行处理，自定义一下处理动作
void service(int sock)
{
char buf[1024];
while(true)
{
ssize_t s = recv(sock,buf,sizeof(buf)-1,0);
if(s > 0)
{
buf[s] = '\0';
cout<<buf<<endl;//对收到的信息打印到命令行
string echo(buf);
echo+=" echo Server";
send(sock,echo.c_str(),echo.size(),0);//返回给客户端
}
else if(s == 0)//读到0表示客户端已经退出
{
cout<<"client is quit!"<<endl;
break;
}
else
{
cout<<"recv error!"<<endl;
}
}
close(sock);//记得结束后关闭文件描述符
}其中有两个函数，一个recv函数，一个是send函数。
recv函数
在UDP里面讲过一个recvfrom函数，recvfrom函数针对UDP，需要告知是谁发过来的，有一个输出型的参数，而recv没有，因为TCP在接收连接（accept）的时候已经知道是谁发过来的，所以可以不用recvfrom函数。
参数分别是套接字、接收数据buf、期望接收的大小和阻塞接收标志flag。flag=0表示阻塞。
返回值
返回值为实际读到多少字节的数据，读到0表示对方已经断开连接，读到-1表示出错。
send函数
和sendto是一类接口，不过send是面向TCP的，不需要指名发给谁，因为TCP已经把连接建立好了，文件描述符在底层绑定了对方的ip地址和端口号。
可以发现这一批接口和系统IO中的read和write很相似，此时这两组接口都是面向字节流的（TCP就是面向字节流的），也就是说我们用read和write也可以直接读取套接字里面的数据或者往套接字里面写入数据。
int main(int argc,char* argv[])
{
if(argc != 2)
{
cerr<<"parameter error!"<<endl;
exit(1);
}
tcpServer *us = new tcpServer(atoi(argv[1]));
us->initServer();
us->start();
return 0;
}
测试服务器
运行一下
补充一个工具telnet
telnet是远程终端协议，是TCP/IP协议家族的成员之一，默认端口23。用来测试网络。
用telnet工具来作为客户端测试一下服务器。
首先需要安装一下：sudo yum install telnet telnet-server
退出就是在telnet命令模式下ctrl ] 输入quit
客户端
与UDP不同的是，客户端需要发起连接
connect函数
第一个参数是文件描述符，第二个第三个参数想必已经不陌生了，需要对方的ip地址和端口号信息，以结构体的形式传递参数。
class tcpClient
{
private:
string _ip;
int _port;
int sock;
public:
tcpClient(string ip = "127.0.0.1",int port = 8080)
:_ip(ip)
,_port(port)
{}
void initClient()
{
sock = socket(AF_INET,SOCK_STREAM,0);//SOCK_STREAM面向字节流
if(sock < 0)
{
cerr<<"sock error!"<<endl;
exit(1);
}
struct sockaddr_in remote;//绑定目的ip地址与端口号
remote.sin_family = AF_INET;
remote.sin_port = htons(_port);
remote.sin_addr.s_addr = inet_addr(_ip.c_str());
if(connect(sock,(struct sockaddr*)&remote,sizeof(remote)) != 0)//连接请求
{
cerr<<"connect error!"<<endl;
exit(2);
}
}
};初始化完成后进行通信，这里就比较简单，自定义函数。
void start()
{
while(true)
{
string msg;
cout<<"please enter msg# ";
cin>>msg;
send(sock,msg.c_str(),msg.size(),0);
char echo[128] = {'\0'};
ssize_t s = recv(sock,echo,sizeof(echo)-1,0);
if(s > 0)
{
echo[s] = '\0';
cout<<"get msg from Server: "<<echo<<endl;
}
}
}
主函数
int main(int argc,char* argv[])
{
if(argc != 3)
{
cerr<<"parameter error!"<<endl;
exit(1);
}
tcpClient *uc = new tcpClient(argv[1],atoi(argv[2]));
uc->initClient();
uc->start();
return 0;
}
运行结果
上述程序面临的一些问题
面对多个请求如何实现？
代码改进
只针对服务器
1、多进程版本
修改一下start函数
void start()
{
sockaddr_in remote;
socklen_t len = sizeof(remote);
while(true)
{
int sock = accept(_lsock,(struct sockaddr*)&remote,&len);
if(sock < 0)
{
cerr<<"accept error\n"<<endl;
continue;
}
pid_t id = fork();
if(id == 0)
{
close(_lsock); //子进程不关心监听套接字，直接关闭
service(sock);
exit(0);
}
close(sock);//由于交给子进程处理，父进程不需要关心sock
cout<<"get a new link"<<endl;
//子进程退出，一些方法回收资源
//1、父进程等待（不能阻塞等待）
//2、自定义捕捉信号SIGCHLD
//3、将SIGCHLD信号忽略
}
}
这里有很多细节
1、由于子进程会按照父进程的模板来创建，所以文件描述符资源也对应相同，子进程需要关闭一些自己并不关心的文件描述符资源，父进程也是如此。
2、子进程的退出，子进程的资源需要回收，此时需要父进程来处理（注意，不是父进程回收，父进程只是发起回收这个动作，实质上是内核完成资源的回收）。一般来说父进程需要等待（wait/waitpid）。还有一些其他的方法，比如说自定义捕捉（针对SIGCHLD信号），或者直接忽略，将资源交给内核回收。
忽略比较简单，在初始化那里加一行代码 signal(SIGCHLD,SIG_IGN);
测试：
同时有三个连接请求，将前两个进程放在后台
查看当前进程信息，三个客户端Client进程，三个子进程Server在处理连接，一个父进程Server。
这样服务器就可以同时应对多个连接。
但是多进程的方式资源消耗比较大，且进程间的切换开销也很大。引入多线程版本。
2、多线程版本
static void* service_routine(void* arg)
{
pthread_detach(pthread_self());//分离线程，避免主线程阻塞等待释放资源
cout<<"creat thread successfully,tid is "<<pthread_self()<<endl;
int *p = (int*)arg;
service(*p);//此时service也需要是静态函数
return nullptr;
}
void start()
{
sockaddr_in remote;
socklen_t len = sizeof(remote);
while(true)
{
int sock = accept(_lsock,(struct sockaddr*)&remote,&len);
if(sock < 0)
{
cerr<<"accept error\n"<<endl;
continue;
}
cout<<"get a new link"<<endl;
pthread_t tid;
pthread_create(&tid,nullptr,service_routine,(void*)&sock);//创建线程去执行通信
}
}
需要注意的几个点
1、由于在类里面，线程处理的函数得是静态函数，因为函数参数这里有一个隐藏的this指针，所以可以处理成静态函数的方式舍弃this指针，由于静态函数没有this指针，所以也无法调用类里面的service函数，此时也要把service设置为静态函数。
2、线程退出时也需要主线程释放资源，如果用pthread_join函数去释放资源，主线程会陷入阻塞状态，在上一个线程为退出的状态下，无法接收新的连接，所以可以采用分离线程的方式。
三种版本的比较
1、单进程：一般不使用
2、多进程版本：健壮性强，比较吃资源，效率低下
3、多线程版本：健壮性不强，较吃资源，效率相对较高
当大量客户端需要接入时，系统会存在大量的执行流。此时切换是影响效率的重要原因
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
