网络——套接字编程TCP

目录

服务端

创建套接字（socket）

服务端绑定（bind）

服务端监听（listen）

服务器接收（accept）

服务端处理（read & write）

客户端

创建套接字（socket）

客户端连接（connect）

客户端处理（send & recv）​​​​​​​

多进程代码测试

捕获忽略SIGCHLD信号

子进程创建子进程

多线程代码测试    

线程池代码测试

服务端

创建套接字（socket）

        我们继续将TCP服务器封装成一个类，TCP创建套接字只有第二个参数不同，所需要的服务类型是SOCK_STREAM，这就是一个可靠的、需要链接的、全双工的、面向字节流的协议。

class TcpServer
{
public:TcpServer(uint16_t port, std::string ip = ""):_port(port),_ip(ip),_sock(-1){}void initServer(){// 创建socket_sock = socket(AF_INET, SOCK_STREAM, 0);if (_sock < 0){logMessage(FATAL, "%d:%s", errno, strerror(errno));exit(2);}logMessage(NORMAL, "sock: %d", _sock);}~TcpServer(){if (_sock > 0)close(_sock);}
private:uint16_t _port;std::string _ip;int _sock;
};

服务端绑定（bind）

        绑定的操作和UDP是差不多的，想要详细了解可以翻看上一篇。

    // 创建套接字// ...    // bindstruct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(_port);local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0){logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));exit(3);}

服务端监听（listen）

        至此，创建套接字和绑定与UDP没有太大的差别，而TCP是面向连接的，客户端发送数据要先与TCP建立连接，然后才能通信。

        所以TCP要注意，随时都有可能从客户端发来连接请求，此时就需要将TCP服务器创建的套接字设置为监听状态，用到的函数就是listen。

参数：

  • sockfd：需要设置为监听状态的套接字文件描述符
  • backlog：全连接队列的最大长度，具体是什么后面再说，一般设置为5、10或20就可以

返回值：监听成功返回0，失败返回-1，错误码被设置。

        至此，我的服务器初始化任务已经完成了。

const static int g_backlog = 20;void initServer()
{// 创建socket_sock = socket(AF_INET, SOCK_STREAM, 0);if (_sock < 0){logMessage(FATAL, "%d:%s", errno, strerror(errno));exit(2);}logMessage(NORMAL, "sock: %d", _sock);// bindstruct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(_port);local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0){logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));exit(3);}logMessage(NORMAL, "bind success ...");// tcp面向连接的，通信前要先建立连接，设置为监听状态，listenif (listen(_sock, g_backlog) < 0){logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));exit(4);}logMessage(NORMAL, "listen success ...");logMessage(NORMAL, "init server success");
}

服务器接收（accept）

        TCP服务器在与客户端进行通信之前，服务器需要先获取到客户端的连接请求，获取的函数就是accept。

参数：

  • sockfd：从该套接字中获取连接
  • addr：输出型参数，获取对端的网络属性信息
  • addrlen：输入输出型参数，返回实际读到的addr结构体的长度、

返回值：获取连接成功的对端套接字的文件描述符，失败返回-1，错误吗被设置。

accept返回值 vs sockfd：

  • sockfd是我们绑定的监听套接字，它只负责帮我们把获取的连接拿过来。
  • 而真正执行IO的就是accept返回的对端的套接字。

所以我们上述的_sock也叫做监听套接字listensock（_sock->listensock）。

void start()
{while (true){// 获取连接acceptstruct sockaddr_in src; // 客户端addrsocklen_t len = sizeof(src);int servicesock = accept(listensock, (struct sockaddr *)&src, &len);if (servicesock < 0){logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));// 接收失败也不影响，继续接收continue;}// 获取连接成功uint16_t client_port = ntohs(src.sin_port);std::string client_ip = inet_ntoa(src.sin_addr);logMessage(NORMAL, "link success, servicesock: %d | %s : %d|\n",servicesock, client_ip.c_str(), client_port);// 处理任务close(servicesock);}
}

服务端处理（read & write）

static void service(int sock, const std::string& clientip, const uint16_t& clientport)
{// echochar buffer[1024];while (true){// read和write可以直接使用// 读取数据ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if (s > 0){buffer[s] = 0; // 将发过来的消息当做字符串std::cout << clientip << " : " << clientport << "# " << buffer << std::endl;}else if (s == 0){// 代表对端关闭连接logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);break; // 跳出循环结束通信}else{logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));break;}// 写回数据write(sock, buffer, sizeof(buffer));}
}// 获取连接成功
// ...service(servicesock, client_ip, client_port);close(servicesock);

        直接使用read和write就可以进行IO了，但是就有一个问题，当一个连接被接收到了，这个函数就是一个死循环，对端不退出会一直执行，那么如果此时再来一个连接那就会被阻塞。

        那我们就可以使用多进程，子进程负责处理接收的文件描述符，父进程负责接收描述符。

void start()
{signal(SIGCHLD, SIG_IGN); // 子进程退出向父进程发送SIGCHLD，直接忽略这个信号，子进程退出就自动释放僵尸状态while (true){// 获取连接accept// ...// 获取连接成功// ...pid_t id = fork();assert(id != -1);if (id == 0){// 子进程// 子进程也会继承父进程的文件与文件fd// 子进程提供服务，他不用管监听的事，所以要关闭close(listensock);service(servicesock, client_ip, client_port);exit(0);}// 父进程// 父进程只需要接收sock，所以要关闭服务sockclose(servicesock);}
}

客户端

创建套接字（socket）

        初始化客户端，而客户端唯一要做的就是创建套接字，它不需要bind，也不需要listen，因为没有人会去连接客户端，那就更不需要accept接收了，它只需要知道服务端的IP和PORT就可以了。

// 1.创建套接字
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{std::cerr << "socket error" << std::endl;exit(2);
}

客户端连接（connect）

        向服务端发起连接请求，使用的函数就是connect。

参数：

  • sockfd：通过该套接字发起连接请求
  • addr：服务端网络属性信息
  • addrlen：传入的addr结构体的长度

返回值：连接成功返回0，失败返回-1，错误码被设置。

        客户端不需要bind，当客户端向服务端发起连接请求，操作系统会自动给客户端分配端口号。

// 不需要显示绑定bind，OS自动选择port
// 2.向服务端发起建立连接的请求connect
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
server.sin_addr.s_addr = inet_addr(serverip.c_str());if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
{std::cerr << "connect error" << std::endl;exit(3);
}

客户端处理（send & recv）

        send和recv是TCP用来通信的接口，但是read和write也可以使用。

作用：发送数据到对端

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

参数：

  • sockfd：向创建的套接字写入
  • buf：要把哪个缓冲区中的数据写入
  • len：缓冲区的长度
  • flags：一般默认为0

返回值：成功返回发送的数据个数，失败返回-1，错误码被设置。

 

作用：接收对端的数据

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

参数：

  • sockfd：从哪个套接字中接收数据
  • buf：将接收的数据放到的缓冲区
  • len：缓冲区的长度
  • flags：一般设置为0

返回值：成功返回接收的个数，失败返回-1，错误码被设置。

while (true)
{std::string line;std::cout << "请输入: ";std::getline(std::cin, line);send(sock, line.c_str(), line.size(), 0);char buffer[1024];ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);if (s > 0){buffer[s] = 0;std::cout << "server echo: " << buffer << std::endl;}else if (s == 0){// 对端关闭break;}else{break;}
}

多进程代码测试

捕获忽略SIGCHLD信号

// tcp_server.hpp#pragma once
#include <iostream>
#include <string>#include <cerrno>
#include <cstdio>
#include <cstring>
#include <cassert>#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>#include "log.hpp"static void service(int sock, const std::string& clientip, const uint16_t& clientport)
{// echochar buffer[1024];while (true){// read和write可以直接使用// 读取数据ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if (s > 0){buffer[s] = 0; // 将发过来的消息当做字符串std::cout << clientip << " : " << clientport << "# " << buffer << std::endl;}else if (s == 0){// 代表对端关闭连接logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);break; // 跳出循环结束通信}else{logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));break;}// 写回数据write(sock, buffer, strlen(buffer));}
}class TcpServer
{const static int g_backlog = 20;public:TcpServer(uint16_t port, std::string ip = ""): _port(port), _ip(ip), listensock(-1){}void initServer(){// 创建socketlistensock = socket(AF_INET, SOCK_STREAM, 0);if (listensock < 0){logMessage(FATAL, "%d:%s", errno, strerror(errno));exit(2);}logMessage(NORMAL, "sock: %d", listensock);// bindstruct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(_port);local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());if (bind(listensock, (struct sockaddr *)&local, sizeof(local)) < 0){logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));exit(3);}logMessage(NORMAL, "bind success ...");// tcp面向连接的，通信前要先建立连接，设置为监听状态，listenif (listen(listensock, g_backlog) < 0){logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));exit(4);}logMessage(NORMAL, "listen success ...");logMessage(NORMAL, "init server success");}void start(){signal(SIGCHLD, SIG_IGN); // 子进程退出向父进程发送SIGCHLD，直接忽略这个信号，子进程退出就自动释放僵尸状态while (true){// 获取连接acceptstruct sockaddr_in src; // 客户端addrsocklen_t len = sizeof(src);int servicesock = accept(listensock, (struct sockaddr *)&src, &len);if (servicesock < 0){logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));// 接收失败也不影响，继续接收continue;}// 获取连接成功uint16_t client_port = ntohs(src.sin_port);std::string client_ip = inet_ntoa(src.sin_addr);logMessage(NORMAL, "link success, servicesock: %d | %s : %d|\n", servicesock, client_ip.c_str(), client_port);// v1 -- 单进程循环版// service(servicesock, client_ip, client_port);// v2 -- 多进程版pid_t id = fork();assert(id != -1);if (id == 0){// 子进程// 子进程也会继承父进程的文件与文件fd// 子进程提供服务，他不用管监听的事，所以要关闭// 这是不是很像匿名管道呢close(listensock);service(servicesock, client_ip, client_port);exit(0);}// 父进程// 父进程只需要接收sock，所以要关闭服务sockclose(servicesock);}}~TcpServer(){if (listensock > 0)close(listensock);}private:uint16_t _port;std::string _ip;int listensock;
};
// tcp_server.cc#include "tcp_server.hpp"
#include <memory>void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}// ./tcp_server port
int main(int argc, char* argv[])
{if (argc != 2){usage(argv[0]);exit(1);}uint16_t port = atoi(argv[1]);std::unique_ptr<TcpServer> svr(new TcpServer(port));svr->initServer();svr->start();return 0;
}
// tcp_client.cc#include <iostream>
#include <unistd.h>
#include <string>#include <cstring>#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " ip port\n" << std::endl;
}int main(int argc, char* argv[])
{if (argc != 3){usage(argv[0]);exit(1);}  std::string serverip = argv[1];uint16_t serverport = atoi(argv[2]);// 1.创建套接字int sock = socket(AF_INET, SOCK_STREAM, 0);if (sock < 0){std::cerr << "socket error" << std::endl;exit(2);}// 不需要显示绑定bind，OS自动选择port// 2.向服务端发起建立连接的请求connectstruct sockaddr_in server;memset(&server, 0, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);server.sin_addr.s_addr = inet_addr(serverip.c_str());if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0){std::cerr << "connect error" << std::endl;exit(3);}// 连接成功std::cout << "connect success" << std::endl;while (true){std::string line;std::cout << "请输入: ";std::getline(std::cin, line);send(sock, line.c_str(), line.size(), 0);char buffer[1024];ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);if (s > 0){buffer[s] = 0;std::cout << "server echo: " << buffer << std::endl;}else if (s == 0){// 对端关闭break;}else{break;}}close(sock);return 0;
}

子进程创建子进程

        其实多进程还有一种写法，我们再来看看这种写法是怎么实现的，这种写法没有用子进程退出向父进程发送SIGCHLD信号的特性。

void start()
{while (true){// 获取连接accept// ...// 获取连接成功// ...pid_t id = fork();assert(id != -1);if (id == 0){// 子进程close(listensock);if (fork() > 0) exit(0); // 子进程fork创建孙子进程，子进程exit退出了// 孙子进程就变成了孤儿进程，孤儿进程会被系统领养，执行完后由操作系统释放service(servicesock, client_ip, client_port);exit(0);}// 父进程close(servicesock);waitpid(id, nullptr, 0); //阻塞式等待子进程退出}
}

多线程代码测试    

        创建进程的成本是很高的，创建进程时需要创建该进程对应task_struct、进程地址空间（mm_struct）等数据结构。而创建线程的成本就会会小得多，线程本质是在进程地址空间内运行，创建出来的线程会共享该进程的大部分资源，因此在实现多执行流的服务器时最好采用多线程进行实现。

class ThreadData
{
public:int sock;uint16_t port;std::string ip;
};class TcpServer
{static void *threadRoutine(void *args){pthread_detach(pthread_self()); // 线程分离，就不用join了ThreadData *td = (ThreadData *)args;service(td->sock, td->ip, td->port);delete td;return nullptr;}private:void start(){while (true){// 获取连接accept// ...// 获取连接成功// ...ThreadData *td = new ThreadData();td->sock = servicesock;td->ip = client_ip;td->port = client_port;pthread_t tid;// 多线程就不用关闭listensock文件描述符了，线程共享这些文件描述符pthread_create(&tid, nullptr, threadRoutine, (void *)td);close(servicesock);}}
};

再查看一下线程信息。

线程池代码测试

        当有新连接到来时，服务端的主线程都会重新为该客户端创建新线程，当服务结束后，将该线程销毁，在短时间内创建与销毁线程，这样做不仅麻烦，而且效率低，创建线程和销毁线程也是有成本的。
        所以为了解决这样的问题我们就可以引入线程池，客户端有发来任务，线程就为他服务，服务完后可以让线程休眠，再有任务来时再将线程唤醒。

        创建的线程也不能太多，要不然CPU的压力也会过大。如果这一批线程都在服务客户，再来一个客户端的连接就不能创建线程，应该让这个新来的连接请求在连接队列中排队，有空闲线程后再获取请求的连接为它提供服务。

        当有新的任务到来的时候，就Push到线程池中的任务队列中，多线程就不断检测任务队列中是否有任务，通过封装的任务类，调用仿函数执行相应的操作。

        这次我们想要实现一个网络词典的功能。

class TcpServer
{
public:TcpServer(uint16_t port, std::string ip = ""): _port(port), _ip(ip), listensock(-1), _threadpool_ptr(ThreadPool<Task>::getThreadPool()) // 获取线程池{}void start(){_threadpool_ptr->run();while (true){// 获取连接accept// ...// 获取连接成功// ...Task t(servicesock, client_ip, client_port, dictOnline);_threadpool_ptr->pushTask(t);}}
private:// ...std::unique_ptr<ThreadPool<Task>> _threadpool_ptr; // 线程池指针
};

        添加成员变量_threadpool_ptr，用智能指针维护，在构造函数的初始化列表中调用getThreadPool获取线程池，因为线程池用了单例模式。当TCP服务端初始化完成后，调用start函数，首先就要启动线程池，当accept接受到对端的sock文件描述符后就可以制作任务，并push到任务队列中。

// Task.hpptypedef std::function<void (int, const std::string&, const uint16_t&, const std::string&)> func_t;class Task
{
public:Task(){}Task(int sock, const std::string& ip, const uint16_t port, func_t func):_sock(sock),_ip(ip),_port(port),_func(func){}void operator()(const std::string& name){_func(_sock, _ip, _port, name);}    
public:int _sock;std::string _ip;uint16_t _port;func_t _func;
};

         我们想要实现一个从客户端接收一个英文单词，在单词的map中找，找到了就返回，没有找到就告知客户端词库中没有这个单词。

        这次我们采用短连接的方式，这个dictOnline函数就是修改了service函数，service函数使用的是死循环，一个线程对应一个客户端，如果这个客户端已经连接上了，它一直死循环不退出地做某件事，那么服务器接收的连接数就被限制了，所以来一个连接就服务一个，服务完之后，双方都断开连接。

static void dictOnline(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{// 网络词典static unordered_map<std::string, std::string> dict = {{"apple", "苹果"},{"banana", "香蕉"},{"process", "进程"},{"thread", "线程"}}; // 简易字典char buffer[1024];// read和write可以直接使用// 读取数据ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if (s > 0){buffer[s] = 0; // 将发过来的消息当做字符串std::cout << thread_name << " | " << clientip << " : " << clientport << "# " << buffer << std::endl;std::string message;auto iter = dict.find(buffer);if (iter == dict.end())message = "词库中无此单词";elsemessage = iter->second;// 写回数据write(sock, message.c_str(), message.size());}else if (s == 0){// 代表对端关闭连接logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);}else{logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));}close(sock);
}

        所以采用短连接，客户端可以死循环，每次执行完后就要关闭套接字，再一次连接的时候就要创建套接字。

void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " ip port\n"<< std::endl;
}int main(int argc, char *argv[])
{if (argc != 3){usage(argv[0]);exit(1);}std::string serverip = argv[1];uint16_t serverport = atoi(argv[2]);int sock = 0;std::string line;while (true){// 1.创建套接字sock = socket(AF_INET, SOCK_STREAM, 0);if (sock < 0){std::cerr << "socket error" << std::endl;exit(2);}// 不需要显示绑定bind，OS自动选择port// 2.向服务端发起建立连接的请求connectstruct sockaddr_in server;memset(&server, 0, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);server.sin_addr.s_addr = inet_addr(serverip.c_str());if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0){std::cerr << "connect error" << std::endl;exit(3);}// 连接成功std::cout << "connect success" << std::endl;std::cout << "请输入英文: ";std::getline(std::cin, line);if (line == "quit")break;ssize_t s = send(sock, line.c_str(), line.size(), 0);if (s > 0){char buffer[1024];s = recv(sock, buffer, sizeof(buffer) - 1, 0);if (s > 0){buffer[s] = 0;std::cout << "中文: " << buffer << std::endl;}}close(sock);}return 0;
}

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

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

相关文章

CVE-2022-33891 Apache Spark shell 命令注入漏洞分析

CVE-2022-33891 Apache Spark shell 命令注入漏洞分析

漏洞简介 Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架 Spark&#xff0c;拥有Hadoop MapReduce所具有的优点&#xff1b;但不同于MapReduce的…
阅读更多...
鸿蒙OS开发实例：【demo选择列表限定数量】

鸿蒙OS开发实例：【demo选择列表限定数量】

效果图&#xff1a; 示例代码 // 使用 DevEco Studio 3.1.1 Release 及以上版本&#xff0c;API 版本为 api 9 及以上。 // 主要功能及注意事项&#xff1a; // 该组件展示了一个乘客选择列表。列表中的每个项目包含一个复选框和对应的乘客姓名&#xff0c; // 用户点击任意一…
阅读更多...
MATLAB 自定义生成圆柱点云（49）

MATLAB 自定义生成圆柱点云（49）

MATLAB 自定义生成圆柱点云（49） 一、算法介绍二、具体实现1.代码2.效果一、算法介绍 按照一些提前指定的圆柱参数，自定义生成圆柱点云，可添加噪声，用于后续的实验测试 二、具体实现 1.代码 代码如下（示例）： % 指定圆柱的参数 radius = 5; % 圆柱半径 height = 20…
阅读更多...
【Spring源码】Bean采用什么数据结构进行存储

【Spring源码】Bean采用什么数据结构进行存储

一、前瞻 经过上篇源码阅读博客的实践&#xff0c;发现按模块阅读也能获得不少收获&#xff0c;而且能更加系统地阅读源码。 今天的阅读方式还是按模块阅读的方式&#xff0c;以下是Spring各个模块的组成。 那今天就挑Beans这个模块来阅读&#xff0c;先思考下本次阅读的阅读…
阅读更多...
Jmeter脚本优化——随机函数

Jmeter脚本优化——随机函数

线程组下有 2 个请求的参数中均使用到相同的参数&#xff0c;在进行参数化时&#xff0c;想 要每个请求使用不同的取值。 &#xff08; 1 &#xff09; 线程组设置如下 &#xff08; 2 &#xff09; 线程组下添加加购物车请求&#xff0c;请求传参包含商品 id &#xff08;…
阅读更多...
前端日期组件layui使用，月模式

前端日期组件layui使用，月模式

初学前端&#xff0c;实战总结 概要 有一个日期组件&#xff0c;我的谷歌浏览器选完日期后&#xff0c;偶尔获取不到最新数据&#xff0c;有一个客户&#xff0c;是经常出不来数据。 日期组件是Wdate&#xff1a;调用的方法是WdatePicker onpicking&#xff0c;代码片段如下…
阅读更多...
基于AT89C51单片机的智能交通灯设计

基于AT89C51单片机的智能交通灯设计

点击链接获取Keil源码与Project Backups仿真图&#xff1a; https://download.csdn.net/download/qq_64505944/89035863?spm1001.2014.3001.5503 1绪 论 1.1课题研究背景 交通是城市经济活动的命脉&#xff0c;对城市经济发展、人民生活水平的提高起着十分重要的作用。城市交…
阅读更多...
干货分享DS5L1伺服电机通过倍讯科技485转 Profinet 网关与西门子PLC进行通信的配置方法

干货分享DS5L1伺服电机通过倍讯科技485转 Profinet 网关与西门子PLC进行通信的配置方法

倍讯科技485转 ProfinetDS5L1 伺服电机与 Profinet 网关进行通信需要了解 Profinet 协议和伺服电机的具体通信要求。以下是您可以如何解决此问题的总体概述&#xff1a; 了解 Profinet&#xff1a;Profinet 是自动化工业以太网标准。您需要了解 Profinet 的工作原理、其寻址方案…
阅读更多...
纳斯达克大屏：媒体尺寸及投放费用详解

纳斯达克大屏：媒体尺寸及投放费用详解

纳斯达克大屏媒体尺寸及投放费用详解 纳斯达克图片要求 像素 纳斯达克大屏媒体图片的像素要求为2336 H x 1832 W (pixels)。确保你的图片符合这一尺寸要求&#xff0c;以确保在大屏上的显示效果最佳。 分辨率 分辨率要求为(1.0) px 72 dpi。这意味着每个像素显示为一个实…
阅读更多...
Spire.PDF for .NET【文档操作】演示：查找并删除 PDF 中的空白页

Spire.PDF for .NET【文档操作】演示：查找并删除 PDF 中的空白页

PDF 中的空白页并不罕见&#xff0c;因为它们可能是作者故意留下的或在操作文档时意外添加的。当您阅读或打印文档时&#xff0c;这些空白页可能会很烦人&#xff0c;因此可能非常有必要将其删除。在本文中&#xff0c;您将了解如何使用Spire.PDF for .NET以编程方式查找和删除…
阅读更多...
亲测有效Djiango连接oracle

亲测有效Djiango连接oracle

navicat连接本地oracle截图。 Djiango下面settings.py下面的DATABASES&#xff1a; 注意&#xff1a;USER最好不要用sys或者system可能会导致连接不了&#xff0c;最好是自己新建的oracle用户。
阅读更多...
【C++11】thread线程库

【C++11】thread线程库

【C11】thread线程库 目录 【C11】thread线程库thread类的简单介绍函数指针lambda表达式常用在线程中 线程函数参数join与detach利用RAII思想来自动回收线程 原子性操作库(atomic)atomic中的load函数&#xff1a;atomic中对变量进行原子操作的一些函数 CAS(Compare-And-Swap)无…
阅读更多...
VGG16神经网络搭建

VGG16神经网络搭建

一、定义提取特征网络结构 将要实现的神经网络参数存放在列表中&#xff0c;方便使用。 数字代表卷积核的个数&#xff0c;字符代表池化层的结构 cfgs {"vgg11": [64, M, 128, M, 256, 256, M, 512, 512, M, 512, 512, M],VGG13: [64, 64, M, 128, 128, M, 256, …
阅读更多...
「11」显示器采集：捕获单个显示器的完整视频画面

「11」显示器采集：捕获单个显示器的完整视频画面

「11」显示器采集捕获单个显示器的完整视频画面 在OBS软件中&#xff0c;「显示器采集」是一种用于捕集显示器屏幕画面的功能&#xff0c;您可以将其用于整个桌面窗口的采集到直播间。该功能主要用于捕捉您的计算机桌面屏幕内容&#xff0c;以便将其实时显示在直播窗口中&#…
阅读更多...
MySQL Explain 字段详解

MySQL Explain 字段详解

Explain 工具介绍 Explain 一般被称为解释器&#xff0c;通过 Explain 工具&#xff0c;我们能分析我们使用的查询语句或是结构的性能瓶颈&#xff0c;它提供 MySQL 如何执行语句的信息。 使用语法&#xff1a; explain [extended|partition] select在 select 关键字前加 ex…
阅读更多...
第 1 章.提示词:开启AI智慧之门的钥匙

第 1 章.提示词:开启AI智慧之门的钥匙

什么是提示词&#xff1f; 提示词&#xff0c;是引导语言模型的指令&#xff0c;让用户能够驾驭模型的输出&#xff0c;确保生成的文本符合需求。 ChatGPT&#xff0c;这位文字界的艺术大师&#xff0c;以transformer架构为基石&#xff0c;能轻松驾驭海量数据&#xff0c;编织…
阅读更多...
R 生存分析3：Cox等比例风险回归及等比例风险检验

R 生存分析3：Cox等比例风险回归及等比例风险检验

虽然Kaplan-Meier分析方法目前应用很广&#xff0c;但是该方法存在一下局限: 对于一些连续型变量&#xff0c;必须分类下可以进行生存率对比 是一种单变量分析&#xff0c;无法同时对多组变量进行分析 是一种非参数分析方法&#xff0c;必须有患者个体数据才能进行分析 英国…
阅读更多...
阳光倒灌高准直汽车抬头显示器HUD太阳光模拟器

阳光倒灌高准直汽车抬头显示器HUD太阳光模拟器

阳光倒灌高准直汽车抬头显示器HUD太阳光模拟器是一种高级别的模拟设备&#xff0c;用于模拟太阳光的光谱、强度及照射角度&#xff0c;应用于太阳能电池板、光伏系统等领域的研究和测试。其参数包括光谱范围、光强度、光源、照射角度、均匀性和稳定性&#xff0c;可根据需求调整…
阅读更多...
ubuntu20.04安装截图工具flameshot

ubuntu20.04安装截图工具flameshot

ubuntu20.04 自带的截图工具&#xff0c;可以使用快捷键“shift printScreen” ,但是它不能对截图进行编辑。 现在安装截图工具 flameshot&#xff0c;使用以下命令&#xff1a; sudo apt install flameshot 安装完成后&#xff0c;使用以下命令打开&#xff1a; flamesho…
阅读更多...
Go 语言基础语法

Go 语言基础语法

目录 行分隔符 注释 标识符 字符串连接 关键字 Go 语言的空格 格式化字符串 Printf 实例 Go 语言变量 变量声明 多变量声明 值类型和引用类型 简短形式&#xff0c;使用 : 赋值操作符 Go 程序可以由多个标记组成&#xff0c;可以是关键字&#xff0c;标识符&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023