C++ Boost 异步网络编程基础

Boost库为C++提供了强大的支持，尤其在多线程和网络编程方面。其中，Boost.Asio库是一个基于前摄器设计模式的库，用于实现高并发和网络相关的开发。Boost.Asio核心类是io_service，它相当于前摄模式下的Proactor角色。所有的IO操作都需要通过io_service来实现。

在异步模式下，程序除了发起IO操作外，还需要定义一个用于回调的完成处理函数。io_service将IO操作交给操作系统执行，但它不同步等待，而是立即返回。调用io_service的run成员函数可以等待异步操作完成。当异步操作完成时，io_service会从操作系统获取结果，再调用相应的处理函数（handler）来处理后续逻辑。

这种异步模型的优势在于它能够更有效地利用系统资源，避免线程阻塞，提高程序的并发性能。Boost.Asio的设计让开发者能够以高效的方式开发跨平台的并发网络应用，使C++在这方面能够与类似Java等语言相媲美。

ASIO异步定时器

boost::asio::deadline_timer 是 Boost.Asio 库中用于处理定时器的类。它允许你在一段时间后或在指定的时间点触发回调函数。deadline_timer 通常与 io_service 配合使用，以实现异步定时器功能。

以下是 boost::asio::deadline_timer 的一些重要概念和方法：

构造函数： deadline_timer 的构造函数通常需要一个 io_service 对象和一个时间参数。时间参数可以是相对时间（相对于当前时间的一段时间间隔）或绝对时间（具体的时刻）。

cppCopy codeboost::asio::io_service io_service;
boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));

expires_from_now 方法： 通过调用 expires_from_now 方法，可以设置相对于当前时间的时间间隔，来定义定时器的到期时间。

cppCopy code
timer.expires_from_now(boost::posix_time::seconds(10));

expires_at 方法： 通过调用 expires_at 方法，可以设置定时器的到期时间为一个具体的时刻。

cppCopy codeboost::posix_time::ptime expiryTime = boost::posix_time::second_clock::local_time() + boost::posix_time::seconds(10);
timer.expires_at(expiryTime);

async_wait 方法： async_wait 方法用于启动异步等待定时器的到期。它接受一个回调函数作为参数，该回调函数将在定时器到期时被调用。

cppCopy codevoid timerCallback(const boost::system::error_code& /*e*/)
{
    std::cout << "Timer expired!" << std::endl;
}

timer.async_wait(boost::bind(timerCallback, boost::asio::placeholders::error));

取消定时器： 你可以通过调用 cancel 方法来取消定时器，以停止它在到期时触发回调函数。

cppCopy code
timer.cancel();

boost::asio::deadline_timer 提供了一种灵活和强大的方式来处理异步定时器操作，使得你可以方便地执行定时任务、调度操作或执行周期性的工作。

#include <iostream>
#include <boost/asio.hpp>

using namespace std;
using namespace boost::asio;

void handler(const boost::system::error_code &ec)
{
  cout << "hello lyshark A" << endl;
}

void handler2(const boost::system::error_code &ec)
{
  cout << "hello lyshark B" << endl;
}

int main(int argc,char *argv)
{
  boost::asio::io_service service;

  boost::asio::deadline_timer timer(service, boost::posix_time::seconds(5));
  timer.async_wait(handler);

  boost::asio::deadline_timer timer2(service, boost::posix_time::seconds(10));
  timer2.async_wait(handler2);

  service.run();

  std::system("pause");
  return 0;
}

上述代码运行后，会分别间隔5秒及10秒，用来触发特定的handler函数，效果如下图所示；

在 Boost.Asio 中，io_service::run() 是一个关键的方法，它用于运行 I/O 服务的事件循环。通常，run() 方法会一直运行，直到没有更多的工作需要完成，即直到没有未完成的异步操作。

如果多个异步函数同时调用同一个 io_service 的 run() 方法，可以考虑将 run() 方法单独摘出来，以便在线程函数中多次调用。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>

using namespace std;
using namespace boost::asio;

void handler(const boost::system::error_code &ec)
{
  cout << "hello lyshark A" << endl;
}

void handler2(const boost::system::error_code &ec)
{
  cout << "hello lyshark B" << endl;
}

boost::asio::io_service service;

void run()
{
  service.run();
}

int main(int argc,char *argv)
{
  boost::asio::deadline_timer timer(service, boost::posix_time::seconds(5));
  timer.async_wait(handler);

  boost::asio::deadline_timer timer2(service, boost::posix_time::seconds(10));
  timer2.async_wait(handler2);

  boost::thread thread1(run);
  boost::thread thread2(run);

  thread1.join();
  thread2.join();

  std::system("pause");
  return 0;
}

上述代码的运行效果与第一个案例一致，唯一的不同在于，该案例中我们通过boost::thread分别启动了两个线程，并通过join()分别等待这两个线程的执行结束，让异步与线程分离。

通过多次触发计时器，实现重复计时器功能，如下代码使用 Boost.Asio 实现了一个异步定时器的例子。

该程序定义了一个计数器 count，并创建了一个 steady_timer 对象 io_timer，设置其到期时间为 1 秒。然后，通过 io_timer.async_wait 启动了一个异步等待操作，该操作在计时器到期时调用 print 函数。

在 print 函数中，首先判断计数器是否小于 5，如果是，则输出计数器的值，并将计时器的到期时间延迟 1 秒。然后，再次启动新的异步等待操作，递归调用 print 函数。当计数器达到 5 时，停止了 io 对象，这会导致 io.run() 返回，程序退出。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>

// 定义输出函数
void print(const boost::system::error_code &,boost::asio::steady_timer * io_timer, int * count)
{
  // 如果计时器等于4也就是循环5此后自动停止
  if (*count < 5)
  {
    std::cout << "Print函数计数器: " << *count << std::endl;
    ++(*count);
    
    // 将计时器到期时间向后延时1秒
    io_timer->expires_at(io_timer->expiry() + boost::asio::chrono::seconds(1));
    
    // 启动一个新的异步等待
    io_timer->async_wait(boost::bind(print,boost::asio::placeholders::error, io_timer, count));
  }
}

int main(int argc, char *argv)
{
  boost::asio::io_context io;
  int count = 0;
  
  // 定义IO时间为1秒
  boost::asio::steady_timer io_timer(io, boost::asio::chrono::seconds(1));

  // 绑定并调用print函数
  io_timer.async_wait(boost::bind(print, boost::asio::placeholders::error, &io_timer, &count));

  io.run();
  std::cout << "循环已跳出,总循环次数: " << count << std::endl;

  std::system("pause");
  return 0;
}

运行上述代码，输出效果如下图所示，通过计数器循环执行特定次数并输出，每次间隔为1秒。

与之前的代码相比，如下所示的版本使用了一个类 print 来封装定时器操作。

与之前版本相比的主要不同点：

  1. 类的引入： 引入了 print 类，将定时器和计数器等相关的操作封装到了一个类中，提高了代码的封装性和可读性。
  2. 构造函数和析构函数： 在 print 类中使用构造函数初始化 timer_ 定时器，而在析构函数中打印最终循环次数。这样的设计使得对象的创建和销毁分别与初始化和清理相关的操作关联起来。
  3. 成员函数 run_print： 使用了成员函数 run_print 作为定时器回调函数，无需再使用 boost::bind 绑定 this 指针，直接使用类的成员变量，提高了代码的简洁性。
  4. 对象的创建和运行： 在 main 函数中，直接创建了 print 对象 ptr，并通过 io.run() 来运行异步操作，无需手动调用 async_wait。这种方式更加面向对象，将异步操作和对象的生命周期绑定在一起。
#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>

class print
{
private:
  boost::asio::steady_timer timer_;
  int count_;

public:
  // 构造时引用io_context对象,使用它初始化timer
  print(boost::asio::io_context& io) : timer_(io, boost::asio::chrono::seconds(1)), count_(0)
  {
    // 使用 bind 绑定当前对象的 this 指针，利用成员 count 控制计时器的执行
    timer_.async_wait(boost::bind(&print::run_print, this));
  }

  // 在析构中打印结果
  ~print()
  {
    std::cout << "循环已跳出,总循环次数: " << count_ << std::endl;
  }

  // 作为类的成员函数，无需再传入参数，直接使用当前对象的成员变量
  void run_print()
  {
    if (count_ < 5)
    {
      std::cout << "Print函数计时器: " << count_ << std::endl;
      ++count_;

      timer_.expires_at(timer_.expiry() + boost::asio::chrono::seconds(1));
      timer_.async_wait(boost::bind(&print::run_print, this));
    }
  }
};

int main(int argc, char *argv)
{
  boost::asio::io_context io;
  print ptr(io);
  io.run();

  std::system("pause");
  return 0;
}

这个输出效果与之前基于过程的保持一致，其他的并无差异；

如下版本的代码相对于之前的版本引入了 io_context::strand 来保证定时器回调函数的串行执行，避免了多个线程同时执行 print1 和 print2 导致的竞态条件。

与之前版本相比的主要不同点：

  1. io_context::strand 的引入： 引入了 io_context::strand 对象 strand_，用于确保 print1 和 print2 的回调函数在同一线程内按序执行。io_context::strand 在多线程环境中提供了同步操作，确保绑定到 strand_ 上的操作不会同时执行。
  2. bind_executor 的使用： 在 async_wait 中使用了 boost::asio::bind_executor 函数，将定时器的回调函数与 strand_ 绑定，保证了异步操作的执行在 strand_ 内。这样可以确保 print1 和 print2 不会在不同线程中同时执行。
  3. 多线程运行 io_context： 引入了两个子线程 t 和 t1，分别调用 io_context::run 来运行 io_context。这样可以使 io_context 在两个独立的线程中运行，增加了并发性。
  4. 线程的 Join： 在 main 函数中，通过 t.join() 和 t1.join() 等待两个子线程执行完成后再退出程序。这样确保了 main 函数在所有线程都完成后再结束。

总体而言，这个版本通过引入 io_context::strand 以及多线程运行 io_context，解决了异步操作可能导致的竞态条件，增强了程序的并发性。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>

class print
{
public:
  print(boost::asio::io_context& io) : strand_(io),  // strand用于控制handler的执行
    timer1_(io, boost::asio::chrono::seconds(1)),   // 运行两个计时器
    timer2_(io, boost::asio::chrono::seconds(1)),
    count_(0)
  {
    // 启动异步操作时，每个 handler 都绑定到 strand 对象
    // bind_executor() 返回一个新的 handler，它将自动调度其包含的 print::print1
    // 通过将 handler 绑定到同一个 strand，保证两个print不会同时执行
    timer1_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print1, this)));
    timer2_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print2, this)));
  }

  void print1()
  {
    if (count_ < 10)
    {
      std::cout << "Print 1: " << count_ << std::endl;
      ++count_;

      timer1_.expires_at(timer1_.expiry() + boost::asio::chrono::seconds(1));
      timer1_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print1, this)));
    }
  }

  void print2()
  {
    if (count_ < 10)
    {
      std::cout << "Print 2: " << count_ << std::endl;
      ++count_;

      timer2_.expires_at(timer2_.expiry() + boost::asio::chrono::seconds(1));
      timer2_.async_wait(boost::asio::bind_executor(strand_,boost::bind(&print::print2, this)));
    }
  }

private:
  boost::asio::io_context::strand strand_;
  boost::asio::steady_timer timer1_;
  boost::asio::steady_timer timer2_;
  int count_;
};

int main(int argc,char *argv[])
{
  // 第一个线程
  boost::asio::io_context io;
  print ptr(io);
  
  // 定义两个子线程
  boost::thread t(boost::bind(&boost::asio::io_context::run, &io));
  boost::thread t1(boost::bind(&boost::asio::io_context::run, &io));

  io.run();
  t.join();
  t1.join();

  std::system("pause");
  return 0;
}

输出效果如下图所示；

ASIO异步网络通信

异步通信的原理与同步通信不同，主要体现在程序对IO请求的处理上。在异步状态下，程序发起IO请求后会立即返回，无需等待IO操作完成。无论IO操作成功还是失败，程序都可以继续执行其他任务，不会被阻塞。当IO请求被执行完成后，系统会通过回调函数的方式通知调用者，使其能够获取操作的状态或结果。

这种异步通信的机制带来了一些优势：

  1. 提高并发性： 在异步模式下，程序在等待IO操作完成的过程中不会阻塞，可以继续执行其他任务，充分利用了宝贵的CPU时间。这使得程序更容易实现高并发，同时处理多个IO操作。
  2. 节省时间： 由于程序不需要等待IO操作完成，可以更加高效地利用时间。在同步模式下，程序必须等待每个IO操作的完成，而在异步模式下，可以在等待的时间内执行其他任务，提高了整体效率。
  3. 提高系统响应性： 异步通信使得程序能够更灵活地响应IO事件，及时处理完成的IO操作。这对于需要快速响应用户请求的系统非常重要，如网络通信、图形用户界面等。
  4. 减少资源浪费： 在异步模式下，程序可以通过回调函数获取IO操作的结果，而无需通过轮询或其他方式一直等待。这减少了对系统资源的浪费，提高了系统的效率。

异步通信的原理在于通过非阻塞的方式发起IO请求，充分利用等待IO完成的时间，通过回调函数的方式获取IO操作的结果，以提高程序的并发性、响应性和效率。

使用Boost.Asio库实现简单的异步TCP服务器。

对代码的主要分析：

  1. IOService 结构体：
    • 该结构体负责管理 io_service 和 acceptor。
    • 构造函数初始化 io_service 和 acceptor 对象。acceptor 用于监听连接请求。
    • start() 函数启动异步等待连接操作，当有客户端连接请求时，触发 accept_handler。
  2. start() 函数：
    • 在 start() 函数中，通过 async_accept 异步等待连接请求，当有客户端连接请求时，会触发 accept_handler 函数。
    • 创建了一个新的 tcp::socket 对象，并使用 async_accept 异步等待连接请求。
    • accept_handler 函数被绑定，负责处理连接成功后的操作。
  3. accept_handler 函数：
    • 当有客户端连接成功时，该函数会被调用。
    • 递归调用 start()，以便继续等待新的连接请求。
    • 输出远程客户端的IP地址。
    • 创建一个字符串指针 pstr，并发送 “hello lyshark” 给客户端。
  4. write_handler 函数：
    • 当异步写操作完成时，该函数被调用。
    • 输出已发送的信息。
  5. main 函数：
    • 创建了一个 io_service 对象和 IOService 对象 server。
    • 调用 server.start() 启动服务器。
    • 调用 io.run() 启动 IO 服务，使其保持运行状态，直到所有异步操作完成。

整体而言，这个程序通过异步的方式接受客户端连接，并在连接建立后异步发送消息给客户端。使用 Boost.Asio 提供的异步操作可以实现高效的并发网络编程。

#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/smart_ptr.hpp>

using namespace boost::asio;
using boost::system::error_code;
using ip::tcp;

struct IOService
{
  IOService(io_service &io) :m_iosev(io), m_acceptor(io, tcp::endpoint(tcp::v4(), 80))
  {
    std::cout << "执行构造函数" << std::endl;
  }
  void start()
  {
    // 非阻塞等待连接
    boost::shared_ptr<tcp::socket> psocket(new tcp::socket(m_iosev));
    // 绑定 IOService::accept_handler 当有请求进来时,自动回调到绑定accept_handler函数上
    m_acceptor.async_accept(*psocket,boost::bind(&IOService::accept_handler, this, psocket, _1));
  }

  // 有客户端连接时accept_handler触发
  void accept_handler(boost::shared_ptr<tcp::socket> psocket, error_code ec)
  {
    if (ec) return;

    // 再次递归调用start()函数继续等待新连接进入
    start();
    
    // 显示远程IP
    std::cout << "远端IP: " << psocket->remote_endpoint().address() << std::endl;
    
    // 发送信息(非阻塞)
    boost::shared_ptr<std::string> pstr(new std::string("hello lyshark"));

    // 绑定 IOService::write_handler 回调函数,当发送完成后,自动触发 write_handler
    psocket->async_write_some(buffer(*pstr),boost::bind(&IOService::write_handler, this, pstr, _1, _2));
  }

  // 异步写操作完成后write_handler触发
  void write_handler(boost::shared_ptr<std::string> pstr,error_code ec, size_t bytes_transferred)
  {
    if (!ec)
      std::cout << *pstr << " 已发送" << std::endl;
  }

private:
  io_service &m_iosev;
  ip::tcp::acceptor m_acceptor;
};


int main(int argc, char* argv[])
{
  io_service io;
  IOService server(io);
  server.start();
  io.run();
  return 0;
}

客户端代码

#include <iostream>
#include <string>
#include <boost/asio.hpp>

using namespace boost::asio;

int main(int argc, char *argv[])
{
  io_service io_service;
  ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), 1000);
  ip::tcp::socket socket(io_service);
  socket.connect(ep);

  char buffer[1024] = { 0 };
  socket.read_some(boost::asio::buffer(buffer));
  std::cout << buffer << std::endl;

  std::system("pause");
  return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Android仿 美团 / 饿了么，店铺详情页功能

Android仿 美团 / 饿了么，店铺详情页功能

前言 UI有所不同&#xff0c;但功能差不多&#xff0c;商品添加购物车功能 正在写&#xff0c;写完会提交仓库。 页面主要由&#xff1a;MagicIndicator ViewPager2 Fragment CoordinatorLayout NestedScrollView RecyclerView实现。 效果图一&#xff1a;左右RecyclerV…
阅读更多...
【SwiftUI】7.预览及其内部机制

【SwiftUI】7.预览及其内部机制

上一篇讲到了组件及组件化&#xff0c;从概念和优/缺点两个方向说明了组件化的意义&#xff0c;更为重要的是&#xff0c;组件和组件化是一个在编程领域&#xff0c;放之四海皆可以的概念&#xff0c;理解和运用它是非常必要的&#xff0c;希望大家能掌握。今天我们介绍另一个特…
阅读更多...
K8S如何部署ActiveMQ（单机、集群）

K8S如何部署ActiveMQ（单机、集群）

前言 大家好&#xff0c;在今天的讨论中&#xff0c;我们将深入研究如何将ActiveMQ迁移到云端&#xff0c;以便更好地利用Kubernetes的容器调度和资源管理能力&#xff0c;确保ActiveMQ的高可用性和可扩展性。 ActiveMQ是Apache开源组织推出的一款开源的、完全支持JMS1.1和J2…
阅读更多...
vue2:组件中extends的使用

vue2:组件中extends的使用

上一篇文章中我对mixin的使用进行了一个使用和测试,这里对extend进行一个使用,其实extend和mixin还是有区别的。 上一篇文章:vue2:mixin混入的使用-CSDN博客 不过也是看实际的业务场景,我们也可以使用extend完成和mixin几乎一摸一样的操作。 不废话,上代码 创建extendTest.…
阅读更多...
位图的详细讲解

位图的详细讲解

位运算操作符&#xff1a;或&#xff0c;与&#xff0c;异或&#xff0c;按位取反。 操作符 |两个中有一个是一则为一&两个都是一则为一^相同为零&#xff0c;不同为一~零变成一&#xff0c;一变成零 什么是位运算符: 位运算是直接对整型数据的二进制进行运算。 位图概念…
阅读更多...
告别百度网盘，搭建自己的专属网盘 ——Cloudreve，不限制下载速度！

告别百度网盘，搭建自己的专属网盘 ——Cloudreve，不限制下载速度！

Cloudreve 是一个用 Go 语言写的公有网盘程序，我们可以用它来快速搭建起自己的网盘服务，公有云 / 私有云都可。 顺哥博客 先来看看文档介绍吧。 支持多家云存储驱动的公有云文件系统. 演示站 • 讨论社区 • 文档 • 下载 • Telegram 群组 • 许可证 :sparkles: 特性 :cl…
阅读更多...
webshell之Laravel和yii

webshell之Laravel和yii

EvalLoader#load 免杀效果 EvalLoader#load分析 eval命令执行函数&#xff0c;参数可控 MockTrait#generate 免杀效果 MockTrait#generate函数分析 存在一个eval函数 MockTrait#generate 免杀效果 view#evaluateDynamicContent 免杀效果 view#evaluateDynamicContent分析 总结…
阅读更多...
Facebook的特点优势

Facebook的特点优势

Facebook作为全球最大的社交媒体平台之一&#xff0c;同时也是最受欢迎的社交网站之一&#xff0c;Facebook具有许多独特的特点和优势。本文小编将说一些关于Facebook的特点及优势。 1、全球化 Facebook拥有数十亿的全球用户&#xff0c;覆盖了几乎所有国家和地区。这使得人们…
阅读更多...
初学剪辑者找视频素材就上这6个网站

初学剪辑者找视频素材就上这6个网站

视频剪辑必备的6个素材网站&#xff0c;高清无水印&#xff0c;还可以免费下载&#xff0c;无版权限制&#xff0c;赶紧收藏起来&#xff01; 1、菜鸟图库 https://www.sucai999.com/video.html?vNTYxMjky 菜鸟图库网素材非常丰富&#xff0c;网站主要以设计类素材为主&#…
阅读更多...
(4)BUUCTF-web-[极客大挑战 2019]EasySQL1

(4)BUUCTF-web-[极客大挑战 2019]EasySQL1

前言&#xff1a; 觉得这个题目挺有意义的&#xff0c;因为最近在学数据库&#xff0c;但是不知道在现实中有什么应用&#xff0c;所以学起来也没有什么兴趣&#xff0c;做了这个题目&#xff0c;发现数据库还是挺有用处的&#xff0c;哈哈 知识点&#xff1a; mysql 中and和…
阅读更多...
2023-11-24--oracle--实验--[Merge 语句]

2023-11-24--oracle--实验--[Merge 语句]

oracle--实验---Merge语句 1.认知Merge 语句 • merge 语句是 sql 语句的一种。在 SQL server 、 Oracle 数据库中可用&#xff0c; MySQL 中不可用。 • merge 用来合并 update 和 insert 语句。目的&#xff1a;通过 merge 语句&#xff0c;根据一张表&#xff08; 原数据表…
阅读更多...
Let’s xrOS 一款让你优先体验社区创作者的 visionOS App工具

Let’s xrOS 一款让你优先体验社区创作者的 visionOS App工具

Let’s xrOS Apple Vision Pro 发布预示着空间计算时代的到来&#xff0c;让科技爱好者和开发者开始思考如何在新的交互、系统和硬件上打造独特的三维应用。 自 WWDC 2023 的发布会后&#xff0c;社交媒体上涌现了许多精美的 visionOS App 的效果图和演示视频&#xff0c;然而…
阅读更多...
Windows核心编程 进程

Windows核心编程 进程

目录 一、进程概述 二、创建进程相关API Winexec ShellExecute CreateProcess 三、进程退出相关API ExitProcess TerminateProcess GetCurrentProcess GetExitCodeProcess 四、如何理解虚拟内存空间 五、关于UAC 一、进程概述 进程&#xff1a;正在运行的程序 程…
阅读更多...
set和map + multiset和multimap（使用+封装(RBTree)）

set和map + multiset和multimap（使用+封装(RBTree)）

set和map 前言一、使用1. set(1)、模板参数列表(2)、常见构造(3)、find和count(4)、insert和erase(5)、iterator(6)、lower_bound和upper_bound 2. multiset3. map(1)、模板参数列表(2)、构造(3)、modifiers和operations(4)、operator[] 4. multimap 二、封装RBTree迭代器原理R…
阅读更多...
（11_23）构建高效数据流转的 ETL 系统：数据库 + Serverless 函数计算的最佳实践

（11_23）构建高效数据流转的 ETL 系统：数据库 + Serverless 函数计算的最佳实践

作者&#xff5c;柳下 概述 随着企业规模和数据量的增长&#xff0c;数据的价值越来越受到重视。数据的变化和更新变得更加频繁和复杂&#xff0c;因此及时捕获和处理这些变化变得至关重要。为了满足这一需求&#xff0c;数据库 CDC&#xff08;Change Data Capture&#xff…
阅读更多...
晶振为什么不能放置在PCB边缘

晶振为什么不能放置在PCB边缘

某行车记录仪&#xff0c;测试的时候要加一个外接适配器&#xff0c;在机器上电运行测试时发现辐射超标&#xff0c;具体频点是84MHz、144MHz、168MHz&#xff0c;需要分析其辐射超标产生的原因&#xff0c;并给出相应的对策。辐射测试数据如下&#xff1a; 图1&#xff1a;辐…
阅读更多...
B/S前后端分离的Java医院云HIS信息管理系统源码（LIS源码+电子病历源码）

B/S前后端分离的Java医院云HIS信息管理系统源码（LIS源码+电子病历源码）

HIS系统采用主流成熟技术开发&#xff0c;软件结构简洁、代码规范易阅读&#xff0c;SaaS应用&#xff0c;全浏览器访问前后端分离&#xff0c;多服务协同&#xff0c;服务可拆分&#xff0c;功能易扩展。多医院、多集团统一登录患者主索引建立、主数据管理&#xff0c;统一对外…
阅读更多...
鸿蒙开发-ArkTS 语言-状态管理

鸿蒙开发-ArkTS 语言-状态管理

鸿蒙开发-ArkTS 语言-基础语法 3. 状态管理 变量必须被装饰器装饰才能成为状态变量&#xff0c;状态变量的改变才能导致 UI 界面重新渲染 概念描述状态变量被状态装饰器装饰的变量&#xff0c;改变会引起UI的渲染更新。常规变量没有状态的变量&#xff0c;通常应用于辅助计算…
阅读更多...
CVE-2023-22515：Atlassian Confluence权限提升漏洞复现 [附POC]

CVE-2023-22515：Atlassian Confluence权限提升漏洞复现 [附POC]

文章目录 Atlassian Confluence权限提升(CVE-2023-22515)漏洞复现 [附POC]0x01 前言0x02 漏洞描述0x03 影响版本0x04 漏洞环境0x05 漏洞复现1.访问漏洞环境2.构造POC3.复现 0x06 修复建议 Atlassian Confluence权限提升(CVE-2023-22515)漏洞复现 [附POC] 0x01 前言 免责声明&…
阅读更多...
Unity-类-Vector

Unity-类-Vector

Vector矢量 是一个基本的数学概念，它允许你描述方向和大小。在游戏和应用中，矢量通常用于描述一些基本属性，如角色的位置、物体移动的速度或两个物体之间的距离。 矢量算术是计算机编程很多方面（如图形、物理和动画）的基础，深入了解这一主题对于充分发挥 Unity 的功能很有…
阅读更多...
最新文章

Copyright @ 2022~2023