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

网络（TCP）

news 来源：原创 2025/5/9 18:55:57

目录

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参数是这样…...

编程日记 2025/5/9 18:55:57

40分钟学 Go 语言高并发：服务性能调优实战

服务性能调优实战 一、性能优化实战概述 优化阶段主要内容关键指标重要程度瓶颈定位收集性能指标&#xff0c;确定瓶颈位置CPU、内存、延迟、吞吐量⭐⭐⭐⭐⭐代码优化优化算法、并发、内存使用代码执行时间、内存分配⭐⭐⭐⭐⭐系统调优调整系统参数、资源配置系统资源利用率…...

编程日记 2025/5/7 6:26:14

5092 星际争霸

逆序对排序&#xff1b; 字符串遍历&#xff1b; pair 特点&#xff1a; 两个值&#xff0c;第一个是字符串&#xff0c;第二个是逆序对数。而且没有重复的字符串。 #include<bits/stdc.h>using namespace std; typedef long long ll; const int N1e35; #define x f…...

编程日记 2025/5/8 5:31:16

AUTOSAR AP 汽车API知识点总结（Automotive API ）R24-11

汽车API知识点总结 一、背景与目标 背景：智能互联汽车正逐步依赖远程诊断、软件更新等功能以确保行驶安全，并且用户已习惯于通过智能设备中的应用程序控制连接设备。虽然AUTOSAR标准支持车辆软件的可更新性，但尚未提供将AUTOSAR应用产生的数据和功能安全可靠地暴露给非AUTO…...

编程日记 2025/5/6 6:33:11

vue2：Cascader 级联选择器中加载两种不同的数据结构

前言 因UI调整，需要将el-tree控件更换为级联选择器，而在原树形控件中，加载了两种不同的数据结构，（参见vue2：树形控件el-tree中加载两种不同结构的数据_vue2 树形插件-CSDN博客）所以现在级联选择器中也需要加载这两种不同的数据结构。 问题 原本以为处理方式差不多，在…...

编程日记 2025/5/6 12:43:12

【xLSTM-Transformer序列分类】Pytorch使用xLSTM-Transformer对序列进行分类源代码

Python, Pytorch使用xLSTM-Transformer对序列进行分类源代码。xLSTM是不久前LSTM团队提出来的新模型&#xff0c;将xLSTM融入Transformer的Encoder中&#xff0c;创新型较强。另外&#xff0c;Transformer是完整的&#xff0c;即使用了Encoder、Decoder和Embedding所有模块。 …...

编程日记 2025/5/7 14:07:52

TDengine 签约安徽智质，助力海螺水泥智慧工厂升级

在当前制造业数字化转型的浪潮中&#xff0c;如何实现智能化、自动化与数据驱动的高效生产&#xff0c;成为企业提升竞争力的关键。尤其是在水泥、钢铁等传统行业&#xff0c;随着技术的不断进步&#xff0c;如何打破数据孤岛、提升生产管理效率&#xff0c;已经成为许多工厂亟…...

编程日记 2025/5/8 21:34:09

Hbase整合Mapreduce案例2 hbase数据下载至hdfs中——wordcount

目录 整合结构准备数据下载pom.xmlMain.javaReduce.javaMap.java操作 总结 整合结构 和案例1的结构差不多&#xff0c;Hbase移动到开头&#xff0c;后面跟随MR程序。 因此对于输入的K1 V1会进行一定的修改 准备 在HBASE中创建表&#xff0c;并写入数据 create "wunaii…...

编程日记 2025/5/9 12:15:40

WHLUG丨deepin、华中科技大学开放原子开源俱乐部、 RustSBI 和清华大学开源操作系统训练营共话开源新生代成长之路

2024年11月30日下午&#xff0c;由 deepin&#xff08;深度&#xff09;社区联合华中科技大学开放原子开源俱乐部、 RustSBI 开源社区和清华大学开源操作系统训练营共同举办的WHLUG&#xff08;武汉Linux用户组&#xff09;线下沙龙在华中科技大学成功举办。 本次活动聚集了50余…...

编程日记 2025/5/9 8:34:00

深入理解AVL树：结构、旋转及C++实现

1. AVL树的概念 什么是AVL树&#xff1f; AVL树是一种自平衡的二叉搜索树&#xff0c;其发明者是Adelson-Velsky和Landis&#xff0c;因此得名“AVL”。AVL树是首个自平衡二叉搜索树&#xff0c;通过对树的平衡因子进行控制&#xff0c;确保任何节点的左右子树高度差最多为1&…...

编程日记 2025/5/4 5:11:34

L15.【LeetCode笔记】相同的树

目录 1.题目 代码模板 2.分析 通过合理的if判断分类讨论两个根节点 1.首先,p和q都为NULL的情况最好排除 2.排除了两个都为NULL的情况,剩下的情况:1.其中一个为NULL;2.两个都不为NULL 写法1 写法2 3.只剩下最后一种情况:p和q都不为NULL 3.代码 提交结果 1.题目 https…...

编程日记 2025/5/5 1:42:52

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

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

编程日记 2025/5/9 17:53:24

网络——Socket与WebSocket

Socket与WebSocket都是网络通信中的重要概念&#xff0c;但它们在原理、应用场景及特性上存在显著的差异。以下是对两者的详细比较&#xff1a; 一、Socket 定义&#xff1a;Socket&#xff08;套接字&#xff09;是计算机网络中的一个抽象层&#xff0c;它允许应用程序通过网…...

编程日记 2025/4/22 18:59:25

Springboot3整合Redis

书接上篇《Redis 安装篇&#xff08;阿里云服务器&#xff09;_阿里云安装redis-CSDN博客》&#xff0c;安装好Redis后&#xff0c;就需要在springboot项目中使用Redis了。 一、SpringBoot整合Redis 1.添加坐标 <!--redis--> <dependency><groupId>org.sp…...

编程日记 2025/5/6 3:27:14

Java CountDownLatch 用法和源码解析

&#x1f9d1; 博主简介&#xff1a;CSDN博客专家&#xff0c;历代文学网&#xff08;PC端可以访问&#xff1a;https://literature.sinhy.com/#/literature?__c1000&#xff0c;移动端可微信小程序搜索“历代文学”&#xff09;总架构师&#xff0c;15年工作经验&#xff0c;…...

编程日记 2025/5/6 11:57:23

微信小程序3-显标记信息和弹框

感谢阅读&#xff0c;初学小白&#xff0c;有错指正。 一、实现功能&#xff1a; 在地图上添加标记点后&#xff0c;标记点是可以携带以下基础信息的&#xff0c;如标题、id、经纬度等。但是对于开发来说&#xff0c;这些信息还不足够&#xff0c;而且还要做到点击标记点时&a…...

编程日记 2025/5/4 18:17:56

Android 消息队列之MQTT的使用：物联网通讯，HTTP太重了，使用MQTT；断网重连、注册、订阅、发送数据和接受数据，实现双向通讯。

目录&#xff1a; 问题MQTT是什么以及为什么使用如何使用&#xff1a;第一阶段、基础功能如何使用&#xff1a;第二阶段、增加断网重连如何使用&#xff1a;第三阶段、封装 一、问题 在开发的时候&#xff0c;我们一般都使用Http和后台进行通讯&#xff0c;比如我们是开发物联…...

编程日记 2025/5/9 18:12:17

详解Java数据库编程之JDBC

目录 首先创建一个Java项目 在Maven中央仓库下载mysql connector的jar包 针对MySQL版本5 针对MySQL版本8 下载之后&#xff0c;在IDEA中创建的项目中建立一个lib目录&#xff0c;然后把刚刚下载好的jar包拷贝进去&#xff0c;然后右键刚刚添加的jar包&#xff0c;点击‘添…...

编程日记 2025/5/6 17:22:53

详解C++类与对象（四）

文章目录 1.类型转换1.1 前言1.2 类型转换的性质 2.static成员2.1 前言2.2 static的基本概念 3.友元4.内部类5.匿名对象 1.类型转换 1.1 前言 在C中&#xff0c;由于程序员可以自己显示定义一个新的类。这样就会出现一个问题&#xff1a;程序员自己显示定义的类类型与编译器中…...

编程日记 2025/5/9 5:30:17

使用 postman 传递 binary 类型的图片到后端接口遇到的坑

使用 psotman 传 binary 类型图片报错&#xff1a; -2024-12-04 [http-nio-9090-exec-1] WARN org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver Resolved [org.springframework.http.converter.HttpMessageNotReadableException: Required r…...

编程日记 2025/5/9 1:46:32

第9章 大模型的有害性（上）

9.1 引言 本章将探讨大型语言模型&#xff08;LLMs&#xff09;可能带来的有害性&#xff0c;重点讨论以下几个方面&#xff1a; 性能差异社会偏见和刻板印象 在后续内容中&#xff0c;还会涉及其他层面的危害&#xff0c;如有害信息、虚假信息、隐私和安全风险、版权问题、…...

编程日记 2025/5/9 14:01:31

计算机视觉——相机标定(Camera Calibration)

文章目录 1. 简介2. 原理3. 相机模型3.1 四大坐标系3.2 坐标系间的转换关系3.2.1 世界坐标系到相机坐标系3.2.2 相机坐标系到图像坐标系3.2.3 像素坐标系转换为图像坐标系3.2.4 世界坐标转换为像素坐标 3.3 畸变3.3.1 畸变类型3.3.1.1 径向畸变&#xff08;Radial Distortion&a…...

编程日记 2025/5/9 14:28:18

Java爬虫技术全解析：从入门到精通

引言 在信息爆炸的今天&#xff0c;数据成为了最宝贵的资源之一。爬虫技术作为获取网络数据的重要手段&#xff0c;广泛应用于数据采集、信息聚合、市场分析等多个领域。Java作为一种强类型、面向对象的编程语言&#xff0c;以其稳健的性能和跨平台的特性&#xff0c;成为了开…...

编程日记 2025/5/9 14:48:05

leetcode hot100【Leetcode 416.分割等和子集】java实现

Leetcode 416.分割等和子集 题目描述 给定一个非负整数的数组 nums &#xff0c;你需要将该数组分割成两个子集&#xff0c;使得两个子集的元素和相等。如果可以分割&#xff0c;返回 true &#xff0c;否则返回 false。 示例 1&#xff1a; 输入&#xff1a;nums [1,5,11,…...

编程日记 2025/5/9 14:53:17

位段详解+代码展示

系列文章目录 &#x1f388; &#x1f388; 我的CSDN主页:OTWOL的主页&#xff0c;欢迎&#xff01;&#xff01;&#xff01;&#x1f44b;&#x1f3fc;&#x1f44b;&#x1f3fc; &#x1f389;&#x1f389;我的C语言初阶合集&#xff1a;C语言初阶合集&#xff0c;希望能…...

编程日记 2025/5/9 0:26:43

python实现c++中so库调用及dbus服务开发

本期介绍主要分两块，一块是python如何调用so库，另一块是dbus服务的注册与调用； python调用so库 1. c++源码 # test.h文件#include<iostream> using namespace std;extern "C"{ int cacl(int a, int b); struct student{char sname[50];int score;}; stud…...

编程日记 2025/5/9 14:16:20

如何进行GC调优

目录 1、GC是什么? 垃圾回收算法、收集器等 2、优化目标 3、优化策略 这个属于较为开放题目&#xff0c;可以结合自己项目实战出发&#xff0c;体现JVM调优。 1、GC是什么? 垃圾回收算法、收集器等 2、优化目标 (1) 将进入老年代的对象数量降到最低 (2) 减少FullGC的执行…...

编程日记 2025/5/9 15:49:12

JAVA ｜日常开发中读写TXT文本详解

JAVA &#xff5c;日常开发中读写TXT文本详解 前言一、读取 TXT 文本1.1 使用BufferedReader读取1.2 使用Scanner读取 二、写入 TXT 文本2.1 使用BufferedWriter写入2.2 使用PrintWriter写入2.3 字节流写入&#xff08;FileOutputStream&#xff09;后转换为字符流&#xff08;…...

编程日记 2025/5/9 14:41:56

开源模型应用落地-安全合规篇-用户输入价值观判断（三）

一、前言 在深度合规功能中，对用户输入内容的价值观判断具有重要意义。这一功能不仅仅是对信息合法性和合规性的简单审核，更是对信息背后隐含的伦理道德和社会责任的深刻洞察。通过对价值观的判断，系统能够识别可能引发不当影响或冲突的内容，从而为用户提供更安全、更和谐的…...

编程日记 2025/5/9 13:43:07

apache部署若依前后端分离项目（开启SSL）

网站部署之后，大多数需要配置https，所以本章教程，介绍使用apache部署若依前后端项目的时候，如何开启SSL，以及如何配置SSL证书。 一、安装ssl模块 默认情况下，ssl模块是没有安装的。需要手动安装，否则直接配置SSL模块的时候，会报错。 sudo yum install mod_ssl二、查询s…...

编程日记 2025/5/9 14:18:54

VMware Workstation Pro安装教程 （全图文保姆级）

一、前言 系统&#xff1a;Windows 11时间&#xff1a;2024/12/04需求&#xff1a;注册&#xff1a;broadcom&#xff08;邮箱&#xff09;难点&#xff1a;在官网找到下载链接 二、说明 建议前往官网&#xff08;https://www.vmware.com&#xff09;下载&#xff0c;可能加…...

编程日记 2025/5/8 22:16:09

【机器学习】—Transformers的扩展应用：从NLP到多领域突破

好久不见&#xff01;喜欢就关注吧~ 云边有个稻草人-CSDN博客 目录 引言 一、Transformer架构解析 &#xff08;一&#xff09;、核心组件 &#xff08;二&#xff09;、架构图 二、领域扩展&#xff1a;从NLP到更多场景 1. 自然语言处理&#xff08;NLP&#xff09; 2…...

编程日记 2025/5/5 7:21:26

Linux权限机制深度解读：系统安全的第一道防线

文章目录 前言‼️一、Linux权限的概念‼️二、Linux权限管理❕2.1 文件访问者的分类&#xff08;人&#xff09;❕2.2 文件类型和访问权限&#xff08;事物属性&#xff09;✔️1. 文件类型✔️2. 基本权限✔️3. 权限值的表示方法 ❕2.3 文件访问权限的相关设置方法✔️1. ch…...

编程日记 2025/5/9 13:38:09

【数据集】细胞数据集：肿瘤-胎儿重编程的内皮细胞驱动肝细胞癌中的免疫抑制性巨噬细胞（Sharma等人）

引用此数据集&#xff1a; Sharma, Ankur (2020), “Onco-fetal reprogramming of endothelial cells drives immunosuppressive macrophages in Hepatocellular Carcinoma (Sharma et al)”, Mendeley Data, V1, doi: 10.17632/6wmzcskt6k.1 下载地址&#xff1a;Onco-feta…...

编程日记 2025/5/9 14:27:25

LangChain学习笔记（一）-LangChain简介

LangChain学习笔记&#xff08;一&#xff09;-LangChain简介 langChain是一个人工智能大语言模型的开发框架&#xff0c;主要构成为下图。 ​ ​ 一、核心模块 &#xff08;一&#xff09;模型I/O模块 负责与现有大模型进行交互&#xff0c;由三部分组成&#xff1a; 提…...

编程日记 2025/5/9 3:03:46

【Dubbo03】消息队列与微服务之dubbo-admin 二进制与编译安装

实战案例&#xff1a;二进制安装 dubbo-admin 新版用Golang重构&#xff0c;提供了二进制包&#xff0c;可以直接部署 #下载二进制包 [rootubuntu2204 ~]#wget https://github.com/apache/dubbo-admin/releases/download/0.5.0/apache-dubbo-admin-0.5.0-bin-release.tar.gz …...

编程日记 2025/5/9 15:07:09

常见问题QA的前端代码

这个的后端代码参见此文 使用语言向量建立常见问题的模糊搜索-CSDN博客https://blog.csdn.net/chenchihwen/article/details/144207262?spm1001.2014.3001.5501 这段代码实现了一个简单的问答页面&#xff0c;页面分为左右两部分&#xff0c;左侧用于展示对话记录&#xff0c…...

编程日记 2025/5/9 13:50:08

【Java基础面试题010】Java中的基本数据类型有哪些？

相关知识补充&#xff1a;《Java从入门到精通(JDK17版)》_尚硅谷电子书.pdf Autism_Btkrsr/Blog_md_to_pdf - 码云 - 开源中国 (gitee.com) 回答重点 Java提供了8中基本数据类型 整型&#xff1a; byte&#xff1a;占用1字节&#xff0c;取值范围 -128 到 127short&#x…...

编程日记 2025/5/9 13:34:51

记录部署dvwa靶场踩的几个坑

DVWA reCAPTCHA key: Missing 解决方法&#xff1a;网上随便copy一个&#xff0c;粘贴到config.inc.php配置文件里&#xff0c;具体我也是参考这篇文章的&#xff1a;DVWA下载、安装You dont have permission to access this resource.Server unable to read htaccess file, de…...

编程日记 2025/5/9 14:50:37

【Pytorch】torch.reshape与torch.Tensor.reshape区别

问题引入&#xff1a; 在Pytorch文档中&#xff0c;有torch.reshape与torch.Tensor.reshape两个reshape操作&#xff0c;他们的区别是什么呢&#xff1f; 我们先来看一下官方文档的定义&#xff1a; torch.reshape&#xff1a; torch.Tensor.reshape: 解释&#xff1a; 在p…...

编程日记 2025/5/9 13:41:24

GPT vs Claude到底如何选？

美国当地时间6月20日&#xff0c;OpenAI的“劲敌”Anthropic公司发布了最新模型Claude 3.5 Sonnet。据Anthropic介绍&#xff0c;该模型是Claude 3.5系列模型中的首个版本&#xff0c;也是Anthropic迄今为止发布的“最强大、最智能”的模型。它不仅在性能上超越了竞争对手和自家…...

编程日记 2025/5/9 15:07:54

基于C++实现的（控制台）双人俄罗斯方块小游戏

基于win32控制台应用程序的双人俄罗斯方块小游戏 1. 课题概述 1.1 课题目标和主要内容 使用visual studio 2015在win32控制台应用程序下用多线程实现双人同时进行俄罗斯方块的桌面游戏。最终将要完成的效果如图1.1所示&#xff0c;左右共两片工作区&#xff0c;也是游戏的主…...

编程日记 2025/5/9 16:12:23

Linux-虚拟环境

文章目录 一. 虚拟机二. 虚拟化软件三. VMware WorkStation四. 安装CentOS操作系统五. 在VMware中导入CentOS虚拟机六. 远程连接Linux系统1. Finalshell安装2. 虚拟机网络配置3. 连接到Linux系统 七. 虚拟机快照 一. 虚拟机 借助虚拟化技术&#xff0c;我们可以在系统中&#…...

编程日记 2025/5/9 14:21:40

uniapp开发微信小程序笔记10-触底加载

前言&#xff1a; 触底加载需求描述&#xff1a; 经常在做一些商品列表页的时候&#xff0c;如果一次性加载大量数据会影响性能&#xff0c;一般都是先加载10-20条&#xff0c;等用户向下滑到底部时再加载新的数据并渲染上去。 1、官方提供了一个API&#xff1a;onReachBott…...

编程日记 2025/5/9 13:09:45

Pytest --capture 参数详解：如何控制测试执行过程中的输出行为

--capture 选项用于控制测试用例执行过程中标准输出&#xff08;stdout&#xff09;和标准错误输出&#xff08;stderr&#xff09;的捕获行为。 --capture 的选项值&#xff1a; fd&#xff08;默认&#xff09; 捕获文件描述符级别的输出&#xff08;stdout 和 stderr&#x…...

编程日记 2025/5/9 3:00:32

JMeter实时性能压测可视化系统整合

一、相关工具简介： JMeter、Grafana 和 InfluxDB 结合实时地收集、分析和展示性能测试数据，进行更好地理解系统的性能表现，及时发现潜在问题并进行优化。 1，JMeter 实时生成性能数据，并将其发送到 InfluxDB 进行存储。2，InfluxDB 存储的数据。3，通过Grafana的仪表板，用…...

编程日记 2025/5/8 21:27:27

USB 声卡全解析：提升音频体验的得力助手

在当今数字化的时代&#xff0c;音频领域的追求愈发多元。无论是热衷聆听高品质音乐的爱好者&#xff0c;还是在专业音频工作中精雕细琢的人士&#xff0c;亦或是在游戏世界里渴望极致音效沉浸的玩家&#xff0c;都始终在寻觅能让音频体验更上一层楼的妙法。而 USB 声卡&#x…...

编程日记 2025/5/9 11:42:46

GoReplay开源工具使用教程

目录 一、GoReplay环境搭建 1、Mac、Linux安装GoReplay环境 二、GoReplay录制与重播 1、搭建练习接口 2、录制命令 3、重播命令 三、GoReplay单个命令 1、常用命令 2、其他命令 3、命令示例 4、性能测试 5、正则表达式 四、gorepaly组合命令 1、组合命令实例 2、…...

编程日记 2025/5/9 11:16:32

Qt开源控件：图像刻度轴绘制器 （附源码）工程项目私信博主

项目简介 图像刻度轴绘制器是一款基于 Qt/C 开发的小型绘图工具&#xff0c;旨在实现带有刻度轴的图像显示功能。该项目主要用于需要精确测量或标注图像坐标的场景。通过左侧和底部的坐标轴以及对应的刻度线&#xff0c;可以直观地了解图像内容在二维空间中的位置。 项目功能 …...

编程日记 2025/5/9 12:45:50

下载 M3U8 格式的视频

要下载 M3U8 格式的视频&#xff08;通常是 HLS 视频流&#xff09;&#xff0c;可以尝试以下几种方法&#xff1a; 方法 1&#xff1a;使用下载工具&#xff08;推荐&#xff09; 1. IDM&#xff08;Internet Download Manager&#xff09;&#xff1a; 安装 IDM 并启用浏…...

编程日记 2025/5/9 12:46:49