网络编程套接字(3): 简单的TCP网络程序
文章目录
- 网络编程套接字(3)
-
- 4. 简单的TCP网络程序
-
- 4.1 服务端创建
-
- (1) 创建套接字
- (2) 绑定端口
- (3) 监听
- (4) 获取新连接
- (5) 处理读取与写入
- 4.2 客户端创建
-
- (1)连接服务器
- 4.3 代码编写
-
- (1) v1__简单发送消息
- (2) v2_多进程版本
- (3) v3_多线程版本
- (4) v4_线程池版本
网络编程套接字(3)
4. 简单的TCP网络程序
4.1 服务端创建
(1) 创建套接字
还是之前udp部分的socket函数，这里只是简单说明一下与udp的差异
int socket(int domain, int type, int protocol);
只需将第二个参数type换成：
SOCK_STREAM: 基于TCP的网络通信，流式套接字，提供的是流式服务(对应TCP的特点：面向字节流)
(2) 绑定端口
还是和之前一样的接口
(3) 监听
UDP服务器的初始化操作只有2步，第一步：创建套接字，第二步：是绑定。但是TCP服务器是面向连接的，客户端在正式向TCP服务器发送数据之前，需要先与TCP服务器建立连接，然后才能与服务器进行通信。
因此TCP服务器需要时刻注意是否有客户端发来连接请求，此时就需要将TCP服务器创建的套接字设置为监听状态
listen for connections on a socket: 监听套接字上的连接
头文件:
#include (4) 获取新连接
客户端有新链接到来，服务端可以获取到新链接，这一步需要死循环获取客户端新链接。
accept a connection on a socket: 接收套接字上的连接
头文件:
#include 关于accept的返回值: 也是一个文件描述符
为什么又返回一个新的文件描述符？？返回的这个新的文件描述符跟旧的文件描述符_sockfd有什么关系？
感性理解:
对比listen监听套接字与accept函数返回的套接字
- listen监听套接字：用于获取客户端发来的连接请求。accept函数会不断从监听套接字当中获取新连接
- accept函数返回的套接字：用于为本次accept获取到的连接提供服务。
- 而listen监听套接字的任务只是不断获取新连接，而真正为这些连接提供服务的套接字是accept函数返回的套接字，而不是监听套接字。
(5) 处理读取与写入
因为TC 提供的是流式服务，所以这里利用read和write来实现读取与写入
4.2 客户端创建
4步：创建套接字，客户端向服务器发起连接请求，bind(不需要自己绑定，由OS自动分配)，处理数据读取与写入
(1)连接服务器
initiate a connection on a socket: 在套接字上发起连接
头文件:
#include
#include
函数原型:
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
参数说明:
第一个参数sockfd: 表示通过该套接字发起连接请求
第二个参数addr: 对方一端网络相关的属性信息
第三个参数addrlen: addr的长度
返回值：
连接成功: 返回0
连接失败: 失败返回-1，并设置错误码
4.3 代码编写
这里一共提供4个版本的tcp代码
err.hpp：这个代码是公用的后续不在给出
#pragma once
enum
{
USAGE_ERR=1,
SOCKET_ERR,
BIND_ERR,
LISTEN_ERR,
CONNECT_ERR,
};
(1) v1__简单发送消息
客户端向服务端发送消息，服务端收到后再把消息发回给客户端
tcpServer.hpp
#includetcpServer.cc
#include"tcpServer.hpp"
using namespace ns_server;
// ./tcp_server port
// 使用手册
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;
}
tcpClient.cc
#include运行结果:
(2) v2_多进程版本
v2版本是把单执行流服务器改成多进程版的服务器
-
在accept获取新连接成功后，fork创建创建子进程，此时子进程对外提供服务, 父进程只进行accept
-
父进程的文件描述符会被子进程继承，但并不是父子共用同一张文件描述符表，因为子进程会拷贝继承父进程的文件描述符表
-
对于套接字文件也是相同的，父进程创建的子进程也会继承父进程的套接字文件，此时子进程就能够对特定的套接字文件进行读写操作，进而完成对对应客户端的服务
关于阻塞等待与非阻塞等待
- 若采用阻塞式等待，那么服务端还是需要等待服务完当前客户端，才能继续获取下一个连接请求，此时服务端仍然是以一种串行的方式为客户端提供服务
- 若采用非阻塞式等待，虽然在子进程为客户端提供服务期间服务端可以继续获取新连接，但此时服务端就需要将所有子进程的PID保存下来，并且需要不断花费时间检测子进程是否退出
- 由此可见两种都有缺陷，所以我们可以考虑让服务端不等待子进程退出
常见的方式有两种：
- 捕捉SIGCHLD信号，将其处理动作设置为忽略。
- 让父进程创建子进程，子进程再创建孙子进程，子进程退出，让孙子进程为客户端提供服务，孙进程的回收工作由OS来承担
下面是创建孙进程的方案：
tcpServer.hpp
#includetcpServer.cc
#include"tcpServer.hpp"
using namespace ns_server;
// ./tcp_server port
// 使用手册
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;
}
tcpClient.cc
#include运行结果:
(3) v3_多线程版本
频繁的创建进程会给OS带来巨大的负担，并且创建线程的成本比创建线程高得多。因此在实现多执行流的服务器时最好采用多线程进行实现。
主线程创建出新线程后，也是需要等待新线程退出的，否则也会造成类似于僵尸进程这样的问题。但对于线程来说，如果不想让主线程等待新线程退出，直接线程分离即可，当这个线程退出时系统会自动回收该线程所对应的资源。
各个线程共享是同一张文件描述符表，也就是说服务进程（主线程）调用accept函数获取到一个文件描述符后，其他创建的新线程是能够直接访问这个文件描述符的。
所以不能关闭不要的套接字文件描述符，该文件描述符的关闭操作应该又新线程来执行。因为是新线程为客户端提供服务的，只有当新线程为客户端提供的服务结束后才能将该文件描述符关闭。
tcpServer.hpp
#includetcpServer.cc
#include"tcpServer.hpp"
using namespace ns_server;
// ./tcp_server port
// 使用手册
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;
}
tcpClient.cc
#include运行结果:
(4) v4_线程池版本
多线程版的问题：
- 每当有新连接到来时，服务端的主线程都会为该客户端创建提供服务的新线程，当服务结束时就会将新线程销毁，这样做既麻烦又效率低下，每当有新连接到来才开始创建提供服务的新线程
- 若有大量的客户端请求，此时服务端要为每一个客户端创建对应的服务线程。计算机中的线程越多，CPU的压力越大
线程池
- 在服务端预先创建一批线程，当有客户端请求连接时就让这些线程为客户端提供服务，此时客户端一来就有线程为其提供服务，而不是当客户端来了才创建对应的服务线程(减少了频繁创建线程的开销)
- 当某个线程为客户端提供完服务后，不要让该线程退出，而是让该线程继续为下一个客户端提供服务，如果当前没有客户端连接请求，则可以让该线程先进入休眠状态，当有客户端连接到来时再将该线程唤醒。
- 服务端创建的这一批线程的数量不能太多，此时CPU的压力也就不会太大
task.hpp
#pragma once
#includeLockGuard.hpp
#includethread.hpp
#includethreadPool_v4.hpp
#includetcpServer.hpp
#includetcpServer.cc
#include"tcpServer.hpp"
using namespace ns_server;
// ./tcp_server port
// 使用手册
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;
}
tcpClient.cc
#include运行结果:
ip serverport\n" <
// ./tcp_client serverip serverport
int main(int argc,char*argv[])
{
// 准备工作
if(argc!=3)
{
usage(argv[0]);
exit(USAGE_ERR);
}
string serverip=argv[1];
uint16_t serverport=atoi(argv[2]);
// 1.创建套接字
int sock=socket(AF_INET,SOCK_STREAM,0);
if (sock < 0)
{
cerr << "create socket error: " << strerror(errno) << endl;
exit(SOCKET_ERR);
}
// (2) 客户端要不要bind呢? 要
// 要不要自己bind呢? 不要, 因为client要让OS自动给用户进行bind
// (3) 要不要listen?不要, 客户端连别人, 永远都是别人listen; 要不要accept?不要, 服务器来连接
// 2. connect 客户端向服务器发起连接请求
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_port=htons(serverport);
server.sin_family=AF_INET;
// server.sin_addr.s_addr=INADDR_ANY; 绝对不是
inet_aton(serverip.c_str(),&(server.sin_addr)); // 字符串风格ip转成点分十进制
int cnt=5;
while(connect(sock,(struct sockaddr*)&server,sizeof(server))!=0) // 连接失败
{
sleep(1);
cout<<"正在给你重连, 重连次数还有: "<> ";
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 >>>"< }
运行结果:
