网络（TCP）
创建一个套接字的域，什么叫做域呢（协议家族可以理解为我们所要的那个套接字他是AF_INET，将来是使用网络通信的，还是有叫本地通信也叫作域间通信，二个参数是socket对应的类型，不用填，协议类型，创建一个套接字的本质就是打开一个文件，必须要告诉服务器，端口号，然后再绑定套接字端口号不同类型（第一个参数的）第二个：定义的套接字的类型第三个写0就可以下面介绍程序中用到的socket API,这些函数
·
目录
udp端口那里随机绑定是首次发送数据的时候，那么你的端口号就随之确定了
tcp这里是面向连接的，客户端连接成功了，我才想让你进行通信
这里会出现一种偶发性的情况，当我们写一个文件描述符时，如果这个sockfd_的底层链接，被双方已经释放掉了，再像这个释放掉的写入时，就会出现问题
ps ajx |head -1 && ps ajx |grep tcpserver
再打开一个xshell就等于重新启动一个会话，还能看到tcpserver进程在运行
TCP socket API 详解
socket()函数用法详解：创建套接字 - C语言中文网 (biancheng.net)
套接字有哪些类型？socket有哪些类型？
套接字有哪些类型？socket有哪些类型？ - C语言中文网 (biancheng.net)
图解TCP四次握手断开连接
图解TCP四次握手断开连接 - C语言中文网 (biancheng.net)
图解TCP数据报结构以及三次握手（非常详细）
图解TCP数据报结构以及三次握手（非常详细） - C语言中文网 (biancheng.net)
socket缓冲区以及阻塞模式详解
socket缓冲区以及阻塞模式详解 - C语言中文网 (biancheng.net)
再谈UDP和TCP
再谈UDP和TCP - C语言中文网 (biancheng.net)
第一个参数：创建一个套接字的域，什么叫做域呢（协议家族）
可以理解为我们所要的那个套接字他是属于什么AF_INET，将来是使用IPv4还是IPv6网络通信的，还是有叫本地通信也叫作域间通信，第二个参数是socket对应的类型，udp是面向用户数据报（SOCK_DGRAM），tcp是面向字节流的，第三个参数不用填，协议类型，创建一个套接字的本质就是打开一个文件，必须要告诉服务器，端口号，然后再绑定套接字端口号
不同类型（第一个参数的）
第二个：定义的套接字的类型
第三个写0就可以
下面介绍程序中用到的socket API,这些函数都在sys/socket.h中。socket():
- socket()打开一个网络通讯端口,如果成功的话,就像open()一样返回一个文件描述符;
- 应用程序可以像读写文件一样用read/write在网络上收发数据;
- 如果socket()调用出错则返回-1;
- 对于IPv4, family参数指定为AF_INET;
- 对于TCP协议,type参数指定为SOCK_STREAM, 表示面向字节流的传输协议
- protocol参数的介绍从略,指定为0即可。
bind():
- 服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后 就可以向服务器发起连接; 服务器需要调用bind绑定一个固定的网络地址和端口号;
- bind()成功返回0,失败返回-1。
- bind()的作用是将参数sockfd和myaddr绑定在一起, 使sockfd这个用于网络通讯的文件描述符监听myaddr所描述的地址和端口号;
- 前面讲过,struct sockaddr *是一个通用指针类型,myaddr参数实际上可以接受多种协议的sockaddr结 构体,而它们的长度各不相同,所以需要第三个参数addrlen指定结构体的长度;
我们的程序中对myaddr参数是这样初始化的:
- 1. 将整个结构体清零;
- 2. 设置地址类型为AF_INET;
- 3. 网络地址为INADDR_ANY, 这个宏表示本地的任意IP地址,因为服务器可能有多个网卡,每个网卡也可能绑 定多个IP 地址, 这样设置可以在所有的IP地址上监听,直到与某个客户端建立了连接时才确定下来到底用哪个IP 地址;
- 4. 端口号为SERV_PORT, 我们定义为9999
listen():
- isten()声明sockfd处于监听状态, 并且最多允许有backlog个客户端处于连接等待状态, 如果接收到更多 的连接请求就忽略, 这里设置不会太大(一般是5), 具体细节同学们课后深入研究;
- listen()成功返回0,失败返回-1;
accept():
- 三次握手完成后, 服务器调用accept()接受连接;
- 如果服务器调用accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来;
- addr是一个传出参数,accept()返回时传出客户端的地址和端口号;
- 如果给addr 参数传NULL,表示不关心客户端的地址;
- addrlen参数是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区addr的长度 以避免缓冲区溢出问题, 传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区);
我们的服务器程序结构是这样的:
理解accecpt的返回值: 饭店拉客例子
connect
- 客户端需要调用connect()连接服务器;
- connect和bind的参数形式一致, 区别在于bind的参数是自己的地址, 而connect的参数是对方的地址;
- connect()成功返回0,出错返回-1;
区别
tcp服务器和udp类似的部分代码
#pragma once
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;
const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
enum
{
SocketError = 2,
BindError
};
class TcpServer
{
public:
TcpServer(const uint16_t &port, const string &ip = defaultip) : sockfd_(defaultfd), port_(port), ip_(ip)
{
}
void InitServer()
{
sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_ < 0)
{
FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
exit(SocketError);
}
INFO("create socket,success,sockfd:%d", sockfd_);
// 本地信息，这里只是栈里定义的变量
struct sockaddr_in local;
memset(&local, 0, sizeof(local)); // 初始化清零
// 填充网络信息
local.sin_family = AF_INET;
// 端口号是要发进网络里的，要主机序列转网络序列
local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
/*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
但有风险 */
inet_aton(ip_.c_str(), &(local.sin_addr));
// 开始绑定
int k = bind(sockfd_, (struct sockaddr *)(&local), sizeof(local));
if (k < 0)
{
FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
exit(BindError);
}
}
void Start()
{
}
~TcpServer()
{
}
private:
// IP和端口号需要用户构建服务器时就要告诉我了，
int sockfd_; // 网络文件描述符
uint16_t port_; // 端口号
string ip_; // 字符串风格的ip
};把套接字设置为监听状态（listen）
第二个参数一般不要设置太大
#pragma once
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;
const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;//listen的第二个参数
enum
{
UsageError = 1,
SocketError,
BindError,
ListenError
};
class TcpServer
{
public:
TcpServer(const uint16_t &port, const string &ip = defaultip) : sockfd_(defaultfd), port_(port), ip_(ip)
{
}
void InitServer()
{
// 字节流
sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_ < 0)
{
FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
exit(SocketError);
}
INFO("create socket,success,sockfd:%d", sockfd_);
// 本地信息，这里只是栈里定义的变量
struct sockaddr_in local;
memset(&local, 0, sizeof(local)); // 初始化清零
// 填充网络信息
local.sin_family = AF_INET;
// 端口号是要发进网络里的，要主机序列转网络序列
local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
/*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
但有风险 */
inet_aton(ip_.c_str(), &(local.sin_addr));
// 开始绑定
int k = bind(sockfd_, (struct sockaddr *)(&local), sizeof(local));
if (k < 0)
{
FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
exit(BindError);
}
INFO("bind socket,success,sockfd:%d", sockfd_);
//TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
int ls = listen(sockfd_, backlog);
if(ls < 0)
{
FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
exit(ListenError);
}
INFO("listen socket,success,sockfd:%d", sockfd_);
}
void Start()
{
for(; ;)
{
sleep(1);
INFO("tcpServer success.....");
}
}
~TcpServer()
{
}
private:
// IP和端口号需要用户构建服务器时就要告诉我了，
int sockfd_; // 网络文件描述符
uint16_t port_; // 端口号
string ip_; // 字符串风格的ip
};#include"TcpServer.hpp"
#include<iostream>
#include<memory>
using namespace std;
void Usage(string proc)
{
cout<< "\n\rUsage:" << proc << "port[1024+]\n" << endl;
}
//./tcpserver 8888
int main(int argc, char* argv[])
{
if(argc != 2)
{
Usage(argv[0]);
exit(UsageError);
}
uint16_t port = stoi(argv[1]);
unique_ptr<TcpServer> server(new TcpServer(port));
server->InitServer();
server->Start();
return 0;
}测试
查看端口号和IP地址（netstat -naup）
accept代码实现
都可以帮助我们知道是哪个客户端在连接我们
返回值：
成功返回一个文件描述符
sockfd是真正的服务者，sockfd_是"拉客的" 。
把所有的sockfd_改为listensock_
获取失败了不会直接结束，会继续获取，就像拉客，有的人拒绝了，直接去拉别的客户就好了
阻塞状态 没有顾客就没有accept到
测试：
#pragma once
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;
const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;//listen的第二个参数
enum
{
UsageError = 1,
SocketError,
BindError,
ListenError
};
class TcpServer
{
public:
TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
{
}
void InitServer()
{
// 字节流
listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (listensockfd_ < 0)
{
FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
exit(SocketError);
}
INFO("create socket,success,listensockfd_:%d", listensockfd_);
// 本地信息，这里只是栈里定义的变量
struct sockaddr_in local;
memset(&local, 0, sizeof(local)); // 初始化清零
// 填充网络信息
local.sin_family = AF_INET;
// 端口号是要发进网络里的，要主机序列转网络序列
local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
/*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
但有风险 */
inet_aton(ip_.c_str(), &(local.sin_addr));
// 开始绑定
int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
if (k < 0)
{
FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
exit(BindError);
}
INFO("bind socket,success,listensockfd_:%d", listensockfd_);
//TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
int ls = listen(listensockfd_, backlog);
if(ls < 0)
{
FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
exit(ListenError);
}
INFO("listen socket,success,listensockfd_:%d", listensockfd_);
}
void Start()
{
INFO("tcpserver is running");
for(; ;)
{
//1.重新获取
struct sockaddr_in client;
socklen_t len = sizeof(client);
//阻塞状态
int sockfd = accept(listensockfd_, (struct sockaddr*)(&client), &len);
if(sockfd < 0)
{
WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
continue;
}
//2.根据新连接来进行通信
INFO("get a new link..., sockfd:%d\n", sockfd);
}
}
~TcpServer()
{
}
private:
// IP和端口号需要用户构建服务器时就要告诉我了，
int listensockfd_; // 网络文件描述符
uint16_t port_; // 端口号
string ip_; // 字符串风格的ip
};
现在没有创建客户端，如何测试服务器呢
telnet
输入ctrl + ] 就可以了再回车就可以发信息了 quit是退出，要想退出再ctrl ] quit就可以了
tcp和udp都不能绑定自己云服务器的公网IP
127.0.0.1可以
tcp中使用的网络转主机函数
inet_ntop
inet_aton
inet_pton
服务测试代码read write
写一个客户端
tcp客户端要绑定，但不用显示的绑定
客户端端口号是随机的，但是唯一的
udp端口那里随机绑定是首次发送数据的时候，那么你的端口号就随之确定了
tcp这里是面向连接的，客户端连接成功了，我才想让你进行通信
没有bind 也就没有listen了
向服务器发起连接的接口 connect
客户端发起connect的时候,系统进行自动随机bind
连接时服务器的IP和端口必须知道，要不然往哪连接
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;
void Usage(string proc)
{
cout<< "\n\rUsage:" << proc << "serverip serverport\n" << endl;
}
//./tcpclient serverip serverport
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
exit(1);
}
string serverip = argv[1];
uint16_t serverport = stoi(argv[2]);
//tcp是面向连接的，客户端连接成功了，我才想让你进行通信
//没有bind 也就没有listen了
//网络文件描述符
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0)
{
cerr << "socket error" << endl;
return 1;
}
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));
//向服务器发起连接的接口 connect
//客户端发起connect的时候,系统进行自动随机bind
int n = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
if(n < 0)
{
cerr<< "connect error" <<endl;
return 2;
}
//连接成功了
//给对方发消息
string message;
while(true)
{
cout<< "Please Enter#" ;
getline(cin, message);
//把数据写给对方
write(sockfd, message.c_str(), message.size());
//对方服务器又会给写回来
char inbuffer[4096];
int n = read(sockfd, inbuffer, sizeof(inbuffer));//写进inbuffer
if(n > 0)//读成功了
{
inbuffer[n] = 0;//字符串以0结尾
cout<< inbuffer << endl;//返回什么就打印什么
}
}
close(sockfd);
return 0;
}测试：
tcp基本代码基本完成了已经
TcpClient.cc
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;
void Usage(string proc)
{
cout<< "\n\rUsage:" << proc << "serverip serverport\n" << endl;
}
//./tcpclient serverip serverport
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
exit(1);
}
string serverip = argv[1];
uint16_t serverport = stoi(argv[2]);
//tcp是面向连接的，客户端连接成功了，我才想让你进行通信
//没有bind 也就没有listen了
//网络文件描述符
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0)
{
cerr << "socket error" << endl;
return 1;
}
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));
//向服务器发起连接的接口 connect
//客户端发起connect的时候,系统进行自动随机bind
int n = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
if(n < 0)
{
cerr<< "connect error" <<endl;
return 2;
}
//连接成功了
//给对方发消息
string message;
while(true)
{
cout<< "Please Enter#" ;
getline(cin, message);
//把数据写给对方
write(sockfd, message.c_str(), message.size());
//对方服务器又会给写回来
char inbuffer[4096];
int n = read(sockfd, inbuffer, sizeof(inbuffer));//写进inbuffer
if(n > 0)//读成功了
{
inbuffer[n] = 0;//字符串以0结尾
cout<< inbuffer << endl;//返回什么就打印什么
}
}
close(sockfd);
return 0;
}main.cc
#include"TcpServer.hpp"
#include<iostream>
#include<memory>
using namespace std;
void Usage(string proc)
{
cout<< "\n\rUsage:" << proc << "port[1024+]\n" << endl;
}
//./tcpserver 8888
int main(int argc, char* argv[])
{
if(argc != 2)
{
Usage(argv[0]);
exit(UsageError);
}
uint16_t port = stoi(argv[1]);
unique_ptr<TcpServer> server(new TcpServer(port));
server->InitServer();
server->Start();
return 0;
}tcpServer.hpp
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;
const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;//listen的第二个参数
enum
{
UsageError = 1,
SocketError,
BindError,
ListenError
};
class TcpServer
{
public:
TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
{
}
void InitServer()
{
// 字节流
listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (listensockfd_ < 0)
{
FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
exit(SocketError);
}
INFO("create socket,success,listensockfd_:%d", listensockfd_);
// 本地信息，这里只是栈里定义的变量
struct sockaddr_in local;
memset(&local, 0, sizeof(local)); // 初始化清零
// 填充网络信息
local.sin_family = AF_INET;
// 端口号是要发进网络里的，要主机序列转网络序列
local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
/*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
但有风险 */
inet_aton(ip_.c_str(), &(local.sin_addr));
// 开始绑定
int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
if (k < 0)
{
FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
exit(BindError);
}
INFO("bind socket,success,listensockfd_:%d", listensockfd_);
//TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
int ls = listen(listensockfd_, backlog);
if(ls < 0)
{
FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
exit(ListenError);
}
INFO("listen socket,success,listensockfd_:%d", listensockfd_);
}
void Start()
{
INFO("tcpserver is running");
for(; ;)
{
//1.重新获取
struct sockaddr_in client;
socklen_t len = sizeof(client);
//阻塞状态
int sockfd = accept(listensockfd_, (struct sockaddr*)(&client), &len);
if(sockfd < 0)
{
WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
continue;
}
//进行服务 传客户端的IP和端口号
//网络转主机
uint16_t clientport = ntohs(client.sin_port);
char clientip[32];
inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
//2.根据新连接来进行通信
INFO("get a new link..., sockfd:%d, client ip:%s, client port:%d", sockfd, clientip, clientport);
//进行服务
Service(sockfd, clientip, clientport);
}
}
//服务 发什么就相应回去
void Service(int sockfd, const string &clientip, const uint16_t &clientport)
{
//测试代码
char buffer[4096];
while(true)
{
//从网络文件描述符中读取
ssize_t n = read(sockfd, buffer, sizeof(buffer));
if(n > 0)
{
buffer[n] = 0;
cout<< "client say# " << buffer << endl;
//发回
string echo_string = "tcpserver echo# ";
echo_string += buffer;
//发回
write(sockfd, echo_string.c_str(), echo_string.size());
}
}
}
~TcpServer()
{
}
private:
// IP和端口号需要用户构建服务器时就要告诉我了，
int listensockfd_; // 网络文件描述符
uint16_t port_; // 端口号
string ip_; // 字符串风格的ip
};客户端如果自己退了，服务器会怎么办
会读到0
但这样是单进程的只允许一个用户在线
多进程版本
但太消耗资源了成本太高了
多线程版本
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;
const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10; // listen的第二个参数
enum
{
UsageError = 1,
SocketError,
BindError,
ListenError
};
class TcpServer;
class ThreadData
{
public:
ThreadData(int fd, const string& ip, const uint16_t& port, TcpServer*td):sockfd(fd), clientip(ip), clientport(port), td_(td)
{}
public:
int sockfd;
string clientip;
uint16_t clientport;
TcpServer* td_;
};
class TcpServer
{
public:
TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
{
}
void InitServer()
{
// 字节流
listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (listensockfd_ < 0)
{
FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
exit(SocketError);
}
INFO("create socket,success,listensockfd_:%d", listensockfd_);
// 本地信息，这里只是栈里定义的变量
struct sockaddr_in local;
memset(&local, 0, sizeof(local)); // 初始化清零
// 填充网络信息
local.sin_family = AF_INET;
// 端口号是要发进网络里的，要主机序列转网络序列
local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
/*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
但有风险 */
inet_aton(ip_.c_str(), &(local.sin_addr));
// 开始绑定
int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
if (k < 0)
{
FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
exit(BindError);
}
INFO("bind socket,success,listensockfd_:%d", listensockfd_);
// TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
int ls = listen(listensockfd_, backlog);
if (ls < 0)
{
FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
exit(ListenError);
}
INFO("listen socket,success,listensockfd_:%d", listensockfd_);
}
void Start()
{
INFO("tcpserver is running");
for (;;)
{
// 1.重新获取
struct sockaddr_in client;
socklen_t len = sizeof(client);
// 阻塞状态
int sockfd = accept(listensockfd_, (struct sockaddr *)(&client), &len);
if (sockfd < 0)
{
WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
continue;
}
// 进行服务 传客户端的IP和端口号
// 网络转主机
uint16_t clientport = ntohs(client.sin_port);
char clientip[32];
inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
// 2.根据新连接来进行通信
INFO("get a new link..., sockfd:%d, client ip:%s, client port:%d", sockfd, clientip, clientport);
// 单进程版本
// 进行服务
// Service(sockfd, clientip, clientport);
// //如果读到了0，就回来了，然后关闭文件描述符
// close(sockfd);
// 多进程版本
// pid_t id = fork();
// if (id == 0)
// {
// // child 可以看到父进程所对应的sockfd
// close(listensockfd_);
// pid_t id = fork();
// if(id > 0) exit(0);//子进程直接退出，退出后，父进程就不用等待了，直接获取新的链接了
// if (id == 0)//让孙子进程处理，孙子进程是直接由系统处理的,被系统领养，被自动回收
// {
// Service(sockfd, clientip, clientport);
// close(sockfd);
// exit(0);
// }
// }
// // sockfd已经被子进程继承下去了，所以父进程不需要了
// close(sockfd);
// // 父进程等待
// pid_t rid = waitpid(id, nullptr, 0);
// (void)rid;
//多线程版本 这里的this，因为ThreadData里有TcpServer这个类了
ThreadData *td = new ThreadData(sockfd, clientip, clientport, this);
pthread_t tid;
pthread_create(&tid, nullptr, Routine, td);
//如果要继续等待，那么就还是只处理一个用户了，所以要线程分离pthread_detach
//这样主线程就一直在获取新链接，新线程进行任务处理
//线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
//线程只有一个 大部分都是共享的
}
}
//成员函数内部有this指针，要加static
//static方法无法使用类内非静态成员方法,也不能访问类内成员
static void* Routine(void* args)
{
//线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
//线程只有一个 大部分都是共享的
pthread_detach(pthread_self());
ThreadData *td = static_cast<ThreadData*>(args);
td->td_->Service(td->sockfd, td->clientip, td->clientport);
delete td;
return nullptr;
}
// 服务 发什么就相应回去
void Service(int sockfd, const string &clientip, const uint16_t &clientport)
{
// 测试代码
char buffer[4096];
while (true)
{
// 从网络文件描述符中读取
ssize_t n = read(sockfd, buffer, sizeof(buffer));
if (n > 0)
{
buffer[n] = 0;
cout << "client say# " << buffer << endl;
// 发回
string echo_string = "tcpserver echo# ";
echo_string += buffer;
// 发回
write(sockfd, echo_string.c_str(), echo_string.size());
}
else if (n == 0) // 说明客户端已经退出了
{
INFO("[%s %d] client quit,server close sockfd:%d", clientip, clientport, sockfd);
break;
}
else // 说明读取已经出问题了
{
WARN("读取出问题了");
}
}
}
~TcpServer()
{
}
private:
// IP和端口号需要用户构建服务器时就要告诉我了，
int listensockfd_; // 网络文件描述符
uint16_t port_; // 端口号
string ip_; // 字符串风格的ip
};线程池版本
修改一下任务
这个注释一下
任务改成这样
代码
dict.txt
apple:苹果
banana:香蕉
yellow:黄色
apple:苹果
banana:香蕉
cat:猫
dog:狗
book:书
computer:电脑
car:汽车
house:房子
tree:树
water:水
food:食物
love:爱
friend:朋友
family:家庭
school:学校
sun:太阳
。。。。。。Task.hpp
#pragma once
#include <iostream>
#include <string>
#include "./logs/ljwlog.h"
using namespace std;
string opers = "+-*/%";
enum
{
Div_zero = 1,
Mod_zero,
Unknown
};
class Task
{
public:
Task(int sockfd, const string &clientip, const uint16_t &clientport)
: sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
{
}
void run()
{
// 服务代码
// 测试代码
char buffer[4096];
// 从网络文件描述符中读取
ssize_t n = read(sockfd_, buffer, sizeof(buffer));
if (n > 0)
{
buffer[n] = 0;
cout << "client say# " << buffer << endl;
// 发回
string echo_string = "tcpserver echo# ";
echo_string += buffer;
// 发回
write(sockfd_, echo_string.c_str(), echo_string.size());
}
else if (n == 0) // 说明客户端已经退出了
{
INFO("[%s %d] client quit,server close sockfd:%d", clientip_, clientport_, sockfd_);
}
else // 说明读取已经出问题了
{
WARN("读取出问题了");
}
close(sockfd_);
}
void operator()()
{
run();
}
~Task()
{
}
private:
int sockfd_; // 网络文件描述符
string clientip_;
uint16_t clientport_; // 端口号
};TcpClient.cc
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;
void Usage(string proc)
{
cout<< "\n\rUsage:" << proc << "serverip serverport\n" << endl;
}
//./tcpclient serverip serverport
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
exit(1);
}
string serverip = argv[1];
uint16_t serverport = stoi(argv[2]);
//tcp是面向连接的，客户端连接成功了，我才想让你进行通信
//没有bind 也就没有listen了
//网络文件描述符
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0)
{
cerr << "socket error" << endl;
return 1;
}
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));
//向服务器发起连接的接口 connect
//客户端发起connect的时候,系统进行自动随机bind
int n = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
if(n < 0)
{
cerr<< "connect error" <<endl;
return 2;
}
//连接成功了
//给对方发消息
string message;
while(true)
{
cout<< "Please Enter#" ;
getline(cin, message);
//把数据写给对方
write(sockfd, message.c_str(), message.size());
//对方服务器又会给写回来
char inbuffer[4096];
int n = read(sockfd, inbuffer, sizeof(inbuffer));//写进inbuffer
if(n > 0)//读成功了
{
inbuffer[n] = 0;//字符串以0结尾
cout<< inbuffer << endl;//返回什么就打印什么
}
}
close(sockfd);
return 0;
}TcpServer.hpp
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
#include "ThreadPool.hpp"
#include "Task.hpp"
using namespace std;
const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10; // listen的第二个参数
enum
{
UsageError = 1,
SocketError,
BindError,
ListenError
};
class TcpServer;
class ThreadData
{
public:
ThreadData(int fd, const string& ip, const uint16_t& port, TcpServer*td):sockfd(fd), clientip(ip), clientport(port), td_(td)
{}
public:
int sockfd;
string clientip;
uint16_t clientport;
TcpServer* td_;
};
class TcpServer
{
public:
TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
{
}
void InitServer()
{
// 字节流
listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (listensockfd_ < 0)
{
FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
exit(SocketError);
}
INFO("create socket,success,listensockfd_:%d", listensockfd_);
// 本地信息，这里只是栈里定义的变量
struct sockaddr_in local;
memset(&local, 0, sizeof(local)); // 初始化清零
// 填充网络信息
local.sin_family = AF_INET;
// 端口号是要发进网络里的，要主机序列转网络序列
local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
/*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
但有风险 */
inet_aton(ip_.c_str(), &(local.sin_addr));
// 开始绑定
int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
if (k < 0)
{
FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
exit(BindError);
}
INFO("bind socket,success,listensockfd_:%d", listensockfd_);
// TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
int ls = listen(listensockfd_, backlog);
if (ls < 0)
{
FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
exit(ListenError);
}
INFO("listen socket,success,listensockfd_:%d", listensockfd_);
}
void Start()
{
//先启动线程池
ThreadPool<Task>::GetInstance()->Start();
INFO("tcpserver is running");
for (;;)
{
// 1.重新获取
struct sockaddr_in client;
socklen_t len = sizeof(client);
// 阻塞状态
int sockfd = accept(listensockfd_, (struct sockaddr *)(&client), &len);
if (sockfd < 0)
{
WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
continue;
}
// 进行服务 传客户端的IP和端口号
// 网络转主机
uint16_t clientport = ntohs(client.sin_port);
char clientip[32];
inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
// 2.根据新连接来进行通信
INFO("get a new link..., sockfd:%d, client ip:%s, client port:%d", sockfd, clientip, clientport);
//1. 单进程版本
// 进行服务
// Service(sockfd, clientip, clientport);
// //如果读到了0，就回来了，然后关闭文件描述符
// close(sockfd);
//2. 多进程版本
// pid_t id = fork();
// if (id == 0)
// {
// // child 可以看到父进程所对应的sockfd
// close(listensockfd_);
// pid_t id = fork();
// if(id > 0) exit(0);//子进程直接退出，退出后，父进程就不用等待了，直接获取新的链接了
// if (id == 0)//让孙子进程处理，孙子进程是直接由系统处理的,被系统领养，被自动回收
// {
// Service(sockfd, clientip, clientport);
// close(sockfd);
// exit(0);
// }
// }
// // sockfd已经被子进程继承下去了，所以父进程不需要了
// close(sockfd);
// // 父进程等待
// pid_t rid = waitpid(id, nullptr, 0);
// (void)rid;
//3.多线程版本 这里的this，因为ThreadData里有TcpServer这个类了
// ThreadData *td = new ThreadData(sockfd, clientip, clientport, this);
// pthread_t tid;
// pthread_create(&tid, nullptr, Routine, td);
//如果要继续等待，那么就还是只处理一个用户了，所以要线程分离pthread_detach
//这样主线程就一直在获取新链接，新线程进行任务处理
//线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
//线程只有一个 大部分都是共享的
//4.线程池版本
Task t(sockfd, clientip, clientport);//构建任务
ThreadPool<Task>::GetInstance()->Push(t);//把任务push进线程池里
}
}
// //成员函数内部有this指针，要加static
// //static方法无法使用类内非静态成员方法,也不能访问类内成员
// static void* Routine(void* args)
// {
// //线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
// //线程只有一个 大部分都是共享的
// pthread_detach(pthread_self());
// ThreadData *td = static_cast<ThreadData*>(args);
// td->td_->Service(td->sockfd, td->clientip, td->clientport);
// delete td;
// return nullptr;
// }
// // 服务 发什么就相应回去
// void Service(int sockfd, const string &clientip, const uint16_t &clientport)
// {
// // 测试代码
// char buffer[4096];
// while (true)
// {
// // 从网络文件描述符中读取
// ssize_t n = read(sockfd, buffer, sizeof(buffer));
// if (n > 0)
// {
// buffer[n] = 0;
// cout << "client say# " << buffer << endl;
// // 发回
// string echo_string = "tcpserver echo# ";
// echo_string += buffer;
// // 发回
// write(sockfd, echo_string.c_str(), echo_string.size());
// }
// else if (n == 0) // 说明客户端已经退出了
// {
// INFO("[%s %d] client quit,server close sockfd:%d", clientip, clientport, sockfd);
// break;
// }
// else // 说明读取已经出问题了
// {
// WARN("读取出问题了");
// }
// }
// }
~TcpServer()
{
}
private:
// IP和端口号需要用户构建服务器时就要告诉我了，
int listensockfd_; // 网络文件描述符
uint16_t port_; // 端口号
string ip_; // 字符串风格的ip
};ThreadPool.hpp
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <pthread.h>
#include <vector>
#include <queue>
using namespace std;
struct ThreadInfo
{
pthread_t tid;
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 Weakup()
{
pthread_cond_signal(&cond_);
}
// 指定条件变量休眠，检测到队列中没有任务（也就是检测临界资源）
void ThreadSleep()
{
pthread_cond_wait(&cond_, &mutex_);
}
void Push(const T &t)
{
Lock();
tasks_.push(t);
Weakup();//唤醒
Unlock();
}
void Pop(T *out)
{
Lock();
tasks_.pop();
Unlock();
}
string GerThreadName(pthread_t tid)
{
for (const auto &t : threads_)
{
if (t.tid == tid)
return t.name;
}
return "None";
}
static void *HandlerTask(void *args)
{
ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
string name = tp->GerThreadName(pthread_self());
while (true)
{
tp->Lock();
while (tp->IsQueueEmpty())
{
tp->ThreadSleep();
}
T t = tp->Pop();
tp->Unlock();
t();
}
}
T Pop()
{
T t = tasks_.front();
tasks_.pop();
return t;
}
void Start()
{
int num = threads_.size();
for (int i = 0; i < num; i++)
{
threads_[i].name = "thread-" + to_string(i + 1);
pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
}
}
static ThreadPool<T> *GetInstance()
{
if (nullptr == tp_)
{
pthread_mutex_lock(&lock_);
if (nullptr == tp_)
{
tp_ = new ThreadPool<T>();
}
pthread_mutex_unlock(&lock_);
}
return tp_;
}
private:
bool IsQueueEmpty()
{
return tasks_.empty();
}
private:
// 构造单例
~ThreadPool()
{
pthread_mutex_destroy(&mutex_);
pthread_cond_destroy(&cond_);
}
ThreadPool(int num = defalutnum) : threads_(num)
{
pthread_mutex_init(&mutex_, nullptr);
pthread_cond_init(&cond_, nullptr);
}
ThreadPool(const ThreadPool<T> &) = delete;
const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete;
private:
vector<ThreadInfo> threads_;
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;
main.cc
#include"TcpServer.hpp"
#include<iostream>
#include<memory>
using namespace std;
void Usage(string proc)
{
cout<< "\n\rUsage:" << proc << "port[1024+]\n" << endl;
}
//./tcpserver 8888
int main(int argc, char* argv[])
{
if(argc != 2)
{
Usage(argv[0]);
exit(UsageError);
}
uint16_t port = stoi(argv[1]);
unique_ptr<TcpServer> server(new TcpServer(port));
server->InitServer();
server->Start();
return 0;
}makefile
.PHONY:all
all:tcpserver tcpclient
tcpserver:main.cc
g++ -o $@ $^ -lpthread -std=c++11
tcpclient:TcpClient.cc
g++ -o $@ $^ -lpthread -std=c++11
.PHONT:clean
clean:
rm -f tcpclient tcpserver
测试结果
像服务器发起请求，服务器把结果给你，链接关闭，此时可以理解为有线程池给同意处理我们的任务
简单的翻译器字典
补充一个知识点
.getline 从文件读取一整行
getline 是 C++ 中一个用于从输入流中读取一整行的函数，通常用于读取带有空格的字符串。它属于 <iostream> 头文件，并且有两个主要的用法：
1. 从 cin 读取输入：
getline 函数能够读取输入流直到遇到换行符（\n），并将其存储到一个字符串中，换行符会被丢弃。
函数原型：
istream& getline(istream& is, string& str);
-
is：输入流（如cin或文件流）。 -
str：存储读取结果的字符串。
示例：
#include <iostream>
#include <string>
using namespace std;
int main() {
string line;
cout << "Enter a line: ";
getline(cin, line); // 读取一行输入并存储到 line 中
cout << "You entered: " << line << endl;
return 0;
}
2. 从文件读取一整行：
getline 也可以用来从文件读取数据。此时，传入的流对象通常是 ifstream。
示例：
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main() {
ifstream file("example.txt"); // 打开文件
string line;
if (file.is_open()) {
while (getline(file, line)) { // 逐行读取文件
cout << line << endl; // 输出每一行
}
file.close();
} else {
cout << "Unable to open file" << endl;
}
return 0;
}
注意事项：
-
getline会删除输入中的换行符（\n），因此字符串末尾没有换行符。 -
如果输入流已经到达文件或流的末尾，
getline会返回false，并且读取的字符串会为空。
总的来说，getline 在处理用户输入或文件数据时非常有用，特别是当输入中包含空格时。
init.hpp
#pragma once
#include<iostream>
#include<fstream>
#include<string>
#include<unordered_map>
#include "./logs/ljwlog.h"
using namespace std;
const string dictname = "./dict.txt";//字典名
const string sep = ":";//分隔符
//yellow:黄色
static bool Split(string &s, string *part1, string* part2)
{
auto pos = s.find(sep);
if(pos == std::string::npos)
{
return false;
}
*part1 = s.substr(0, pos);
*part2 = s.substr(pos+1);
return true;
}
//yellow:黄色
class Init
{
public:
Init()
{
ifstream in(dictname);
if(!in.is_open())
{
FATAL("ifstream open %s error", dictname.c_str());
exit(1);
}
string s;
while(getline(in, s))
{
string part1, part2;
Split(s, &part1, &part2);
dict.insert({part1, part2});
}
in.close();
}
string translation(const string& key)
{
auto iter = dict.find(key);
if(iter == dict.end()) return "Unkonw";
else return iter->second;
}
private:
unordered_map<string, string> dict;
};
Task.hpp
研究一下write
没有发回客户端
这里会出现一种偶发性的情况，当我们写一个文件描述符时，如果这个sockfd_的底层链接，被双方已经释放掉了，再像这个释放掉的写入时，就会出现问题
两个继承向管道写入，把读端给关闭了，写端继续写的话，进程就会收到SIGPIPE信号
给屏蔽掉
补充知识点常见的信号
常见的信号：
**SIGINT**：中断信号，通常由键盘的 Ctrl+C 触发。 |
**SIGTERM**：终止信号，用于请求进程正常退出。 |
**SIGSEGV**：段错误信号，进程访问非法内存时触发。 |
**SIGKILL**：杀死信号，强制终止进程，不可被捕获或屏蔽。 |
**SIGALRM**：定时器到期信号，通常由 alarm() 函数触发。 |
**SIGUSR1、SIGUSR2**：用户定义信号，用于用户自定义的应用程序通信。 |
**SIGPIPE**：管道破裂信号，通常由写入关闭管道的进程触发。 |
常见的信号忽略
在 C/C++ 中，信号忽略是一种控制信号行为的机制，允许进程对某些信号采取不处理的方式，即忽略这些信号。信号忽略的常见方法是通过 signal() 或 sigaction() 函数设置信号的处理行为为 SIG_IGN（即忽略信号）。下面介绍一些常见的信号及其忽略方式。
常见的信号及其忽略方法
-
**
SIGPIPE**：当进程尝试向一个已关闭的管道或套接字写入数据时，系统会向进程发送SIGPIPE信号。默认情况下，进程会因接收到SIGPIPE信号而终止程序。在一些应用程序中（如网络编程），你可能希望忽略这个信号，避免进程崩溃。忽略方法：
signal(SIGPIPE, SIG_IGN);这行代码会让程序在遇到
SIGPIPE信号时不做任何处理，程序将继续运行，而不是因为尝试写入关闭的管道而崩溃。 -
**
SIGCHLD**：当子进程终止时，操作系统会向父进程发送SIGCHLD信号。默认情况下，父进程会接收到这个信号并需要调用wait()或waitpid()来回收子进程的退出状态。如果不想处理这个信号，可以通过忽略它来避免父进程被中断。忽略方法：
signal(SIGCHLD, SIG_IGN);这将使得父进程忽略
SIGCHLD信号，而不需要显式地等待子进程的结束。 -
**
SIGUSR1和SIGUSR2**：这两个信号是用户定义的信号，可以用于应用程序自定义的行为。在某些情况下，你可能不希望进程响应这些信号，通常在进程不需要使用这些信号时会选择忽略。忽略方法：
signal(SIGUSR1, SIG_IGN); signal(SIGUSR2, SIG_IGN); -
**
SIGINT**：当用户按下Ctrl+C时，通常会向进程发送SIGINT信号，默认情况下进程会终止。如果你希望在某些情况下忽略SIGINT信号（例如，防止用户终止正在运行的程序），可以使用以下方法：忽略方法：
signal(SIGINT, SIG_IGN);这将让程序忽略
Ctrl+C产生的中断信号，程序将继续运行。 -
**
SIGTERM**：SIGTERM是一个请求终止进程的信号，通常用来请求程序优雅退出。如果你希望程序在收到SIGTERM信号时不退出，可以选择忽略它。忽略方法：
signal(SIGTERM, SIG_IGN);这将让程序忽略
SIGTERM信号，程序不会因为外部终止请求而退出。
使用 signal() 函数忽略信号
signal() 函数可以用于设置信号的处理程序，以下是常用的忽略信号的语法：
signal(signal_number, SIG_IGN);
-
signal_number：表示要忽略的信号编号（如SIGPIPE,SIGINT,SIGTERM等）。 -
SIG_IGN：表示忽略信号。
使用 sigaction() 函数忽略信号
sigaction() 是一种更为强大和灵活的信号处理机制，可以提供更精细的控制，包括设置信号屏蔽、信号处理程序等。通过 sigaction() 忽略信号的方式如下：
#include <signal.h>
struct sigaction sa;
sa.sa_handler = SIG_IGN; // 设置为忽略信号
sigemptyset(&sa.sa_mask); // 清空信号掩码
sa.sa_flags = 0; // 不使用特殊标志
sigaction(SIGINT, &sa, NULL); // 忽略 SIGINT 信号
常见信号的忽略示例
以下是一些常见信号的忽略示例：
#include <iostream>
#include <signal.h>
#include <unistd.h>
using namespace std;
int main() {
// 忽略 SIGINT 信号（Ctrl+C）
signal(SIGINT, SIG_IGN);
// 忽略 SIGPIPE 信号（写入关闭的管道时）
signal(SIGPIPE, SIG_IGN);
// 忽略 SIGTERM 信号（终止进程请求）
signal(SIGTERM, SIG_IGN);
cout << "Signal handling example: ignoring SIGINT, SIGPIPE, and SIGTERM" << endl;
// 程序继续执行，等待信号
while (true) {
sleep(1); // 程序保持运行，等待信号
}
return 0;
}
在上述示例中，程序会忽略 SIGINT（Ctrl+C）、SIGPIPE（写入关闭管道）和 SIGTERM（请求终止进程）信号。如果用户按下 Ctrl+C 或尝试向关闭的管道写数据时，程序不会被终止，而是继续运行。
总结
-
忽略信号：使用
signal(signal_number, SIG_IGN)或sigaction()可以让进程忽略特定的信号，避免因信号导致程序异常终止或干扰。 -
常见信号忽略：常见需要忽略的信号包括
SIGPIPE、SIGINT、SIGTERM和SIGCHLD等。 -
**
signal()与sigaction()**：signal()是一种简单的信号处理方式，sigaction()提供了更强大的功能和更高的可移植性，适用于更复杂的信号处理需求。
通过适当的信号忽略和处理，可以提升程序的稳定性和鲁棒性，尤其是在网络编程或需要长时间运行的后台进程中。
TcpClient.cc 修改成多次可以使用服务的
连续输入
读写出错进行重连
守护进程
前台进程 后台进程
后台进程不能标准输入
3个后台进程了
把2号任务提到前台进程
ctrl c终止前台进程
把任务提到前台进程，后悔了，再重新放回后台
ctrl z就可以暂停，然后系统自动把bash提到前台
bg 3再把3号进程启动起来
session（进程会话）
在Linux中，session（会话）通常指的是与用户交互的一个环境，它是系统中与某个用户交互的一系列活动的集合。会话在Linux系统中有多种用途，下面是几种常见的会话类型及其相关概念：
1. 登录会话（Login Session）
当用户通过登录界面（如终端或图形界面）登录到系统时，系统会为该用户创建一个会话。登录会话包括：
-
用户身份验证（通过用户名和密码等方式）。
-
运行用户的默认Shell（例如
bash）。 -
用户环境变量的设置（例如
$PATH、$HOME等）。
这种会话通常由登录管理器（如login、sshd或gdm等）管理。当用户退出登录时，该会话会结束。
2. 进程会话（Process Session）
在Linux中，每个进程都有一个会话（Session），这个会话由session leader（会话领导进程）控制。进程会话的特征包括：
-
每个进程在启动时都会被分配一个会话ID。
-
会话通常由一个进程创建，称为会话领导进程。
-
会话通常用于进程组管理，特别是在控制终端和后台进程之间的交互。
会话的管理由setsid()系统调用进行，当进程调用setsid()时，它会创建一个新的会话，并成为该会话的领导进程
前台任务和后台任务比较好
本质
任务里有多个进程组
每多建一个就多一个
绘画和终端都关掉了，那些任务仍然在
bash也退了，然后就托孤了
受到了用户登录和退出的影响
守护进程化---不想受到任何用户登陆和注销的影响
如何做到（setsid）
怎么保证自己不是组长
守护进程本质（孤儿进程）
代码
先忽略几个常见信号
#pragma once
#include<iostream>
#include<cstdlib>
#include<unistd.h>
#include<signal.h>
#include<string>
using namespace std;
void Daemon(const string &cwd = "")
{
//1.忽略其他异常信号
signal(SIGCLD, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGSTOP, SIG_IGN);
//2.将自己变成独立的会话
if(fork() > 0)
{
exit(0);
}
setsid();
//3.g更改当前目录
if(!cwd.empty())
{
chdir(cwd.c_str());//更改当前目录
}
}网络服务器以守护进程运行
/dev/null,垃圾桶
dup2重定向到/dev/null
Daemon.hpp
#pragma once
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
using namespace std;
const string nullfile = "/dev/null";
void Daemon(const string &cwd = "")
{
// 1.忽略其他异常信号
signal(SIGCLD, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGSTOP, SIG_IGN);
// 2.将自己变成独立的会话
if (fork() > 0)
{
exit(0);
}
setsid();
// 3.g更改当前目录
if (!cwd.empty())
{
chdir(cwd.c_str()); // 更改当前目录
}
// 4.有打印的，标准输出标准输入的，所以要把表示输入，标准输出，标准错误重定向至/dev/null
// 标准错误一般要打印到日志文件，不要打印到屏幕
int fd = open(nullfile.c_str(), O_RDWR);//读写方式打开
if(fd > 0)
{
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, 2);
close(fd);
}
}测试：启动后直接终止了，变成后台了
检查是否起来了netstat -nltp
ps ajx |head -1 && ps ajx |grep tcpserver
自成进程组，自成会话
查看工作目录ls /proc/644717 -l
还在当前目录
ls /proc/644717/fd -l
把xshell关闭了，服务仍然在
再打开一个xshell就等于重新启动一个会话，还能看到tcpserver进程在运行
更改目录到根目录
把服务器进程关闭掉kill -9 PID
把打印的放进日志文件
守护进程函数daemon,上面的是模拟
tcp通信时全双工的
read/write相当于拷贝到缓冲区
助力广东及东莞地区开发者，代码托管、在线学习与竞赛、技术交流与分享、资源共享、职业发展，成为松山湖开发者首选的工作与学习平台
更多推荐
124
0- 0
已为社区贡献4条内容
所有评论(0)