Linux网络套接字编程(2)-TCP传输+多线程+多进程
TCP传输
TCP的三次握手
图解为TCP协议的传输过程。
| 客户端操作 | 服务端操作 |
|---|---|
| 1、创建套接字 | 1、创建套接字 |
| 2、向服务端发起连接 | 2、绑定地址信息 |
| 3、发送数据 | 3、监听(若有新的客户端，新建socket) |
| 4、接收数据 | 4、接收已经连接成功的socket |
| 5、关闭套接字 |
TCP传输-socket编程
通过C++实现一个类来封装tcp协议
//tcpsocket.hpp
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define CHECK_RET(q) if((q) == false){return -1;}
class TcpSocket
{
public:
TcpSocket() : _sockfd(-1){
}
void SetSockFd(int fd){
_sockfd = fd;
}
bool Socket() {
_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (_sockfd < 0) {
perror("socket error");
return false;
}
return true;
}
bool Bind(std::string &ip, uint16_t port){
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
socklen_t len = sizeof(struct sockaddr_in);
int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("bind error");
return false;
}
return true;
}
bool Listen(int backlog = 10) {
//int listen(int sockfd, int backlog);
//backlog:最大并发连接数--内核中已完成连接队列的最大节点数
int ret = listen(_sockfd, backlog);
if (ret < 0) {
perror("listen error");
return false;
}
return true;
}
bool Connect(std::string &ip, uint16_t port) {
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
socklen_t len = sizeof(struct sockaddr_in);
int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("connect error");
return false;
}
return true;
}
bool Accept(TcpSocket &csock, struct sockaddr_in *addr = NULL){
struct sockaddr_in _addr;
socklen_t len = sizeof(struct sockaddr_in);
int newfd = accept(_sockfd, (struct sockaddr*)&_addr, &len);
if (newfd < 0) {
perror("accept error");
return false;
}
if (addr != NULL) {
memcpy(addr, &_addr, len);
}
csock.SetSockFd(newfd);
//_sockfd--仅用于接收新客户端连接请求
//newfd----专门用于与客户端进行通信
return true;
}
bool Recv(std::string &buf) {
char tmp[4096] = {0};
int ret = recv(_sockfd, tmp, 4096, 0);
if (ret < 0) {
perror("recv error");
return false;
}else if (ret == 0) {
printf("peer shutdown\n");
return false;
}
buf.assign(tmp, ret);
return true;
}
bool Send(std::string &buf) {
int ret = send(_sockfd, buf.c_str(), buf.size(), 0);
if (ret < 0) {
perror("send error");
return false;
}
return true;
}
bool Close() {
close(_sockfd);
_sockfd = -1;
}
private:
int _sockfd;
};
tcp传输客户端
#include "tcpsocket.hpp"
int main(int argc, char *argv[])
{
if (argc != 3 ) {
std::cout<<"./tcp_cli ip port\n";
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);
TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Connect(ip, port));
while(1) {
std::string buf;
std::cout<<"client say:";
fflush(stdout);
std::cin>>buf;
sock.Send(buf);
buf.clear();
sock.Recv(buf);
std::cout<<"server say:"<tcp传输服务端
#include "tcpsocket.hpp"
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("./tcp_srv ip port\n");
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);
TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Bind(ip, port));
CHECK_RET(sock.Listen());
while(1) {
TcpSocket clisock;
struct sockaddr_in cliaddr;
//accept是阻塞获取已经完成的连接
if (sock.Accept(clisock, &cliaddr) == false) {
continue;
}
printf("new connect client:%s:%d\n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
std::string buf;
clisock.Recv(buf);
printf("client say:%s\n", buf.c_str());
buf.clear();
std::cout<<"server say:";
fflush(stdout);
std::cin>>buf;
clisock.Send(buf);
}
sock.Close();
return 0;
}
运行截图如上
TCP的传输运行结果与UDP的传输运行结果不同
这是因为在UDP的传输无连接，不可靠，面向数据报
但是TCP的传输不同是建立连接，可靠传输，面向字节流
所以基本的tcp服务端只能与一个客户端通信一次，无法实现同时与多个客户端多次通信
如何快速判断连接是否已经断开
tcp的连接管理中，内建有保活机制。当长时间没有数据来往的时候，每隔一段时间都会向对方发送一个保活探测包，要求对方回复，当多次发送保活探测包都没有响应，则认为连接断开。
若连接断开，则recv会返回0，send会触发异常SIGPIPE(导致进程退出)。recv返回0不是代表没有接收数据的意思，而是说明连接已经断开。
在TCP连接过程中，因为面向字节流，有可能接收到半条数据，因此一定要对返回值进行判断，判断数据是否已经完全接收或者完全发送。
多进程版本tcp服务端
通过使用多进程来完成多个客户端的请求处理
将之前的通用版本改为多线程版本即可
#include
#include
#include "tcpsocket.hpp"
void sigcb(int no){
while (waitpid(-1, NULL, WNOHANG) > 0);
}
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("./tcp_srv ip port\n");
return -1;
}
signal(SIGCHLD, sigcb);
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);
TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Bind(ip, port));
CHECK_RET(sock.Listen());
while(1) {
TcpSocket clisock;
struct sockaddr_in cliaddr;
//accept是阻塞获取已经完成的连接
if (sock.Accept(clisock, &cliaddr) == false) {
continue;
}
printf("new connect client:%s:%d\n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
int pid = fork();
if (pid == 0) {
while(1){
std::string buf;
clisock.Recv(buf);
printf("client say:%s\n", buf.c_str());
buf.clear();
std::cout<<"server say:";
fflush(stdout);
std::cin>>buf;
clisock.Send(buf);
}
}
clisock.Close();
}
sock.Close();
return 0;
}
先进行多个客户端连接，在左上角的服务端可以看到有三个新的客户端进行了连接成功
这时候相继发送消息，服务端的回复顺序是根据接收客户端发送数据的顺序进行回复的
哪怕有其他客户端抢先回答了，服务端还是按照发送数据的顺序依次给客户端进行发送数据
多线程版本tcp服务端
#include
#include "tcpsocket.hpp"
void *thr_start(void *arg){
TcpSocket *sock = (TcpSocket*)arg;
while(1) {
std::string buf;
sock->Recv(buf);
printf("client say:%s\n", buf.c_str());
buf.clear();
std::cout<<"server say:";
fflush(stdout);
std::cin>>buf;
sock->Send(buf);
}
sock->Close();
delete sock;
return NULL;
}
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("./tcp_srv ip port\n");
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);
TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Bind(ip, port));
CHECK_RET(sock.Listen());
while(1) {
TcpSocket *clisock = new TcpSocket();
struct sockaddr_in cliaddr;
//accept是阻塞获取已经完成的连接
if (sock.Accept(*clisock, &cliaddr) == false) {
continue;
}
printf("new connect client:%s:%d\n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
pthread_t tid;
pthread_create(&tid, NULL, thr_start, (void*)clisock);
pthread_detach(tid);
//多线程中 ，主线程不能关闭socket，因为线程之间共享文件描述符表
//如果在主线程中关闭了socket，其它线程中的这个描述符也就关闭了
}
sock.Close();
return 0;
}
线程版本的服务端与进程版本的服务端操作大同小异，差距就是进程与线程的创建方式不同，在方式上可能有区别。能了解这两个知识就能掌握。