目录
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是面向字节流的,第三个参数不用填,协议类型,创建一个套接字的本质就是打开一个文件,必须要告诉服务器,端口号,然后再绑定套接字端口号
不同类型(第一个参数的)
第二个:定义的套接字的类型
第三个写0就可以
下面介绍程序中用到的socket API,这些函数都在sys/socket.h中。socket():
bind():
我们的程序中对myaddr参数是这样初始化的:
listen():
- isten()声明sockfd处于监听状态, 并且最多允许有backlog个客户端处于连接等待状态, 如果接收到更多 的连接请求就忽略, 这里设置不会太大(一般是5), 具体细节同学们课后深入研究;
- listen()成功返回0,失败返回-1;
accept():
我们的服务器程序结构是这样的:
理解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
(即忽略信号)。下面介绍一些常见的信号及其忽略方式。
常见的信号及其忽略方法
-
**
SIGPIPE
**:当进程尝试向一个已关闭的管道或套接字写入数据时,系统会向进程发送SIGPIPE
信号。默认情况下,进程会因接收到SIGPIPE
信号而终止程序。在一些应用程序中(如网络编程),你可能希望忽略这个信号,避免进程崩溃。忽略方法:
signal(SIGPIPE, SIG_IGN);
这行代码会让程序在遇到
SIGPIPE
信号时不做任何处理,程序将继续运行,而不是因为尝试写入关闭的管道而崩溃。 -
**
SIGCHLD
**:当子进程终止时,操作系统会向父进程发送SIGCHLD
信号。默认情况下,父进程会接收到这个信号并需要调用wait()
或waitpid()
来回收子进程的退出状态。如果不想处理这个信号,可以通过忽略它来避免父进程被中断。忽略方法:
signal(SIGCHLD, SIG_IGN);
这将使得父进程忽略
SIGCHLD
信号,而不需要显式地等待子进程的结束。 -
**
SIGUSR1
和SIGUSR2
**:这两个信号是用户定义的信号,可以用于应用程序自定义的行为。在某些情况下,你可能不希望进程响应这些信号,通常在进程不需要使用这些信号时会选择忽略。忽略方法:
signal(SIGUSR1, SIG_IGN); signal(SIGUSR2, SIG_IGN);
-
**
SIGINT
**:当用户按下Ctrl+C
时,通常会向进程发送SIGINT
信号,默认情况下进程会终止。如果你希望在某些情况下忽略SIGINT
信号(例如,防止用户终止正在运行的程序),可以使用以下方法:忽略方法:
signal(SIGINT, SIG_IGN);
这将让程序忽略
Ctrl+C
产生的中断信号,程序将继续运行。 -
**
SIGTERM
**:SIGTERM
是一个请求终止进程的信号,通常用来请求程序优雅退出。如果你希望程序在收到SIGTERM
信号时不退出,可以选择忽略它。忽略方法:
signal(SIGTERM, SIG_IGN);
这将让程序忽略
SIGTERM
信号,程序不会因为外部终止请求而退出。
使用 signal()
函数忽略信号
signal()
函数可以用于设置信号的处理程序,以下是常用的忽略信号的语法:
signal(signal_number, SIG_IGN);
-
signal_number
:表示要忽略的信号编号(如SIGPIPE
,SIGINT
,SIGTERM
等)。 -
SIG_IGN
:表示忽略信号。
使用 sigaction()
函数忽略信号
sigaction()
是一种更为强大和灵活的信号处理机制,可以提供更精细的控制,包括设置信号屏蔽、信号处理程序等。通过 sigaction()
忽略信号的方式如下:
#include <signal.h>struct sigaction sa;
sa.sa_handler = SIG_IGN; // 设置为忽略信号
sigemptyset(&sa.sa_mask); // 清空信号掩码
sa.sa_flags = 0; // 不使用特殊标志sigaction(SIGINT, &sa, NULL); // 忽略 SIGINT 信号
常见信号的忽略示例
以下是一些常见信号的忽略示例:
#include <iostream>
#include <signal.h>
#include <unistd.h>using namespace std;int main() {// 忽略 SIGINT 信号(Ctrl+C)signal(SIGINT, SIG_IGN);// 忽略 SIGPIPE 信号(写入关闭的管道时)signal(SIGPIPE, SIG_IGN);// 忽略 SIGTERM 信号(终止进程请求)signal(SIGTERM, SIG_IGN);cout << "Signal handling example: ignoring SIGINT, SIGPIPE, and SIGTERM" << endl;// 程序继续执行,等待信号while (true) {sleep(1); // 程序保持运行,等待信号}return 0;
}
在上述示例中,程序会忽略 SIGINT
(Ctrl+C)、SIGPIPE
(写入关闭管道)和 SIGTERM
(请求终止进程)信号。如果用户按下 Ctrl+C
或尝试向关闭的管道写数据时,程序不会被终止,而是继续运行。
总结
-
忽略信号:使用
signal(signal_number, SIG_IGN)
或sigaction()
可以让进程忽略特定的信号,避免因信号导致程序异常终止或干扰。 -
常见信号忽略:常见需要忽略的信号包括
SIGPIPE
、SIGINT
、SIGTERM
和SIGCHLD
等。 -
**
signal()
与sigaction()
**:signal()
是一种简单的信号处理方式,sigaction()
提供了更强大的功能和更高的可移植性,适用于更复杂的信号处理需求。
通过适当的信号忽略和处理,可以提升程序的稳定性和鲁棒性,尤其是在网络编程或需要长时间运行的后台进程中。
TcpClient.cc 修改成多次可以使用服务的
连续输入
读写出错进行重连
守护进程
前台进程 后台进程
后台进程不能标准输入
3个后台进程了
把2号任务提到前台进程
ctrl c终止前台进程
把任务提到前台进程,后悔了,再重新放回后台
ctrl z就可以暂停,然后系统自动把bash提到前台
bg 3再把3号进程启动起来
session(进程会话)
在Linux中,session
(会话)通常指的是与用户交互的一个环境,它是系统中与某个用户交互的一系列活动的集合。会话在Linux系统中有多种用途,下面是几种常见的会话类型及其相关概念:
1. 登录会话(Login Session)
当用户通过登录界面(如终端或图形界面)登录到系统时,系统会为该用户创建一个会话。登录会话包括:
-
用户身份验证(通过用户名和密码等方式)。
-
运行用户的默认Shell(例如
bash
)。 -
用户环境变量的设置(例如
$PATH
、$HOME
等)。
这种会话通常由登录管理器(如login
、sshd
或gdm
等)管理。当用户退出登录时,该会话会结束。
2. 进程会话(Process Session)
在Linux中,每个进程都有一个会话(Session),这个会话由session leader
(会话领导进程)控制。进程会话的特征包括:
-
每个进程在启动时都会被分配一个会话ID。
-
会话通常由一个进程创建,称为会话领导进程。
-
会话通常用于进程组管理,特别是在控制终端和后台进程之间的交互。
会话的管理由setsid()
系统调用进行,当进程调用setsid()
时,它会创建一个新的会话,并成为该会话的领导进程
前台任务和后台任务比较好
本质
任务里有多个进程组
每多建一个就多一个
绘画和终端都关掉了,那些任务仍然在
bash也退了,然后就托孤了
受到了用户登录和退出的影响
守护进程化---不想受到任何用户登陆和注销的影响
如何做到(setsid)(创建新会话)
怎么保证自己不是组长
守护进程本质(孤儿进程)
守护进程忽略的几个信号和含义
在 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()
函数执行以下操作:
- 分离进程:它使进程脱离控制终端,成为一个守护进程。
- 改变工作目录:它将工作目录切换到根目录
/
,以确保守护进程不会阻止文件系统的卸载。 - 关闭文件描述符:它关闭进程的标准输入、标准输出和标准错误输出,通常会将这些文件描述符重定向到某个日志文件或
/dev/null
。
守护进程的常见步骤
通常,守护进程的创建步骤包括:
- 调用
fork()
创建子进程,父进程退出。 - 调用
setsid()
创建新会话并脱离终端。 - 调用
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()
做了以下几件事:
- 创建一个子进程,父进程退出。
- 调用
setsid()
创建新会话并使进程脱离终端。 - 改变工作目录到根目录。
- 关闭标准输入、输出、错误输出。
使用守护进程时的注意事项
- 文件描述符:守护进程会关闭标准输入、标准输出和标准错误输出,因此在守护进程中通常需要将这些描述符重定向到
/dev/null
或某个日志文件。 - 退出状态:守护进程通常是长期运行的,退出时要考虑清理工作,如关闭打开的文件、释放资源等。
- 进程管理:可以使用进程管理工具如
systemd
或init.d
来启动和管理守护进程。
总结
daemon()
是一个用于创建守护进程的方便函数,它将一些常见的守护进程设置封装在一起。- 它脱离控制终端、改变工作目录为根目录、关闭标准输入输出等,使得进程成为一个后台独立运行的守护进程。
- 它是编写需要长期运行、无交互的后台任务程序时常用的函数。
tcp通信时全双工的
read/write相当于拷贝到缓冲区