当前位置： 首页 > news >正文

网站建设和赚钱方法/网络营销策略ppt

news 文章来源：https://blog.csdn.net/2401_83427936/article/details/144243487 2025/2/22 22:54:40
网站建设和赚钱方法,网络营销策略ppt,重庆沙坪坝区疫情最新消息,蓝图网站建设目录 TCP socket API 详解 套接字有哪些类型？socket有哪些类型？ 图解TCP四次握手断开连接 图解TCP数据报结构以及三次握手（非常详细） socket缓冲区以及阻塞模式详解 再谈UDP和TCP bind(): 我们的程序中对myaddr参数是这样…

目录

TCP socket API 详解

套接字有哪些类型？socket有哪些类型？

图解TCP四次握手断开连接

图解TCP数据报结构以及三次握手（非常详细）

socket缓冲区以及阻塞模式详解

再谈UDP和TCP

bind():

我们的程序中对myaddr参数是这样初始化的:

listen():

accept():

理解accecpt的返回值: 饭店拉客例子

connect

tcp服务器和udp类似的部分代码

把套接字设置为监听状态（listen）

测试

查看端口号和IP地址（netstat -naup）

accept代码实现

成功返回一个文件描述符

sockfd是真正的服务者，sockfd_是"拉客的" 。

测试：

现在没有创建客户端，如何测试服务器呢

telnet 

tcp和udp都不能绑定自己云服务器的公网IP

tcp中使用的网络转主机函数

inet_ntop

inet_aton 

inet_pton

服务测试代码read write

写一个客户端

tcp客户端要绑定，但不用显示的绑定

客户端端口号是随机的，但是唯一的

udp端口那里随机绑定是首次发送数据的时候，那么你的端口号就随之确定了

tcp这里是面向连接的，客户端连接成功了，我才想让你进行通信

没有bind 也就没有listen了

向服务器发起连接的接口 connect

客户端发起connect的时候,系统进行自动随机bind

连接时服务器的IP和端口必须知道，要不然往哪连接

tcp基本代码基本完成了已经

客户端如果自己退了，服务器会怎么办

会读到0

但这样是单进程的只允许一个用户在线

多进程版本

但太消耗资源了成本太高了

多线程版本

线程池版本

修改一下任务

代码  

 测试结果

简单的翻译器字典

补充一个知识点

.getline 从文件读取一整行

研究一下write

这里会出现一种偶发性的情况，当我们写一个文件描述符时，如果这个sockfd_的底层链接，被双方已经释放掉了，再像这个释放掉的写入时，就会出现问题

补充知识点常见的信号

常见的信号：

常见的信号忽略

TcpClient.cc 修改成多次可以使用服务的

读写出错进行重连

守护进程

前台进程  后台进程

session（进程会话）

前台任务和后台任务比较好

本质

绘画和终端都关掉了，那些任务仍然在

bash也退了，然后就托孤了

​编辑​

守护进程化---不想受到任何用户登陆和注销的影响​编辑​

如何做到（setsid）(创建新会话)

怎么保证自己不是组长

守护进程本质（孤儿进程）

守护进程忽略的几个信号和含义

1. SIGHUP (Hangup signal)

2. SIGINT (Interrupt signal)

3. SIGTERM (Termination signal)

4. SIGQUIT (Quit signal)

5. SIGCHLD (Child terminated signal)

6. SIGPIPE (Broken pipe signal)

为什么守护进程忽略这些信号？

如何在 C/C++ 中忽略信号？

总结：

代码

网络服务器以守护进程运行

/dev/null,垃圾桶

dup2重定向到/dev/null

 ​编辑​

测试：启动后直接终止了，变成后台了

检查是否起来了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,上面的是模拟

daemon() 函数的定义

参数：

返回值：

daemon() 的作用

守护进程的常见步骤

使用 daemon() 示例

代码解析：

daemon() 与 setsid() 和 fork() 的比较

使用守护进程时的注意事项

总结

tcp通信时全双工的

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是面向字节流的，第三个参数不用填，协议类型，创建一个套接字的本质就是打开一个文件，必须要告诉服务器，端口号，然后再绑定套接字端口号

8d653c031bf046d5aa810558107d2b7f.png​

不同类型（第一个参数的） 

8716260b5598498d938bbcbd53f4783a.png​

第二个：定义的套接字的类型

30f91d16c7da430a8bff696543150763.png​

第三个写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的时候,系统进行自动随机bindint 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));//写进inbufferif(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的时候,系统进行自动随机bindint 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));//写进inbufferif(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的时候,系统进行自动随机bindint 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));//写进inbufferif(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.ccg++ -o $@ $^ -lpthread -std=c++11
tcpclient:TcpClient.ccg++ -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（即忽略信号）。下面介绍一些常见的信号及其忽略方式。

常见的信号及其忽略方法

  1. **SIGPIPE**：当进程尝试向一个已关闭的管道或套接字写入数据时，系统会向进程发送 SIGPIPE 信号。默认情况下，进程会因接收到 SIGPIPE 信号而终止程序。在一些应用程序中（如网络编程），你可能希望忽略这个信号，避免进程崩溃。

    忽略方法：

    signal(SIGPIPE, SIG_IGN);

    这行代码会让程序在遇到 SIGPIPE 信号时不做任何处理，程序将继续运行，而不是因为尝试写入关闭的管道而崩溃。

  2. **SIGCHLD**：当子进程终止时，操作系统会向父进程发送 SIGCHLD 信号。默认情况下，父进程会接收到这个信号并需要调用 wait() 或 waitpid() 来回收子进程的退出状态。如果不想处理这个信号，可以通过忽略它来避免父进程被中断。

    忽略方法：

    signal(SIGCHLD, SIG_IGN);

    这将使得父进程忽略 SIGCHLD 信号，而不需要显式地等待子进程的结束。

  3. **SIGUSR1 和 SIGUSR2**：这两个信号是用户定义的信号，可以用于应用程序自定义的行为。在某些情况下，你可能不希望进程响应这些信号，通常在进程不需要使用这些信号时会选择忽略。

    忽略方法：

    signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);

  4. **SIGINT**：当用户按下 Ctrl+C 时，通常会向进程发送 SIGINT 信号，默认情况下进程会终止。如果你希望在某些情况下忽略 SIGINT 信号（例如，防止用户终止正在运行的程序），可以使用以下方法：

    忽略方法：

    signal(SIGINT, SIG_IGN);

    这将让程序忽略 Ctrl+C 产生的中断信号，程序将继续运行。

  5. **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）(创建新会话)

​

怎么保证自己不是组长

​​

守护进程本质（孤儿进程）

守护进程忽略的几个信号和含义

在 C/C++ 中，守护进程通常会忽略一些信号，确保其在后台继续运行，而不被用户的操作或其他系统事件干扰。除了常见的信号外，SIGPIPE 也是一个重要的信号，守护进程通常会忽略它。以下是几个常见的守护进程忽略的信号及其作用，包括 SIGPIPE：

1. SIGHUP (Hangup signal)

  • 作用：最初用于通知进程，终端连接已经断开。对于守护进程来说，接收到 SIGHUP 信号通常意味着该进程应重新加载其配置文件。
  • 守护进程行为：守护进程通常会忽略 SIGHUP 信号，这样即使终端连接断开，进程也会继续运行。

2. SIGINT (Interrupt signal)

  • 作用：通常由用户通过键盘操作（Ctrl+C）发送，用来中断进程的执行。
  • 守护进程行为：守护进程会忽略 SIGINT 信号，避免被用户的键盘中断。

3. SIGTERM (Termination signal)

  • 作用：请求进程终止的信号。系统或其他进程通常会发送此信号来请求进程优雅地结束。
  • 守护进程行为：尽管守护进程有时会捕获 SIGTERM 信号并优雅地退出，但它也可能选择忽略该信号，或者采取一些特定的清理操作后继续运行。

4. SIGQUIT (Quit signal)

  • 作用：通常由用户通过 Ctrl+\ 发送，用来终止进程并生成核心转储文件。
  • 守护进程行为：守护进程通常会忽略 SIGQUIT 信号，以避免被意外终止并生成不必要的核心转储文件。

5. SIGCHLD (Child terminated signal)

  • 作用：当子进程结束时，父进程会收到 SIGCHLD 信号，通常用于处理子进程的退出状态。
  • 守护进程行为：守护进程可能会忽略 SIGCHLD 信号，特别是当它不需要对子进程的退出状态进行处理时。

6. SIGPIPE (Broken pipe signal)

  • 作用：当一个进程向一个已经关闭的管道或套接字写入数据时，操作系统会发送 SIGPIPE 信号给该进程。
  • 守护进程行为：守护进程通常会忽略 SIGPIPE 信号。这是因为如果进程尝试向一个已经关闭的管道或套接字写入数据，默认情况下会导致进程终止。通过忽略 SIGPIPE 信号，守护进程可以避免因意外的关闭管道而终止，通常这种情况下进程会返回一个错误代码，而不是被强制终止。

为什么守护进程忽略这些信号？

守护进程的设计目标是长时间稳定地在后台运行，因此它们通常需要避免因为用户的操作（如 Ctrl+C）、系统的请求（如终止信号）或其他不必要的信号而中断。忽略这些信号有助于确保进程不被意外终止，可以持续运行。

如何在 C/C++ 中忽略信号？

在 C/C++ 中，您可以使用 signal() 函数来捕获或忽略信号。若要忽略一个信号，可以将信号处理程序设置为 SIG_IGN。例如：

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>int main() {// 忽略 SIGHUP, SIGINT, SIGPIPEsignal(SIGHUP, SIG_IGN);  // 忽略 SIGHUPsignal(SIGINT, SIG_IGN);  // 忽略 SIGINTsignal(SIGPIPE, SIG_IGN); // 忽略 SIGPIPE// 守护进程的逻辑while (1) {// 模拟工作sleep(1);}return 0;
}

总结：

  • SIGHUP: 通常用于通知终端连接断开，守护进程会忽略它。
  • SIGINT: 用户通过 Ctrl+C 发送的中断信号，守护进程会忽略它。
  • SIGTERM: 请求进程终止，守护进程有时会忽略它，或者捕获后进行清理操作。
  • SIGQUIT: 用户通过 Ctrl+\ 发送的信号，守护进程会忽略它。
  • SIGCHLD: 子进程退出时发送的信号，守护进程可能会忽略它。
  • SIGPIPE: 管道或套接字关闭时发送的信号，守护进程会忽略它，避免进程被意外终止。

通过忽略这些信号，守护进程能够在后台稳定运行，避免不必要的中断或退出。

代码

先忽略几个常见信号

​

#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,上面的是模拟

​

在 C/C++ 中，daemon() 函数用于创建守护进程（daemon）。守护进程通常是系统后台运行的进程，通常没有控制终端，并且可以在系统启动时自动启动或在用户退出登录时保持运行。守护进程会与控制终端断开连接，通常用于执行长期运行的任务。

daemon() 函数的定义

daemon() 函数通常在 <unistd.h> 中声明，原型如下：

#include <unistd.h>int daemon(int nochdir, int noclose);
参数：
  • nochdir: 如果设置为 0，守护进程将在启动时改变当前工作目录为根目录（/）。这是因为守护进程一般不希望占用当前工作目录，并防止在程序退出时当前工作目录被锁定。如果设置为 1，则守护进程的当前工作目录不会改变。
  • noclose: 如果设置为 0，守护进程会关闭标准输入、标准输出和标准错误输出（stdin, stdout, stderr）。通常这是守护进程的行为，以防它继续与终端交互。如果设置为 1，守护进程将不会关闭这些文件描述符。
返回值：
  • 成功时，返回 0。
  • 出错时，返回 -1，并将 errno 设置为具体的错误值。

daemon() 的作用

daemon() 函数执行以下操作：

  1. 分离进程：它使进程脱离控制终端，成为一个守护进程。
  2. 改变工作目录：它将工作目录切换到根目录 /，以确保守护进程不会阻止文件系统的卸载。
  3. 关闭文件描述符：它关闭进程的标准输入、标准输出和标准错误输出，通常会将这些文件描述符重定向到某个日志文件或 /dev/null。

守护进程的常见步骤

通常，守护进程的创建步骤包括：

  1. 调用 fork() 创建子进程，父进程退出。
  2. 调用 setsid() 创建新会话并脱离终端。
  3. 调用 daemon() 或手动设置工作目录并关闭文件描述符。

使用 daemon() 示例

下面是一个简单的 C 程序示例，演示如何使用 daemon() 创建守护进程：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>int main() {// 调用 daemon() 创建守护进程if (daemon(0, 0) == -1) {perror("daemon failed");exit(EXIT_FAILURE);}// 守护进程在后台执行任务while (1) {// 模拟后台任务// 这里可以执行长期运行的任务，如定时备份、日志记录等sleep(60);  // 每分钟执行一次}return 0;
}

代码解析：

  • daemon(0, 0)：将守护进程从终端脱离，改变当前工作目录到根目录，并关闭标准输入、标准输出和标准错误输出。这个调用会将进程转为守护进程。
  • sleep(60)：模拟守护进程在后台执行任务，每分钟执行一次。

daemon() 与 setsid() 和 fork() 的比较

在手动创建守护进程时，通常会使用 fork() 和 setsid() 来脱离终端并创建一个新的会话。然而，daemon() 函数将这些步骤封装在一个调用中，因此可以更方便地创建守护进程。基本上，daemon() 做了以下几件事：

  1. 创建一个子进程，父进程退出。
  2. 调用 setsid() 创建新会话并使进程脱离终端。
  3. 改变工作目录到根目录。
  4. 关闭标准输入、输出、错误输出。

使用守护进程时的注意事项

  1. 文件描述符：守护进程会关闭标准输入、标准输出和标准错误输出，因此在守护进程中通常需要将这些描述符重定向到 /dev/null 或某个日志文件。
  2. 退出状态：守护进程通常是长期运行的，退出时要考虑清理工作，如关闭打开的文件、释放资源等。
  3. 进程管理：可以使用进程管理工具如 systemd 或 init.d 来启动和管理守护进程。

总结

  • daemon() 是一个用于创建守护进程的方便函数，它将一些常见的守护进程设置封装在一起。
  • 它脱离控制终端、改变工作目录为根目录、关闭标准输入输出等，使得进程成为一个后台独立运行的守护进程。
  • 它是编写需要长期运行、无交互的后台任务程序时常用的函数。

tcp通信时全双工的

read/write相当于拷贝到缓冲区

​

​

相关文章：

网络（TCP）

目录 TCP socket API 详解 套接字有哪些类型&#xff1f;socket有哪些类型&#xff1f; 图解TCP四次握手断开连接 图解TCP数据报结构以及三次握手&#xff08;非常详细&#xff09; socket缓冲区以及阻塞模式详解 再谈UDP和TCP bind(): 我们的程序中对myaddr参数是这样…...

编程日记 2024/12/5 6:25:20

CSS 选择器的优先级

一、基本概念 CSS 选择器的优先级决定了在样式冲突时&#xff0c;哪个样式规则将被应用到 HTML 元素上。通过理解 CSS 选择器的优先级&#xff0c;可以更好地控制网页元素的样式&#xff0c;避免样式冲突。 二、优先级计算规则 1. 内联样式 内联样式具有最高的优先级。 &l…...

编程日记 2024/12/5 6:24:19

留学生数学辅导作业随机过程高等线性代数概率论微积分优化统计

针对留学生数学辅导作业中的随机过程、高等线性代数、概率论、微积分、优化以及统计等科目&#xff0c;以下是一些详细的辅导建议和资源概述&#xff1a; 一、随机过程 概念理解&#xff1a; 随机过程是研究随机现象随时间演变的数学分支。它涉及概率论和数理统计的知识&#…...

编程日记 2024/12/5 6:23:18

移动机器人课程建图实验-ROSbug汇总

问题1描述 $ rosrun robot_state_publisher robot_state_publisher [ERROR] [1733131886.474757207]: [registerPublisher] Failed to contact master at [localhost:11311]. Retrying...解决方案 这个错误信息表明 robot_state_publisher 节点无法联系到 ROS master。通常&…...

编程日记 2024/12/5 6:22:17

小家电出海，沃丰科技助力保障售后服务的及时性与高效性

随着全球化步伐的加快&#xff0c;小家电行业也逐渐迈向国际市场&#xff0c;面向全球消费者提供服务。然而&#xff0c;跨国界的销售和服务挑战也随之而来&#xff0c;尤其是售后服务的及时性与高效性成为了企业亟需解决的问题。沃丰科技凭借其全渠道在线客服、工单系统和视频…...

编程日记 2024/12/5 6:21:16

vscode 如何支持点击跳转函数，以C++为例，Python等其它编程语言同理，Visual Studio Code。

VScode(Visual Studio Code)按住Ctrl鼠标左键&#xff0c;没法跳转到对应的函数怎么办。 如下图所示 1、点击有四个小方块的图标 2、输入C&#xff08;如果你的编程语言是C&#xff0c;其它的就输其它的&#xff09; 3、找到C Extension&#xff08;其它编程语言&#xff0…...

编程日记 2024/12/5 6:20:15

创建子类对象时，会创建父类对象吗

一、查询网上的结论&#xff1a; 创建子类对象时&#xff0c; 会先调用子类构造方法对子类对象进行初始化&#xff0c;子类构造方法的第一行又会调用父类构造方法对父类进行初始化(不会创建父类对象&#xff0c; 但是会在子类对象的内存空间中开辟一块被包含的内存空间存储父类…...

编程日记 2024/12/5 6:19:14

华为、华三交换机纯Web下如何创关键VLANIF、操作STP参数

华为交换机WEB操作 使用的是真机S5735&#xff0c;目前主流的版本都适用&#xff08;V1R5~V2R1的就不在列了&#xff0c;版本太老了&#xff0c;界面完全不一样&#xff0c;这里调试线接的console口&#xff0c;电脑的网络接在ETH口&#xff09; 「模拟器、工具合集」复制整段内…...

编程日记 2024/12/5 6:18:13

MongoDB分片集群架构实战

分片集群架构 分片简介 分片&#xff08;shard&#xff09;是指在将数据进行水平切分之后&#xff0c;将其存储到多个不同的服务器节点上的一种扩展方式。分片在概念上非常类似于应用开发中的“水平分表”。不同的点在于&#xff0c;MongoDB本身就自带了分片管理的能力&#…...

编程日记 2024/12/5 6:17:12

架构 | 调优 - [zookeeper]

INDEX 0 实际使用的 zoo.cfg1 基础知识1.1 官网文档1.2 日志相关配置1.3 tick 时间 0 实际使用的 zoo.cfg ### 时间配置 ### 一个tick&#xff08;滴答&#xff09;的毫秒数&#xff0c;时间单位&#xff0c;可以认为是心跳时间 tickTime2000 ### follower 连接 leader 并与之…...

编程日记 2024/12/5 6:16:11

威联通-004 安装photoview相册应用Docker镜像

文章目录 前言准备MariaDB 10phpMyAdminphotoview 安装步骤1.安装MariaDB 10和phpMyAdmin2.初始安装MariaDB 103.进入phpMyAdmin添加账户4.手动下载photoview的Docker库注意&#xff1a;安装 phpMyAdmin 报错5.配置photoview6.容器安装成功之后进入photoview注意&#xff1a;这…...

编程日记 2024/12/5 6:15:10

Github clone 的时候出现Error in the HTTP2 framing layer错误

解决方案 github鉴权认证&#xff0c;打开gitbash&#xff0c;并输入 ssh-keygen -t rsa -C "emailicjs.cc" 执行后会在 .ssh 目录生产两个文件&#xff1a;id_rsa&#xff08;私有密钥&#xff09;和id_rsa.pub&#xff08;公开密钥&#xff09; 直接默认回车执行…...

编程日记 2024/12/5 6:14:09

SpringBoot中@Import和@ImportResource和@PropertySource

1. Import Import注解是引入java类&#xff1a; 导入Configuration注解的配置类&#xff08;4.2版本之前只可以导入配置类&#xff0c;4.2版本之后也可以导入普通类&#xff09;导入ImportSelector的实现类导入ImportBeanDefinitionRegistrar的实现类 SpringBootApplication…...

编程日记 2024/12/5 6:13:08

OpenCV 简介与安装方法

大家好啊&#xff0c;我是董董灿。 如果你在做计算机视觉相关的工作&#xff0c;肯定少不了使用 OpenCV 库。 在《计算机视觉专栏》的传统计算机视觉部分&#xff0c;我曾经使用 OpenCV 进行了很多图像的处理&#xff0c;比如边缘检测。 刚好最近在整理一份文稿&#xff0c;…...

编程日记 2024/12/5 6:12:07

pycharm基本库安装的几种方法

1、pycharm基本库安装的几种方法 1&#xff09;一次性设置下载源 cmd窗口&#xff08;管理员方式&#xff09;.输入以下命令&#xff1a; pip config set global.index-url http://pypi.tuna.tsinghua.edu.cn/simple pip config set global.trusted-host pypi.tuna.tsinghu…...

编程日记 2024/12/5 6:10:06

安装更新upgrade导致ubuntu崩溃

安装更新导致ubuntu崩溃 前言uuid编不过&#xff0c;导致的崩溃 记录一些ubuntu崩溃的过程。 目前只有一个&#xff0c;以后遇到都放在这里&#xff0c;以提醒自己。 前言 如果从10000年看现在的linux&#xff0c;不是说不完美&#xff0c;而是糟透了。 linux的版本号&#xf…...

编程日记 2024/12/5 6:09:04

数学建模选MATLAB还是Python？

选择MATLAB还是Python进行数学建模&#xff0c;取决于多个因素&#xff0c;包括你的具体需求、个人偏好、项目要求以及你已有的技能。以下是一些考虑因素&#xff1a; 1. 易用性&#xff1a; • MATLAB&#xff1a;对于数学和工程问题&#xff0c;MATLAB提供了一个非常直观和…...

编程日记 2024/12/5 6:08:03

python数组增加元素

append、appext、insert&#xff0c;在某位置插入insert最在行。 (笔记模板由python脚本于2024年12月04日 19:41:46创建&#xff0c;本篇笔记适合python基础编程的coder翻阅) 【学习的细节是欢悦的历程】 Python 官网&#xff1a;https://www.python.org/ Free&#xff1a;大咖…...

编程日记 2024/12/5 6:06:01

【笔记】离散数学 1-3 章

1. 数理逻辑 1.1 命题逻辑的基本概念 1.1.1 命题的概念 命题&#xff08;Proposition&#xff09;&#xff1a;是一个陈述句&#xff0c;它要么是真的&#xff08;true&#xff09;&#xff0c;要么是假的&#xff08;false&#xff09;&#xff0c;但不能同时为真和假。例如…...

编程日记 2024/12/5 6:04:00

AI技术在电商行业中的应用与发展

✨✨ 欢迎大家来访Srlua的博文&#xff08;づ&#xffe3;3&#xffe3;&#xff09;づ╭❤&#xff5e;✨✨ &#x1f31f;&#x1f31f; 欢迎各位亲爱的读者&#xff0c;感谢你们抽出宝贵的时间来阅读我的文章。 我是Srlua小谢&#xff0c;在这里我会分享我的知识和经验。&am…...

编程日记 2024/12/5 6:02:59

【Linux篇】权限管理 - 用户与组权限详解

一. 什么是权限&#xff1f; 首先权限是限制人的。人 真实的人 身份角色 权限 角色 事物属性 二. 认识人–用户 Linux下的用户分为超级用户和普通用户 root :超级管理员&#xff0c;几乎不受权限的约束普通用户 :受权限的约束超级用户的命令提示符是#&#xff0c;普通用…...

编程日记 2024/12/5 6:01:57

【AI系统】昇腾推理引擎 MindIE

昇腾推理引擎 MindIE 本文将介绍华为昇腾推理引擎 MindIE 的详细内容&#xff0c;包括其基本介绍、关键功能特性以及不同组件的详细描述。 本文内容将深入探讨 MindIE 的三个主要组件&#xff1a;MindIE-Service、MindIE-Torch 和 MindIE-RT&#xff0c;以及它们在服务化部署…...

编程日记 2024/12/5 6:00:57

美畅物联丨智能监控，高效运维：视频汇聚平台在储能领域的实践探索

在当今全球能源格局不断变化的大背景下&#xff0c;对清洁能源的需求正以惊人的速度增长。储能项目作为平衡能源供需、提升能源利用效率的关键环节&#xff0c;其规模和复杂度也在不断攀升。在储能项目的运营管理过程中&#xff0c;安全监控、设备运维以及数据管理等方面面临着…...

编程日记 2024/12/5 5:58:55

[SSL: UNSAFE_LEGACY_RENEGOTIATION_DISABLED]

使用requess库访问https网址时&#xff0c;返回 (Caused by SSLError(SSLError(1, [SSL: UNSAFE_LEGACY_RENEGOTIATION_DISABLED] unsafe legacy renegotiation disabled (_ssl.c:1147)))) 原因可能是服务器的认证方式版本太低然后requests抛弃了这种认证方式 参考&#xff…...

编程日记 2024/12/5 5:56:53

12.2深度学习_视觉处理CNN_池化层、卷积知识

3.池化层 3.1 概述 池化层 (Pooling) 降低维度, 缩减模型大小&#xff0c;提高计算速度. 即: 主要对卷积层学习到的特征图进行下采样&#xff08;SubSampling&#xff09;处理。 池化层主要有两种: 最大池化 max pooling 最大池化是从每个局部区域中选择最大值作为池化后的值…...

编程日记 2024/12/5 5:55:52

Kafka 常见面试题深度解析

一、基础概念 1. 请简要介绍 Kafka 的基本架构。 Kafka 主要由生产者&#xff08;Producer&#xff09;、消费者&#xff08;Consumer&#xff09;、代理&#xff08;Broker&#xff09;、主题&#xff08;Topic&#xff09;和分区&#xff08;Partition&#xff09;等组成。…...

编程日记 2024/12/5 5:54:50

LVS默认的工作模式支持哪些负载均衡算法?

LVS默认的工作模式支持哪些负载均衡算法? LVS&#xff08;Linux Virtual Server&#xff09;默认支持多种负载均衡算法&#xff0c;这些算法在不同的场景下具有各自的优势。以下是 LVS 默认支持的负载均衡算法及其特点&#xff1a; 1. 轮询调度&#xff08;Round Robin Sched…...

编程日记 2024/12/5 5:53:49

洛谷P2670扫雷游戏(Java)

三.P2670 [NOIP2015 普及组] 扫雷游戏 题目背景 NOIP2015 普及组 T2 题目描述 扫雷游戏是一款十分经典的单机小游戏。在 n 行 m列的雷区中有一些格子含有地雷&#xff08;称之为地雷格&#xff09;&#xff0c;其他格子不含地雷&#xff08;称之为非地雷格&#xff09;。玩…...

编程日记 2024/12/5 5:52:48

【算法】【优选算法】位运算（下）

目录 一、&#xff1a;⾯试题 01.01.判定字符是否唯⼀1.1 位图1.2 hash思路1.3 暴力枚举 二、268.丢失的数字2.1 位运算&#xff0c;异或2.2 数学求和 三、371.两整数之和四、137.只出现⼀次的数字 II五、⾯试题 17.19.消失的两个数字 一、&#xff1a;⾯试题 01.01.判定字符是…...

编程日记 2024/12/5 5:51:48

前端性能优化篇：防抖和节流

参考&#xff1a;JS问题&#xff1a;项目中如何区分使用防抖或节流&#xff1f; 面试官&#xff1a;什么是防抖和节流&#xff1f;有什么区别&#xff1f;如何实现&#xff1f; 1 为什么要用到防抖和节流 当函数绑定一些持续触发的事件如&#xff1a;浏览器的resize、scroll…...

编程日记 2024/12/5 5:50:47