网络编程套接字(3): 简单的TCP网络程序

文章目录

  • 网络编程套接字(3)
    • 4. 简单的TCP网络程序
      • 4.1 服务端创建
        • (1) 创建套接字
        • (2) 绑定端口
        • (3) 监听
        • (4) 获取新连接
        • (5) 处理读取与写入
      • 4.2 客户端创建
        • (1)连接服务器
      • 4.3 代码编写
        • (1) v1__简单发送消息
        • (2) v2_多进程版本
        • (3) v3_多线程版本
        • (4) v4_线程池版本

网络编程套接字(3)

4. 简单的TCP网络程序

4.1 服务端创建

(1) 创建套接字

还是之前udp部分的socket函数，这里只是简单说明一下与udp的差异

int socket(int domain, int type, int protocol);

只需将第二个参数type换成：
SOCK_STREAM: 基于TCP的网络通信，流式套接字，提供的是流式服务(对应TCP的特点：面向字节流)

(2) 绑定端口

还是和之前一样的接口

(3) 监听

UDP服务器的初始化操作只有2步，第一步：创建套接字，第二步：是绑定。但是TCP服务器是面向连接的，客户端在正式向TCP服务器发送数据之前，需要先与TCP服务器建立连接，然后才能与服务器进行通信。

因此TCP服务器需要时刻注意是否有客户端发来连接请求，此时就需要将TCP服务器创建的套接字设置为监听状态

在这里插入图片描述

listen for connections on a socket: 监听套接字上的连接

头文件:#include <sys/types.h>         #include <sys/socket.h>函数原型:int listen(int sockfd, int backlog);参数说明:第一个参数sockfd:  需要设置为监听状态的套接字对应的文件描述符第二个参数backlog: 这里当成一个整数,后续详细解释返回值:监听成功: 返回0监听失败: 失败返回-1，并设置错误码

(4) 获取新连接

客户端有新链接到来，服务端可以获取到新链接，这一步需要死循环获取客户端新链接。

在这里插入图片描述

accept a connection on a socket: 接收套接字上的连接

头文件:#include <sys/types.h>         #include <sys/socket.h>函数原型:int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);参数说明:第一个参数sockfd:  监听套接字第二个参数addr:    获取对方一端网络相关的属性信息第三个参数addrlen: addr的长度返回值:连接成功: 返回接收到的套接字的文件描述符连接失败: 失败返回-1，并设置错误码

关于accept的返回值: 也是一个文件描述符

为什么又返回一个新的文件描述符？？返回的这个新的文件描述符跟旧的文件描述符_sockfd有什么关系？

感性理解:

在这里插入图片描述

对比listen监听套接字与accept函数返回的套接字

  • listen监听套接字：用于获取客户端发来的连接请求。accept函数会不断从监听套接字当中获取新连接
  • accept函数返回的套接字：用于为本次accept获取到的连接提供服务。
  • 而listen监听套接字的任务只是不断获取新连接，而真正为这些连接提供服务的套接字是accept函数返回的套接字，而不是监听套接字。

(5) 处理读取与写入

因为TC 提供的是流式服务，所以这里利用read和write来实现读取与写入

4.2 客户端创建

4步：创建套接字，客户端向服务器发起连接请求，bind(不需要自己绑定，由OS自动分配)，处理数据读取与写入

(1)连接服务器

在这里插入图片描述

initiate a connection on a socket: 在套接字上发起连接

头文件:#include <sys/types.h>#include <sys/socket.h>函数原型:int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);参数说明:第一个参数sockfd: 表示通过该套接字发起连接请求第二个参数addr: 对方一端网络相关的属性信息第三个参数addrlen: addr的长度返回值：连接成功: 返回0连接失败: 失败返回-1，并设置错误码

4.3 代码编写

这里一共提供4个版本的tcp代码

err.hpp：这个代码是公用的后续不在给出

#pragma onceenum
{USAGE_ERR=1,SOCKET_ERR,BIND_ERR,LISTEN_ERR,CONNECT_ERR,
};

(1) v1__简单发送消息

客户端向服务端发送消息，服务端收到后再把消息发回给客户端

tcpServer.hpp

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include"err.hpp"
using namespace std;// 问题: 目前的服务器, 无法处理多个client的问题, 为什么?
// 单进程服务, 当服务端向客户端提供业务处理服务时, 没有办法accet, 不能处理连接namespace ns_server
{static const uint16_t defaultport=8081;static int backlog=32;using func_t=function<string(const string&)>;   // 回调函数,一种处理逻辑class TcpServer{public:TcpServer(func_t func, uint16_t port=defaultport):func_(func),port_(port),quit_(true){}void InitServer(){// 1. 创建socket文件listensock_=socket(AF_INET,SOCK_STREAM,0);if(listensock_<0){cerr<<"create socket error"<<endl;exit(SOCKET_ERR);}// 2. bindstruct sockaddr_in local;memset(&local,0,sizeof(local));local.sin_port=htons(port_);local.sin_family=AF_INET;local.sin_addr.s_addr=INADDR_ANY;int n=bind(listensock_,(struct sockaddr*)&local,sizeof(local));if(n<0){cerr<<"bind socket error"<<endl;exit(BIND_ERR);}// 3. 监听int m=listen(listensock_,backlog);if(m<0){cerr<<"listen socket error"<<endl;exit(LISTEN_ERR);}}void Start(){quit_=false;while(!quit_){struct sockaddr_in client;socklen_t len=sizeof(client);// 4. 获取连接, acceptint sock=accept(listensock_,(struct sockaddr*)&client,&len);if (sock < 0)   // accept失败并不会终止进程, 只要获取下一个连接{cerr << "accept error" << endl;continue;}// 提取client信息   --- debugstring clientip=inet_ntoa(client.sin_addr); // 把4字节对应的IP转化成字符串风格uint16_t clientport=ntohs(client.sin_port);  // 网络序列转主机序列// 5. 获取新连接成功后, 开始进行业务处理cout<<"获取新连接成功: "<<sock<<" from "<<listensock_<<", "<< clientip << "-				   " <<clientport<<endl;// v1service(sock,clientip,clientport);}}// 流式 - 利用read和writevoid service(int sock, const string&clientip,const uint16_t clientport){string who=clientip + "-" + to_string(clientport);char buffer[1024];while(true){ssize_t s=read(sock,buffer,sizeof(buffer)-1);if(s>0){buffer[s]=0;string res=func_(buffer);     // 进行回调cout<<who<< ">>> " <<res<<endl;// 把收到的消息返回(写给客户端)write(sock,res.c_str(),res.size());}else if(s==0){// 对方将连接关闭了close(sock);cout<< who <<" quit, me too"<<endl;break;}else{close(sock);cerr<<"read error: "<<strerror(errno)<<endl;break;}}}~TcpServer(){}private:uint16_t port_;int listensock_;bool quit_;      // 标志服务器是否运行字段func_t func_;};
}

tcpServer.cc

#include"tcpServer.hpp"
using namespace ns_server;// ./tcp_server port// 使用手册
static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" port\n"<<endl;
}string echo(const string&message)
{return message;
}int main(int argc,char*argv[])
{if(argc!=2){usage(argv[0]);exit(USAGE_ERR);}uint16_t port=atoi(argv[1]);unique_ptr<TcpServer> tsvr(new TcpServer(echo,port));tsvr->InitServer();tsvr->Start();return 0;
}

tcpClient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include"err.hpp"
using namespace std;static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" serverip serverport\n" <<endl;
}// ./tcp_client serverip serverport
int main(int argc,char*argv[])
{// 准备工作if(argc!=3){usage(argv[0]);exit(USAGE_ERR);}string serverip=argv[1];uint16_t serverport=atoi(argv[2]);// 1.创建套接字int sock=socket(AF_INET,SOCK_STREAM,0);if (sock < 0){cerr << "create socket error: " << strerror(errno) << endl;exit(SOCKET_ERR);}// (2) 客户端要不要bind呢? 要//     要不要自己bind呢? 不要, 因为client要让OS自动给用户进行bind// (3) 要不要listen?不要, 客户端连别人, 永远都是别人listen; 要不要accept?不要, 服务器来连接// 2. connect  客户端向服务器发起连接请求struct sockaddr_in server;memset(&server,0,sizeof(server));server.sin_port=htons(serverport);server.sin_family=AF_INET;// server.sin_addr.s_addr=INADDR_ANY;   绝对不是inet_aton(serverip.c_str(),&(server.sin_addr));    // 字符串风格ip转成点分十进制int cnt=5;while(connect(sock,(struct sockaddr*)&server,sizeof(server))!=0)   // 连接失败{sleep(1);cout<<"正在给你重连, 重连次数还有: "<<cnt--<<endl;if(cnt<=0)break;}if(cnt<=0){cerr<<"连接失败"<<endl;exit(CONNECT_ERR);}char buffer[1024];// 3. 连接成功while(true){string line;cout<<"Enter>> ";getline(cin,line);write(sock,line.c_str(),line.size());ssize_t s = read(sock, buffer, sizeof(buffer)-1);if (s > 0){buffer[s] = 0;cout<<"server echo >>>"<<buffer<<endl;}else if (s == 0){cerr << "server quit" << endl;break;}else{cerr << "read error: " << strerror(errno) << endl;break;}}close(sock);return 0;
}

运行结果:

在这里插入图片描述

(2) v2_多进程版本

v2版本是把单执行流服务器改成多进程版的服务器

  • 在accept获取新连接成功后，fork创建创建子进程，此时子进程对外提供服务, 父进程只进行accept

  • 父进程的文件描述符会被子进程继承，但并不是父子共用同一张文件描述符表，因为子进程会拷贝继承父进程的文件描述符表

  • 对于套接字文件也是相同的，父进程创建的子进程也会继承父进程的套接字文件，此时子进程就能够对特定的套接字文件进行读写操作，进而完成对对应客户端的服务

关于阻塞等待与非阻塞等待

  • 若采用阻塞式等待，那么服务端还是需要等待服务完当前客户端，才能继续获取下一个连接请求，此时服务端仍然是以一种串行的方式为客户端提供服务
  • 若采用非阻塞式等待，虽然在子进程为客户端提供服务期间服务端可以继续获取新连接，但此时服务端就需要将所有子进程的PID保存下来，并且需要不断花费时间检测子进程是否退出
  • 由此可见两种都有缺陷，所以我们可以考虑让服务端不等待子进程退出

常见的方式有两种：

  1. 捕捉SIGCHLD信号，将其处理动作设置为忽略。
  2. 让父进程创建子进程，子进程再创建孙子进程，子进程退出，让孙子进程为客户端提供服务，孙进程的回收工作由OS来承担

下面是创建孙进程的方案：

tcpServer.hpp

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include<sys/wait.h>
#include"err.hpp"
using namespace std;namespace ns_server
{static const uint16_t defaultport=8081;static int backlog=32;using func_t=function<string(const string&)>;   // 回调函数,一种处理逻辑class TcpServer{public:TcpServer(func_t func, uint16_t port=defaultport):func_(func),port_(port),quit_(true){}void InitServer(){// 1. 创建socket文件listensock_=socket(AF_INET,SOCK_STREAM,0);if(listensock_<0){cerr<<"create socket error"<<endl;exit(SOCKET_ERR);}// 2. bindstruct sockaddr_in local;memset(&local,0,sizeof(local));local.sin_port=htons(port_);local.sin_family=AF_INET;local.sin_addr.s_addr=INADDR_ANY;int n=bind(listensock_,(struct sockaddr*)&local,sizeof(local));if(n<0){cerr<<"bind socket error"<<endl;exit(BIND_ERR);}// 3. 监听int m=listen(listensock_,backlog);if(m<0){cerr<<"listen socket error"<<endl;exit(LISTEN_ERR);}}void Start(){// signal(SIGCHLD,SIG_IGN);  // ok, 最推荐// signal(SIGCHLD,handler);  // 回收子进程, 不太推荐quit_=false;while(!quit_){struct sockaddr_in client;socklen_t len=sizeof(client);// 4. 获取连接, acceptint sock=accept(listensock_,(struct sockaddr*)&client,&len);if (sock < 0)   // accept失败并不会终止进程, 只要获取下一个连接{cerr << "accept error" << endl;continue;}// 提取client信息   --- debugstring clientip=inet_ntoa(client.sin_addr); // 把4字节对应的IP转化成字符串风格uint16_t clientport=ntohs(client.sin_port);  // 网络序列转主机序列// 5. 获取新连接成功后, 开始进行业务处理cout<<"获取新连接成功: "<<sock<<" from "<<listensock_<<", "<< clientip << "-                 " <<clientport<<endl;// v2: 多进程版本// 子进程对外提供服务, 父进程只进行acceptpid_t id=fork();if(id<0){close(sock);continue;}else if(id==0) // child, 父进程的fd会被子进程继承吗? 会; 父子会用同一张文件描述符表吗?不会, 子进程会拷贝继承父进程的fd table{// 建议关闭掉不需要的fdclose(listensock_);if(fork()>0) exit(0);   // 就这一行代码// 子进程已经退了(则下面的wait立马返回, 回收子进程资源), 孙子进程在运行(无父进程, 变成孤儿进程, 被系统领养),提供服务// 孙子进程的回收工作由系统来承担service(sock,clientip,clientport);exit(0);}// 父进程, 一定要关闭不需要的fd(否则会导致父进程的文件描述符变少, 即父进程文件描述符资源的浪费[文件描述符泄露])close(sock);// 不等待子进程, 会导致子进程僵尸之后无法回收, 近而导致内存泄漏pid_t ret=waitpid(id,nullptr,0);    // 父进程默认是阻塞的, waitpid(id,nullptr,WNOHANG);不推荐if(ret==id)cout<< "wait child "<<id<< " success" <<endl;}}// 流式 - 利用read和writevoid service(int sock, const string&clientip,const uint16_t clientport){string who=clientip + "-" + to_string(clientport);char buffer[1024];while(true){ssize_t s=read(sock,buffer,sizeof(buffer)-1);if(s>0){buffer[s]=0;string res=func_(buffer);     // 进行回调cout<<who<< ">>> " <<res<<endl;// 把收到的消息返回(写给客户端)write(sock,res.c_str(),res.size());}else if(s==0){// 对方将连接关闭了close(sock);cout<< who <<" quit, me too"<<endl;break;}else{close(sock);cerr<<"read error: "<<strerror(errno)<<endl;break;}}}~TcpServer(){}private:uint16_t port_;int listensock_;bool quit_;      // 标志服务器是否运行字段func_t func_;};
}

tcpServer.cc

#include"tcpServer.hpp"
using namespace ns_server;// ./tcp_server port// 使用手册
static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" port\n"<<endl;
}string echo(const string&message)
{return message;
}int main(int argc,char*argv[])
{if(argc!=2){usage(argv[0]);exit(USAGE_ERR);}uint16_t port=atoi(argv[1]);unique_ptr<TcpServer> tsvr(new TcpServer(echo,port));tsvr->InitServer();tsvr->Start();return 0;
}

tcpClient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include"err.hpp"
using namespace std;static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" serverip serverport\n" <<endl;
}// ./tcp_client serverip serverport
int main(int argc,char*argv[])
{// 准备工作if(argc!=3){usage(argv[0]);exit(USAGE_ERR);}string serverip=argv[1];uint16_t serverport=atoi(argv[2]);// 1.创建套接字int sock=socket(AF_INET,SOCK_STREAM,0);if (sock < 0){cerr << "create socket error: " << strerror(errno) << endl;exit(SOCKET_ERR);}// (2) 客户端要不要bind呢? 要//     要不要自己bind呢? 不要, 因为client要让OS自动给用户进行bind// (3) 要不要listen?不要, 客户端连别人, 永远都是别人listen; 要不要accept?不要, 服务器来连接// 2. connect  客户端向服务器发起连接请求struct sockaddr_in server;memset(&server,0,sizeof(server));server.sin_port=htons(serverport);server.sin_family=AF_INET;// server.sin_addr.s_addr=INADDR_ANY;   绝对不是inet_aton(serverip.c_str(),&(server.sin_addr));    // 字符串风格ip转成点分十进制int cnt=5;while(connect(sock,(struct sockaddr*)&server,sizeof(server))!=0)   // 连接失败{sleep(1);cout<<"正在给你重连, 重连次数还有: "<<cnt--<<endl;if(cnt<=0)break;}if(cnt<=0){cerr<<"连接失败"<<endl;exit(CONNECT_ERR);}char buffer[1024];// 3. 连接成功while(true){string line;cout<<"Enter>> ";getline(cin,line);write(sock,line.c_str(),line.size());ssize_t s = read(sock, buffer, sizeof(buffer)-1);if (s > 0){buffer[s] = 0;cout<<"server echo >>>"<<buffer<<endl;}else if (s == 0){cerr << "server quit" << endl;break;}else{cerr << "read error: " << strerror(errno) << endl;break;}}close(sock);return 0;
}

运行结果:

在这里插入图片描述

(3) v3_多线程版本

频繁的创建进程会给OS带来巨大的负担，并且创建线程的成本比创建线程高得多。因此在实现多执行流的服务器时最好采用多线程进行实现。

主线程创建出新线程后，也是需要等待新线程退出的，否则也会造成类似于僵尸进程这样的问题。但对于线程来说，如果不想让主线程等待新线程退出，直接线程分离即可，当这个线程退出时系统会自动回收该线程所对应的资源。

各个线程共享是同一张文件描述符表，也就是说服务进程（主线程）调用accept函数获取到一个文件描述符后，其他创建的新线程是能够直接访问这个文件描述符的。

所以不能关闭不要的套接字文件描述符，该文件描述符的关闭操作应该又新线程来执行。因为是新线程为客户端提供服务的，只有当新线程为客户端提供的服务结束后才能将该文件描述符关闭。

tcpServer.hpp

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include<sys/wait.h>
#include<pthread.h>
#include"err.hpp"
using namespace std;namespace ns_server
{static const uint16_t defaultport=8081;static int backlog=32;using func_t=function<string(const string&)>;   // 回调函数,一种处理逻辑class TcpServer;class ThreadData{public:ThreadData(int fd, const string&ip,const uint16_t&port,TcpServer*ts):sock(fd),clientip(ip),clientport(port),current(ts){}public:int sock;string clientip;uint16_t clientport;TcpServer*current;};class TcpServer{public:TcpServer(func_t func, uint16_t port=defaultport):func_(func),port_(port),quit_(true){}void InitServer(){// 1. 创建socket文件listensock_=socket(AF_INET,SOCK_STREAM,0);if(listensock_<0){cerr<<"create socket error"<<endl;exit(SOCKET_ERR);}// 2. bindstruct sockaddr_in local;memset(&local,0,sizeof(local));local.sin_port=htons(port_);local.sin_family=AF_INET;local.sin_addr.s_addr=INADDR_ANY;int n=bind(listensock_,(struct sockaddr*)&local,sizeof(local));if(n<0){cerr<<"bind socket error"<<endl;exit(BIND_ERR);}// 3. 监听int m=listen(listensock_,backlog);if(m<0){cerr<<"listen socket error"<<endl;exit(LISTEN_ERR);}}void Start(){// signal(SIGCHLD,SIG_IGN);  // ok, 最推荐// signal(SIGCHLD,handler);  // 回收子进程, 不太推荐quit_=false;while(!quit_){struct sockaddr_in client;socklen_t len=sizeof(client);// 4. 获取连接, acceptint sock=accept(listensock_,(struct sockaddr*)&client,&len);if (sock < 0)   // accept失败并不会终止进程, 只要获取下一个连接{cerr << "accept error" << endl;continue;}// 提取client信息   --- debugstring clientip=inet_ntoa(client.sin_addr); // 把4字节对应的IP转化成字符串风格uint16_t clientport=ntohs(client.sin_port);  // 网络序列转主机序列// 5. 获取新连接成功后, 开始进行业务处理cout<<"获取新连接成功: "<<sock<<" from "<<listensock_<<", "<< clientip << "-                " <<clientport<<endl;// v3: 多线程版本 --- 原生多线程// 1. 要不要关闭不要的socket?  绝对不能,一个进程的文件描述符表共享, 关了影响其他线程// 2. 要不要回收线程?要;如何回收?会不会阻塞pthread_t tid;ThreadData*td=new ThreadData(sock,clientip,clientport,this);    // 要开出一块独立的空间pthread_create(&tid,nullptr,threadRoutine,td);}}static void*threadRoutine(void*args){pthread_detach(pthread_self());ThreadData*td=static_cast<ThreadData*>(args);td->current->service(td->sock,td->clientip,td->clientport);delete td;}// 流式 - 利用read和writevoid service(int sock, const string&clientip,const uint16_t clientport){string who=clientip + "-" + to_string(clientport);char buffer[1024];while(true){ssize_t s=read(sock,buffer,sizeof(buffer)-1);if(s>0){buffer[s]=0;string res=func_(buffer);     // 进行回调cout<<who<< ">>> " <<res<<endl;// 把收到的消息返回(写给客户端)write(sock,res.c_str(),res.size());}else if(s==0){// 对方将连接关闭了close(sock);cout<< who <<" quit, me too"<<endl;break;}else{close(sock);cerr<<"read error: "<<strerror(errno)<<endl;break;}}}~TcpServer(){}private:uint16_t port_;int listensock_;bool quit_;      // 标志服务器是否运行字段func_t func_;};
}

tcpServer.cc

#include"tcpServer.hpp"
using namespace ns_server;// ./tcp_server port// 使用手册
static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" port\n"<<endl;
}string echo(const string&message)
{return message;
}int main(int argc,char*argv[])
{if(argc!=2){usage(argv[0]);exit(USAGE_ERR);}uint16_t port=atoi(argv[1]);unique_ptr<TcpServer> tsvr(new TcpServer(echo,port));tsvr->InitServer();tsvr->Start();return 0;
}

tcpClient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include"err.hpp"
using namespace std;static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" serverip serverport\n" <<endl;
}// ./tcp_client serverip serverport
int main(int argc,char*argv[])
{// 准备工作if(argc!=3){usage(argv[0]);exit(USAGE_ERR);}string serverip=argv[1];uint16_t serverport=atoi(argv[2]);// 1.创建套接字int sock=socket(AF_INET,SOCK_STREAM,0);if (sock < 0){cerr << "create socket error: " << strerror(errno) << endl;exit(SOCKET_ERR);}// (2) 客户端要不要bind呢? 要//     要不要自己bind呢? 不要, 因为client要让OS自动给用户进行bind// (3) 要不要listen?不要, 客户端连别人, 永远都是别人listen; 要不要accept?不要, 服务器来连接// 2. connect  客户端向服务器发起连接请求struct sockaddr_in server;memset(&server,0,sizeof(server));server.sin_port=htons(serverport);server.sin_family=AF_INET;// server.sin_addr.s_addr=INADDR_ANY;   绝对不是inet_aton(serverip.c_str(),&(server.sin_addr));    // 字符串风格ip转成点分十进制int cnt=5;while(connect(sock,(struct sockaddr*)&server,sizeof(server))!=0)   // 连接失败{sleep(1);cout<<"正在给你重连, 重连次数还有: "<<cnt--<<endl;if(cnt<=0)break;}if(cnt<=0){cerr<<"连接失败"<<endl;exit(CONNECT_ERR);}char buffer[1024];// 3. 连接成功while(true){string line;cout<<"Enter>> ";getline(cin,line);write(sock,line.c_str(),line.size());ssize_t s = read(sock, buffer, sizeof(buffer)-1);if (s > 0){buffer[s] = 0;cout<<"server echo >>>"<<buffer<<endl;}else if (s == 0){cerr << "server quit" << endl;break;}else{cerr << "read error: " << strerror(errno) << endl;break;}}close(sock);return 0;
}

运行结果:

在这里插入图片描述

(4) v4_线程池版本

多线程版的问题：

  • 每当有新连接到来时，服务端的主线程都会为该客户端创建提供服务的新线程，当服务结束时就会将新线程销毁，这样做既麻烦又效率低下，每当有新连接到来才开始创建提供服务的新线程
  • 若有大量的客户端请求，此时服务端要为每一个客户端创建对应的服务线程。计算机中的线程越多，CPU的压力越大

线程池

  • 在服务端预先创建一批线程，当有客户端请求连接时就让这些线程为客户端提供服务，此时客户端一来就有线程为其提供服务，而不是当客户端来了才创建对应的服务线程(减少了频繁创建线程的开销)
  • 当某个线程为客户端提供完服务后，不要让该线程退出，而是让该线程继续为下一个客户端提供服务，如果当前没有客户端连接请求，则可以让该线程先进入休眠状态，当有客户端连接到来时再将该线程唤醒。
  • 服务端创建的这一批线程的数量不能太多，此时CPU的压力也就不会太大

task.hpp

#pragma once
#include<iostream>
#include<string>
#include<unistd.h>
#include<string.h>
#include<functional>
using namespace std;using cb_t=function<void(int sock, const string&,const uint16_t&)>;class Task
{
public:Task(){}Task(int sock, const string& ip,const uint16_t&port,cb_t cb):_sock(sock),_ip(ip),_port(port),_cb(cb){}void operator()(){_cb(_sock,_ip,_port);}~Task(){}private:int _sock;string _ip;uint16_t _port;cb_t _cb;
};

LockGuard.hpp

#include<iostream>
#include<pthread.h>
using namespace std;class Mutex   //自己不维护锁,由外部传入
{
public:Mutex(pthread_mutex_t* mutex):_pmutex(mutex){}void lock(){pthread_mutex_lock(_pmutex);}void unlock(){pthread_mutex_unlock(_pmutex);}~Mutex(){}private:pthread_mutex_t* _pmutex;   //锁的指针
};class LockGuard  //自己不维护锁,由外部传入
{
public:LockGuard(pthread_mutex_t* mutex):_mutex(mutex){_mutex.lock();}~LockGuard(){_mutex.unlock();}private:Mutex _mutex;   //锁的指针
};

thread.hpp

#include<iostream>
#include<string>
using namespace std;class Thread
{
public:typedef enum{NEW=0,RUNNING,EXITED}ThreadStatus;typedef void (*func_t)(void*);      //函数指针, 参数是void*Thread(int num, func_t func, void*args):_tid(0),_status(NEW),_func(func),_args(args){char name[128];snprintf(name,sizeof(name),"thread-%d",num);_name=name;}int status() {return _status;}string threadname() {return _name;}pthread_t thread_id(){if(_status==RUNNING)return _tid;elsereturn 0;}// runHelper是不是类的成员函数, 而类的成员函数, 具有默认参数this, 需要static// void*runHelper(Thread*this, void*args) , 而pthread_create要求传的参数必须是: void*的, 即参数不匹配// 但是static会有新的问题: static成员函数, 无法直接访问类属性和其他成员函数static void*runHelper(void*args){Thread*ts=(Thread*)args;   //就拿到了当前对象// _func(_args);(*ts)();}//仿函数void operator()(){_func(_args);}void run(){int n=pthread_create(&_tid,nullptr,runHelper,this);  //this: 是当前线程对象Threadif(n!=0) exit(-1);_status=RUNNING;}void join(){int n=pthread_join(_tid,nullptr);if(n!=0){cerr<<" main thread join thread "<< _name << " error "<<endl;}_status=EXITED;}~Thread(){}private:pthread_t _tid;string _name;func_t _func;  //线程未来要执行的回调void*_args;     //调用回调函数时的参数ThreadStatus _status;
};

threadPool_v4.hpp

#include<iostream>
#include<memory>
#include<vector>
#include<queue>
#include<unistd.h>
#include"thread.hpp"
#include"lockGuard.hpp"
using namespace std;const static int N=5;template<class T>
class threadPool
{
public:pthread_mutex_t* getlock(){return &_lock;}void threadWait(){pthread_cond_wait(&_cond,&_lock);}void threadWakeup(){pthread_cond_signal(&_cond);  // 唤醒在条件变量下等待的线程}bool isEmpty(){return _tasks.empty();}T popTask(){T t=_tasks.front();_tasks.pop();return t;}static void threadRoutine(void*args)      {threadPool<T>*tp=static_cast<threadPool<T>*>(args);while(true){// 1. 检测有没有任务 --- 本质是看队列是否为空// --- 本质就是在访问共享资源  --- 必定加锁// 2. 有: 处理// 3. 无: 等待// 细节: 必定加锁T t;{LockGuard lockguard(tp->getlock());while (tp->isEmpty()){// 等待, 在条件变量下等待tp->threadWait();}t = tp->popTask(); // 把任务从公共区域拿到私有区域}// for test// 处理任务应不应该在临界区中处理, 不应该, 这是线程自己私有的事情t();   }}static threadPool<T> * getinstance(){if (instance == nullptr)  // 为什么要这样? 提高效率, 减少加锁的次数{LockGuard lockguard(&instance_lock);if (instance == nullptr){cout<<"线程池单例形成"<<endl;instance = new threadPool<T>();instance->init();instance->start();}}return instance;}void init(){for(int i=0;i<_num;++i){_threads.push_back(Thread(i,threadRoutine,this));cout<<i<<" thread running"<<endl;}}void check(){for(auto&t:_threads){cout<<t.threadname()<<" running..."<<endl;}}void start(){for(auto&t:_threads){t.run();}}void pushTask(const T&t){LockGuard lockguard(&_lock);_tasks.push(t);threadWakeup();}~threadPool(){for(auto&t:_threads){t.join();}pthread_mutex_destroy(&_lock);pthread_cond_destroy(&_cond);}private:threadPool(int num=N):_num(num){pthread_mutex_init(&_lock,nullptr);pthread_cond_init(&_cond,nullptr);}threadPool(const threadPool<T>&tp)=delete;void operator=(const threadPool<T>&tp)=delete;private:vector<Thread> _threads;   int _num;                     queue<T> _tasks;               pthread_mutex_t _lock;pthread_cond_t  _cond;static threadPool<T>*instance;static pthread_mutex_t instance_lock;
};template<class T>
threadPool<T> * threadPool<T>::instance=nullptr;template<class T>
pthread_mutex_t  threadPool<T>::instance_lock=PTHREAD_MUTEX_INITIALIZER;

tcpServer.hpp

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include<sys/wait.h>
#include<pthread.h>
#include"err.hpp"
#include"threadPool_v4.hpp"
#include"task.hpp"
using namespace std;namespace ns_server
{static const uint16_t defaultport=8081;static int backlog=32;using func_t=function<string(const string&)>;   // 回调函数,一种处理逻辑class TcpServer;class ThreadData{public:ThreadData(int fd, const string&ip,const uint16_t&port,TcpServer*ts):sock(fd),clientip(ip),clientport(port),current(ts){}public:int sock;string clientip;uint16_t clientport;TcpServer*current;};class TcpServer{public:TcpServer(func_t func, uint16_t port=defaultport):func_(func),port_(port),quit_(true){}void InitServer(){// 1. 创建socket文件listensock_=socket(AF_INET,SOCK_STREAM,0);if(listensock_<0){cerr<<"create socket error"<<endl;exit(SOCKET_ERR);}// 2. bindstruct sockaddr_in local;memset(&local,0,sizeof(local));local.sin_port=htons(port_);local.sin_family=AF_INET;local.sin_addr.s_addr=INADDR_ANY;int n=bind(listensock_,(struct sockaddr*)&local,sizeof(local));if(n<0){cerr<<"bind socket error"<<endl;exit(BIND_ERR);}// 3. 监听int m=listen(listensock_,backlog);if(m<0){cerr<<"listen socket error"<<endl;exit(LISTEN_ERR);}}void Start(){quit_=false;while(!quit_){struct sockaddr_in client;socklen_t len=sizeof(client);// 4. 获取连接, acceptint sock=accept(listensock_,(struct sockaddr*)&client,&len);if (sock < 0)   // accept失败并不会终止进程, 只要获取下一个连接{cerr << "accept error" << endl;continue;}// 提取client信息   --- debugstring clientip=inet_ntoa(client.sin_addr); // 把4字节对应的IP转化成字符串风格uint16_t clientport=ntohs(client.sin_port);  // 网络序列转主机序列// 5. 获取新连接成功后, 开始进行业务处理cout<<"获取新连接成功: "<<sock<<" from "<<listensock_<<", "<< clientip << "-                 " <<clientport<<endl;// v4: 线程池版本 //  一旦用户来了，你才创建线程, 线程池吗// 使用线程池的时候, 一定是有限的线程个数, 一定要处理短任务Task t(sock,clientip,clientport, bind(&TcpServer::service,                                      this,placeholders::_1,placeholders::_2,placeholders::_3));threadPool<Task>::getinstance()->pushTask(t);}}static void*threadRoutine(void*args){pthread_detach(pthread_self());ThreadData*td=static_cast<ThreadData*>(args);td->current->service(td->sock,td->clientip,td->clientport);delete td;}// 流式 - 利用read和writevoid service(int sock, const string&clientip,const uint16_t clientport){string who=clientip + "-" + to_string(clientport);char buffer[1024];ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if (s > 0){buffer[s] = 0;string res = func_(buffer); // 进行回调cout << who << ">>> " << res << endl;// 把收到的消息返回(写给客户端)write(sock, res.c_str(), res.size());}else if (s == 0){cout << who << " quit, me too" << endl;}else{close(sock);cerr << "read error: " << strerror(errno) << endl;}close(sock);}~TcpServer(){}private:uint16_t port_;int listensock_;bool quit_;      // 标志服务器是否运行字段func_t func_;};
}

tcpServer.cc

#include"tcpServer.hpp"
using namespace ns_server;// ./tcp_server port// 使用手册
static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" port\n"<<endl;
}string echo(const string&message)
{return message;
}int main(int argc,char*argv[])
{if(argc!=2){usage(argv[0]);exit(USAGE_ERR);}uint16_t port=atoi(argv[1]);unique_ptr<TcpServer> tsvr(new TcpServer(echo,port));tsvr->InitServer();tsvr->Start();return 0;
}

tcpClient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<memory>
#include<functional>
#include"err.hpp"
using namespace std;static void usage(string proc)
{cout<<"usage:\n\t"<<proc<<" serverip serverport\n" <<endl;
}// ./tcp_client serverip serverport
int main(int argc,char*argv[])
{// 准备工作if(argc!=3){usage(argv[0]);exit(USAGE_ERR);}string serverip=argv[1];uint16_t serverport=atoi(argv[2]);// 1.创建套接字int sock=socket(AF_INET,SOCK_STREAM,0);if (sock < 0){cerr << "create socket error: " << strerror(errno) << endl;exit(SOCKET_ERR);}// (2) 客户端要不要bind呢? 要//     要不要自己bind呢? 不要, 因为client要让OS自动给用户进行bind// (3) 要不要listen?不要, 客户端连别人, 永远都是别人listen; 要不要accept?不要, 服务器来连接// 2. connect  客户端向服务器发起连接请求struct sockaddr_in server;memset(&server,0,sizeof(server));server.sin_port=htons(serverport);server.sin_family=AF_INET;// server.sin_addr.s_addr=INADDR_ANY;   绝对不是inet_aton(serverip.c_str(),&(server.sin_addr));    // 字符串风格ip转成点分十进制int cnt=5;while(connect(sock,(struct sockaddr*)&server,sizeof(server))!=0)   // 连接失败{sleep(1);cout<<"正在给你重连, 重连次数还有: "<<cnt--<<endl;if(cnt<=0)break;}if(cnt<=0){cerr<<"连接失败"<<endl;exit(CONNECT_ERR);}char buffer[1024];// 3. 连接成功while(true){string line;cout<<"Enter>> ";getline(cin,line);write(sock,line.c_str(),line.size());ssize_t s = read(sock, buffer, sizeof(buffer)-1);if (s > 0){buffer[s] = 0;cout<<"server echo >>>"<<buffer<<endl;}else if (s == 0){cerr << "server quit" << endl;break;}else{cerr << "read error: " << strerror(errno) << endl;break;}}close(sock);return 0;
}

运行结果:

ip serverport\n" <<endl;
}

// ./tcp_client serverip serverport
int main(int argc,char*argv[])
{
// 准备工作
if(argc!=3)
{
usage(argv[0]);
exit(USAGE_ERR);
}

string serverip=argv[1];
uint16_t serverport=atoi(argv[2]);// 1.创建套接字
int sock=socket(AF_INET,SOCK_STREAM,0);
if (sock < 0)
{cerr << "create socket error: " << strerror(errno) << endl;exit(SOCKET_ERR);
}// (2) 客户端要不要bind呢? 要
//     要不要自己bind呢? 不要, 因为client要让OS自动给用户进行bind
// (3) 要不要listen?不要, 客户端连别人, 永远都是别人listen; 要不要accept?不要, 服务器来连接// 2. connect  客户端向服务器发起连接请求
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_port=htons(serverport);
server.sin_family=AF_INET;
// server.sin_addr.s_addr=INADDR_ANY;   绝对不是
inet_aton(serverip.c_str(),&(server.sin_addr));    // 字符串风格ip转成点分十进制int cnt=5;while(connect(sock,(struct sockaddr*)&server,sizeof(server))!=0)   // 连接失败
{sleep(1);cout<<"正在给你重连, 重连次数还有: "<<cnt--<<endl;if(cnt<=0)break;
}
if(cnt<=0)
{cerr<<"连接失败"<<endl;exit(CONNECT_ERR);
}char buffer[1024];
// 3. 连接成功
while(true)
{string line;cout<<"Enter>> ";getline(cin,line);write(sock,line.c_str(),line.size());ssize_t s = read(sock, buffer, sizeof(buffer)-1);if (s > 0){buffer[s] = 0;cout<<"server echo >>>"<<buffer<<endl;}else if (s == 0){cerr << "server quit" << endl;break;}else{cerr << "read error: " << strerror(errno) << endl;break;}
}close(sock);
return 0;

}


运行结果:![在这里插入图片描述](https://img-blog.csdnimg.cn/eadac05d3a6c43dbb8c5e44f9ccebca6.png)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/110182.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

如何使用CSS实现一个自适应等高布局？

如何使用CSS实现一个自适应等高布局？

聚沙成塔每天进步一点点 ⭐ 专栏简介⭐ 使用 Flexbox 布局⭐ 使用 Grid 布局⭐ 写在最后 ⭐ 专栏简介 前端入门之旅&#xff1a;探索Web开发的奇妙世界 记得点击上方或者右侧链接订阅本专栏哦 几何带你启航前端之旅 欢迎来到前端入门之旅&#xff01;这个专栏是为那些对Web开发…
阅读更多...
爬虫逆向实战（二十三）--某准网数据

爬虫逆向实战（二十三）--某准网数据

一、数据接口分析 主页地址&#xff1a;某准网 1、抓包 通过抓包可以发现数据接口是api_to/search/company_v2.json 2、判断是否有加密参数 请求参数是否加密&#xff1f; 通过查看“载荷”模块可以发现b参数和kiv参数是加密参数 请求头是否加密&#xff1f; 无响应是否加…
阅读更多...
在云原生时代，构建高效的大数据存储与分析平台

在云原生时代，构建高效的大数据存储与分析平台

文章目录 1. **选择适当的数据存储技术&#xff1a;**2. **采用分布式架构&#xff1a;**3. **数据分区和索引&#xff1a;**4. **采用列式存储&#xff1a;**5. **数据压缩和编码&#xff1a;**6. **使用缓存技术&#xff1a;**7. **数据分片和复制&#xff1a;**8. **自动化运…
阅读更多...
GNS3 在 Linux 上的安装指南

GNS3 在 Linux 上的安装指南

文章目录 GNS3 在 Linux 上的安装指南1. 基于 Ubuntu 的发行版安装 GNS32. 基于 Debian 的安装3. 基于 ArchLinux 的安装4. 从 Pypi 安装 GNS35. 启动 GNS3 服务端GNS3 在 Linux 上的安装指南 大家好，今天我们来聊聊如何在 Linux 上安装 GNS3。GNS3 是一个非常受欢迎的网络模…
阅读更多...
软件工程(二十) 系统运行与软件维护

软件工程(二十) 系统运行与软件维护

1、系统转换计划 1.1、遗留系统的演化策略 时至今日，你想去开发一个系统，想完全不涉及到已有的系统，基本是不可能的事情。但是对于已有系统我们有一个策略。 比如我们是淘汰掉已有系统，还是继承已有系统，或者集成已有系统，或者改造遗留的系统呢，都是不同的策略。 技术…
阅读更多...
macOS上开源免费的新闻阅读器SABnzbd

macOS上开源免费的新闻阅读器SABnzbd

SABnzbd Mac版是一款运行在Mac平台上的开源新闻阅读器&#xff0c;这款阅读器界面简约、功效简单强大&#xff0c;使用SABnzbd时可以帮助使用Python语言编写&#xff0c;让用户使用usenet新闻组更便利&#xff0c;是你阅读新闻的好帮手&#xff01; SABnzbd具有以下主要特点&a…
阅读更多...
Sentinel流量控制与熔断降级

Sentinel流量控制与熔断降级

&#x1f4dd; 学技术、更要掌握学习的方法&#xff0c;一起学习&#xff0c;让进步发生 &#x1f469;&#x1f3fb; 作者&#xff1a;一只IT攻城狮 &#xff0c;关注我&#xff0c;不迷路 。 &#x1f490;学习建议&#xff1a;1、养成习惯&#xff0c;学习java的任何一个技术…
阅读更多...
git 把项目托管到 码云出现的错误集合

git 把项目托管到 码云出现的错误集合

分享一下我git项目时碰见的错误 1、error: could not lock config file D:/orcad/Cadence/SPB_Data/.gitconfig: No suchfile or directory 在下载git后设置用户名、邮箱时会出现的错误 需要去修改环境变量&#xff0c;这个之前写好了&#xff0c;可以跳转看看 Git配置error:…
阅读更多...
三维模型OBJ格式轻量化压缩并行计算处理方法浅析

三维模型OBJ格式轻量化压缩并行计算处理方法浅析

三维模型OBJ格式轻量化压缩并行计算处理方法浅析 三维模型的轻量化是指通过一系列技术和算法来减小三维模型的文件大小&#xff0c;以提高模型在计算机中的加载、渲染和传输效率。并行计算是利用多个计算单元同时执行任务&#xff0c;以加速计算过程的一种技术。在三维模型的O…
阅读更多...
900ES1-0100 honeywell 可减少视觉引导应用的整体开发时间

900ES1-0100 honeywell 可减少视觉引导应用的整体开发时间

900ES1-0100 honeywell 可减少视觉引导应用的整体开发时间 CV2视觉系统配有高柔性电缆(以太网或USB)。通过将高柔性电缆作为所有CV2视觉系统的标准配置&#xff0c;Epson CV2摄像机可以安装在机器人臂(移动)或固定装置(固定)上。基于向导的校准使机器人到视觉系统的校准变得轻…
阅读更多...
关于单例模式

关于单例模式

单例模式的目的&#xff1a; 单例模式的目的和其他的设计模式的目的都是一样的&#xff0c;都是为了降低对象之间的耦合性&#xff0c;增加代码的可复用性&#xff0c;可维护性和可扩展性。 单例模式&#xff1a; 单例模式是一种常用的设计模式&#xff0c;用简单的言语说&am…
阅读更多...
CSS学习笔记01

CSS学习笔记01

CSS笔记01 什么是CSS CSS&#xff08;Cascading Style Sheets &#xff09;&#xff1a;层叠样式表&#xff0c;也可以叫做级联样式表&#xff0c;是一种用来表现 HTML 或 XML 等文件样式的计算机语言。字体&#xff0c;颜色&#xff0c;边距&#xff0c;高度&#xff0c;宽度…
阅读更多...
代码随想录算法训练营之JAVA｜第四十二天|70. 爬楼梯

代码随想录算法训练营之JAVA｜第四十二天|70. 爬楼梯

今天是第 天刷leetcode&#xff0c;立个flag&#xff0c;打卡60天&#xff0c;如果做不到&#xff0c;完成一件评论区点赞最高的挑战。 算法挑战链接 70. 爬楼梯https://leetcode.cn/problems/climbing-stairs/ 第一想法 这是一个动态规划的入门题目&#xff0c;在看完完全背…
阅读更多...
液体神经网络LLN：通过动态信息流彻底改变人工智能

液体神经网络LLN：通过动态信息流彻底改变人工智能

巴乌米克泰吉 一、说明 在在人工智能领域&#xff0c;神经网络已被证明是解决复杂问题的非常强大的工具。多年来&#xff0c;研究人员不断寻求创新方法来提高其性能并扩展其能力。其中一种方法是液体神经网络&#xff08;LNN&#xff09;的概念&#xff0c;这是一个利用动态计算…
阅读更多...
【计算机网络】OSI 七层网络参考模型

【计算机网络】OSI 七层网络参考模型

OSI&#xff08;Open Systems Interconnection&#xff09;七层网络参考模型是一种用于描述计算机网络通信的框架&#xff0c;将网络通信划分为七个不同的层次&#xff0c;每个层次负责不同的功能。 以下为 OSI 七层网络参考模型的简单表格&#xff1a; --------------------…
阅读更多...
设计模式—原型模式(Prototype)

设计模式—原型模式(Prototype)

目录 一、什么是原型模式&#xff1f; 二、原型模式具有什么优缺点吗&#xff1f; 三、有什么缺点&#xff1f; 四、什么时候用原型模式&#xff1f; 五、代码展示 ①、简历代码初步实现 ②、原型模式 ③、简历的原型实现 ④、深复制 ⑤、浅复制 一、什么是原型模式&…
阅读更多...
Leetcode刷题笔记--Hot31-40

Leetcode刷题笔记--Hot31-40

1--颜色分类&#xff08;75&#xff09; 主要思路&#xff1a; 快排 #include <iostream> #include <vector>class Solution { public:void sortColors(std::vector<int>& nums) {quicksort(nums, 0, nums.size()-1);}void quicksort(std::vector<int…
阅读更多...
Apache Celeborn 让 Spark 和 Flink 更快更稳更弹性

Apache Celeborn 让 Spark 和 Flink 更快更稳更弹性

摘要&#xff1a;本文整理自阿里云/数据湖 Spark 引擎负责人周克勇&#xff08;一锤&#xff09;在 Streaming Lakehouse Meetup 的分享。内容主要分为五个部分&#xff1a; Apache Celeborn 的背景Apache Celeborn——快Apache Celeborn——稳Apache Celeborn——弹Evaluation…
阅读更多...
IntelliJ 中如何配置 Tomcat 调试

IntelliJ 中如何配置 Tomcat 调试

Tomcat 在 IntelliJ 中的配置要求首先你要下载 Tomcat。 设置服务器 在 IntelliJ 下面先选择 Run&#xff0c;然后选择配置运行配置。 在弹出的界面中&#xff0c;有一个编辑配置的选项。 然后在弹出的页面中选择添加。 选择 Tomcat 在弹出的添加页面中选择添加 Tomcat&…
阅读更多...
华为数通方向HCIP-DataCom H12-821题库(单选题：141-160）

华为数通方向HCIP-DataCom H12-821题库(单选题：141-160）

第141题 Router-LSA 能够描述不同的链路类型&#xff0c;不属于Router LSA 链路类型的是以下哪一项? A、Link Type 可以用来描述到末梢网络的连接&#xff0c;即 SubNet B、Link Type 可以用来描述到中转网络的连接&#xff0c;即 TranNet C、Link Type 可以用来描述到另一…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023