Netty笔记07-粘包与半包(上)

文章目录

  • 前言
    • 1. 粘包
      • 造成粘包的原因
      • 解决粘包的方法
    • 2. 半包
      • 造成半包的原因
      • 解决半包的方法
  • 粘包现象
    • 服务端代码示例
    • 客户端代码示例
  • 半包现象
  • 现象分析
    • 粘包
    • 半包
    • 滑动窗口
    • MSS 限制
    • Nagle 算法

前言

粘包和半包问题是网络编程中常见的问题，特别是在TCP协议中。通过合理的设计和实现，比如使用消息头、特殊分隔符或协议定义等方法，可以有效地解决这些问题。

1. 粘包

“粘包”指的是在网络传输过程中，发送方连续发送的多个数据包在接收方看来像是一个连续的数据流，无法区分这些数据包的边界。这种情况通常发生在TCP协议中，因为TCP是一个面向连接的、可靠的数据流传输协议，它不保证发送的数据包一定会按原来的方式到达接收方。

造成粘包的原因

发送方快速发送：如果发送方快速连续发送多个数据包，而接收方的接收缓冲区不足以区分这些数据包，就可能发生粘包现象。
接收方处理缓慢：如果接收方处理数据的速度慢于发送方发送数据的速度，也可能导致粘包。
网络拥塞：在网络拥塞的情况下，数据包可能会被合并成更大的数据块进行传输。

解决粘包的方法

定长分隔：发送固定长度的消息。这种方式简单但不够灵活。
消息头：在消息前加上消息长度的描述，接收方根据长度来确定消息的边界。
特殊分隔符：在消息末尾加上特定的分隔符（如 \n 或其他特殊字符），接收方根据分隔符来判断消息的结束。
心跳包：定期发送心跳包来同步发送方和接收方的状态，确保数据包的正确接收。
协议定义：明确消息的格式和边界，例如使用特定的帧格式（如HTTP/2、MQTT等）。

2. 半包

“半包”指的是在接收方收到的数据包不完整，即接收到的数据包只包含了一个完整消息的一部分。这种情况通常是由于接收方的接收缓冲区不足以容纳整个消息导致的。

造成半包的原因

接收缓冲区不足：如果接收方的接收缓冲区太小，不足以一次接收完整的消息，就会出现半包现象。
网络延迟：在网络延迟较高的情况下，数据包的到达时间不一致，可能导致接收方未能及时接收到后续的数据包。

解决半包的方法

消息头：类似于解决粘包的方法，通过消息头来确定消息的长度，从而判断是否接收到完整的消息。
重发机制：如果接收方发现消息不完整，可以请求发送方重新发送缺失的部分。
累积接收：接收方可以累积接收到的数据，直到接收到完整的消息为止。
超时机制：设置合理的超时时间，如果在超时时间内未能接收到完整的消息，则可以判定消息丢失或不完整。

粘包现象

服务端代码示例

public class HelloWorldServer {static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class);void start() {NioEventLoopGroup boss = new NioEventLoopGroup(1);NioEventLoopGroup worker = new NioEventLoopGroup();try {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.channel(NioServerSocketChannel.class);serverBootstrap.group(boss, worker);serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {@Overridepublic void channelActive(ChannelHandlerContext ctx) throws Exception {log.debug("connected {}", ctx.channel());super.channelActive(ctx);}@Overridepublic void channelInactive(ChannelHandlerContext ctx) throws Exception {log.debug("disconnect {}", ctx.channel());super.channelInactive(ctx);}});}});ChannelFuture channelFuture = serverBootstrap.bind(8080);log.debug("{} binding...", channelFuture.channel());channelFuture.sync();log.debug("{} bound...", channelFuture.channel());channelFuture.channel().closeFuture().sync();} catch (InterruptedException e) {log.error("server error", e);} finally {boss.shutdownGracefully();worker.shutdownGracefully();log.debug("stoped");}}public static void main(String[] args) {new HelloWorldServer().start();}
}

客户端代码示例

客户端代码希望发送 10 个消息，每个消息是 16 字节

public class HelloWorldClient {static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);public static void main(String[] args) {NioEventLoopGroup worker = new NioEventLoopGroup();try {Bootstrap bootstrap = new Bootstrap();bootstrap.channel(NioSocketChannel.class);bootstrap.group(worker);bootstrap.handler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {log.debug("connetted...");ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {//在连接channel建立成功后，就会触发active事件@Overridepublic void channelActive(ChannelHandlerContext ctx) throws Exception {log.debug("sending...");Random r = new Random();char c = 'a';for (int i = 0; i < 10; i++) {ByteBuf buffer = ctx.alloc().buffer();buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});ctx.writeAndFlush(buffer);}}});}});ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();channelFuture.channel().closeFuture().sync();} catch (InterruptedException e) {log.error("client error", e);} finally {worker.shutdownGracefully();}}
}

服务器端的某次输出，可以看到一次就接收了 160 个字节，而非分 10 次接收

08:24:46 [DEBUG] [main] c.i.n.HelloWorldServer - [id: 0x81e0fda5] binding...
08:24:46 [DEBUG] [main] c.i.n.HelloWorldServer - [id: 0x81e0fda5, L:/0:0:0:0:0:0:0:0:8080] bound...
08:24:55 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x94132411, L:/127.0.0.1:8080 - R:/127.0.0.1:58177] REGISTERED
08:24:55 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x94132411, L:/127.0.0.1:8080 - R:/127.0.0.1:58177] ACTIVE
08:24:55 [DEBUG] [nioEventLoopGroup-3-1] c.i.n.HelloWorldServer - connected [id: 0x94132411, L:/127.0.0.1:8080 - R:/127.0.0.1:58177]
08:24:55 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x94132411, L:/127.0.0.1:8080 - R:/127.0.0.1:58177] READ: 160B+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000010| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000020| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000030| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000040| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000050| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000060| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000070| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000080| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000090| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
+--------+-------------------------------------------------+----------------+
08:24:55 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x94132411, L:/127.0.0.1:8080 - R:/127.0.0.1:58177] READ COMPLETE

半包现象

客户端代码希望发送 1 个消息，这个消息是 160 字节，代码改为

public class HelloWorldClient {static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);public static void main(String[] args) {NioEventLoopGroup worker = new NioEventLoopGroup();try {Bootstrap bootstrap = new Bootstrap();bootstrap.channel(NioSocketChannel.class);bootstrap.group(worker);bootstrap.handler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {log.debug("connetted...");ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {//在连接channel建立成功后，就会触发active事件@Overridepublic void channelActive(ChannelHandlerContext ctx) throws Exception {log.debug("sending...");Random r = new Random();char c = 'a';for (int i = 0; i < 10; i++) {ByteBuf buffer = ctx.alloc().buffer(16);
//                                ByteBuf buffer = ctx.alloc().buffer();buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});ctx.writeAndFlush(buffer);}}});}});ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();channelFuture.channel().closeFuture().sync();} catch (InterruptedException e) {log.error("client error", e);} finally {worker.shutdownGracefully();}}
}

为现象明显，服务端修改一下接收缓冲区，其它代码不变

public class HelloWorldServer {static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class);void start() {NioEventLoopGroup boss = new NioEventLoopGroup(1);NioEventLoopGroup worker = new NioEventLoopGroup();try {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.channel(NioServerSocketChannel.class);//配置接受缓冲区为10字节，观察客户端发送数据时出现的黏包半包问题serverBootstrap.option(ChannelOption.SO_RCVBUF,10);serverBootstrap.group(boss, worker);serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
//                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
//                        @Override
//                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
//                            log.debug("connected {}", ctx.channel());
//                            super.channelActive(ctx);
//                        }
//
//                        @Override
//                        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
//                            log.debug("disconnect {}", ctx.channel());
//                            super.channelInactive(ctx);
//                        }
//                    });}});ChannelFuture channelFuture = serverBootstrap.bind(8080);log.debug("{} binding...", channelFuture.channel());channelFuture.sync();log.debug("{} bound...", channelFuture.channel());channelFuture.channel().closeFuture().sync();} catch (InterruptedException e) {log.error("server error", e);} finally {boss.shutdownGracefully();worker.shutdownGracefully();log.debug("stoped");}}public static void main(String[] args) {new HelloWorldServer().start();}
}

服务器端的某次输出，可以看到接收的消息被分为两节，第一次 20 字节，第二次 140 字节

08:43:49 [DEBUG] [main] c.i.n.HelloWorldServer - [id: 0x4d6c6a84] binding...
08:43:49 [DEBUG] [main] c.i.n.HelloWorldServer - [id: 0x4d6c6a84, L:/0:0:0:0:0:0:0:0:8080] bound...
08:44:23 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221] REGISTERED
08:44:23 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221] ACTIVE
08:44:23 [DEBUG] [nioEventLoopGroup-3-1] c.i.n.HelloWorldServer - connected [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221]
08:44:24 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221] READ: 20B+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000010| 00 01 02 03                                     |....            |
+--------+-------------------------------------------------+----------------+
08:44:24 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221] READ COMPLETE
08:44:24 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221] READ: 140B+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000010| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000020| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000030| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000040| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000050| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000060| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000070| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000080| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f             |............    |
+--------+-------------------------------------------------+----------------+
08:44:24 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x1719abf7, L:/127.0.0.1:8080 - R:/127.0.0.1:59221] READ COMPLETE

注意 serverBootstrap.option(ChannelOption.SO_RCVBUF, 10) 影响的底层接收缓冲区（即滑动窗口）大小，仅决定了 netty 读取的最小单位，netty 实际每次读取的一般是它的整数倍

现象分析

粘包

  • 现象，发送 abc def，接收 abcdef
  • 原因
    • 应用层：接收方 ByteBuf 设置太大（Netty 默认 1024）
    • 滑动窗口：假设发送方 256 bytes 表示一个完整报文，但由于接收方处理不及时且窗口大小足够大，这 256 bytes 字节就会缓冲在接收方的滑动窗口中，当滑动窗口中缓冲了多个报文就会粘包
    • Nagle 算法：会造成粘包(因为tcp和ip的报头要分别占用20个字节，所以就算发送一个字节，那么总共也要发送41个字节，所以使用粘包来减少发送次数，尽可能多的发送数据)

半包

  • 现象，发送 abcdef，接收 abc def
  • 原因
    • 应用层：接收方 ByteBuf 小于实际发送数据量
    • 滑动窗口：假设接收方的窗口只剩了 128 bytes，发送方的报文大小是 256 bytes，这时放不下了，只能先发送前 128 bytes，等待 ack 后才能发送剩余部分，这就造成了半包
    • MSS 限制：当发送的数据超过 MSS 限制后，会将数据切分发送，就会造成半包

本质是因为 TCP 是流式协议，消息无边界

滑动窗口

  • TCP 以一个段（segment）为单位，每发送一个段就需要进行一次确认应答（ack）处理，但如果这么做，缺点是包的往返时间越长性能就越差
    在这里插入图片描述
    为了解决此问题，引入了窗口概念，窗口大小即决定了无需等待应答而可以继续发送的数据最大值
    在这里插入图片描述
    图中窗口大小可以同时发送四个请求，当第一个请求响应后窗口向下移动，第五个请求才可以发送，第二个请求响应后窗口下移，第六个请求发送。
    窗口实际就起到一个缓冲区的作用，同时也能起到流量控制的作用
  • 图中深色的部分即要发送的数据，高亮的部分即窗口
  • 窗口内的数据才允许被发送，当应答未到达前，窗口必须停止滑动
  • 如果 1001~2000 这个段的数据 ack 回来了，窗口就可以向前滑动
  • 接收方也会维护一个窗口，只有落在窗口内的数据才能允许接收

MSS 限制

  • 链路层对一次能够发送的最大数据有限制，这个限制称之为 MTU（maximum transmission unit），不同的链路设备的 MTU 值也有所不同，例如
  • 以太网的 MTU 是 1500
  • FDDI（光纤分布式数据接口）的 MTU 是 4352
  • 本地回环地址的 MTU 是 65535 - 本地测试不走网卡
  • MSS 是最大段长度（maximum segment size），它是 MTU 刨去 tcp 头和 ip 头后剩余能够作为数据传输的字节数
  • ipv4 tcp 头占用 20 bytes，ip 头占用 20 bytes，因此以太网 MSS 的值为 1500 - 40 = 1460
  • TCP 在传递大量数据时，会按照 MSS 大小将数据进行分割发送
  • MSS 的值在三次握手时通知对方自己 MSS 的值，然后在两者之间选择一个小值作为 MSS
    在这里插入图片描述

Nagle 算法

  • 即使发送一个字节，也需要加入 tcp 头和 ip 头，也就是总字节数会使用 41 bytes，非常不经济。因此为了提高网络利用率，tcp 希望尽可能发送足够大的数据，这就是 Nagle 算法产生的缘由
  • 该算法是指发送端即使还有应该发送的数据，但如果这部分数据很少的话，则进行延迟发送
  • 如果 SO_SNDBUF 的数据达到 MSS，则需要发送
  • 如果 SO_SNDBUF 中含有 FIN（表示需要连接关闭）这时将剩余数据发送，再关闭
  • 如果 TCP_NODELAY = true，则需要发送
  • 已发送的数据都收到 ack 时，则需要发送
  • 上述条件不满足，但发生超时（一般为 200ms）则需要发送
  • 除上述情况，延迟发送

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

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

相关文章

[Postman]接口自动化测试入门

[Postman]接口自动化测试入门

文章大多用作个人学习分享&#xff0c;如果大家觉得有不足或错漏的地方欢迎评论指出或补充 此文章将完整的走一遍一个web页面的接口测试流程 大致路径为&#xff1a; 创建集合->调用接口登录获取token->保存token->带着token去完成其他接口的自动化测试->断言-&g…
阅读更多...
✔2848. 与车相交的点

✔2848. 与车相交的点

代码实现&#xff1a; 方法一&#xff1a;哈希表 #define fmax(a, b) ((a) > (b) ? (a) : (b))int numberOfPoints(int **nums, int numsSize, int *numsColSize) {int hash[101] {0};int max 0;for (int i 0; i < numsSize; i) {max fmax(max, nums[i][1]);for …
阅读更多...
【人工智能】AI创业的前沿思考 | 从垂直领域到通用智能模型AGI的崛起

【人工智能】AI创业的前沿思考 | 从垂直领域到通用智能模型AGI的崛起

写在前面&#xff1a; &#x1f31f; 欢迎光临 清流君 的博客小天地&#xff0c;这里是我分享技术与心得的温馨角落。&#x1f4dd; 个人主页&#xff1a;清流君_CSDN博客&#xff0c;期待与您一同探索 移动机器人 领域的无限可能。 &#x1f50d; 本文系 清流君 原创之作&…
阅读更多...
Golang协程泄漏定位和排查

Golang协程泄漏定位和排查

Golang协程泄漏定位和排查 1 场景&#xff1a;无缓冲channel写阻塞2 排查和定位思路2.1 Golang pprof2.2 协程数监控2.3 操作系统内存泄漏 参考 1 场景&#xff1a;无缓冲channel写阻塞 package mainimport ("log""net/http"_ "net/http/pprof"…
阅读更多...
PPT中的图形与图片：插入、调整与格式设置技术详解

PPT中的图形与图片：插入、调整与格式设置技术详解

目录 引言 一、图形与图片的插入 1. 插入图形 2. 插入图片 二、图形与图片的调整 1. 调整大小与位置 2. 裁剪与旋转 3. 图形与图片的合并与组合 三、图片格式与布局设置 1. 图片格式设置 2. 图片布局设置 示例案例&#xff1a;制作产品展示PPT 四、结论 引言 在现…
阅读更多...
【OJ刷题】双指针问题4

【OJ刷题】双指针问题4

这里是阿川的博客&#xff0c;祝您变得更强 ✨ 个人主页&#xff1a;在线OJ的阿川 &#x1f496;文章专栏&#xff1a;OJ刷题入门到进阶 &#x1f30f;代码仓库&#xff1a; 写在开头 现在您看到的是我的结论或想法&#xff0c;但在这背后凝结了大量的思考、经验和讨论 目录 1…
阅读更多...
(CVPR-2022)感知优先的扩散模型训练

(CVPR-2022)感知优先的扩散模型训练

感知优先的扩散模型训练 Paper Title&#xff1a;Perception Prioritized Training of Diffusion Models Paper是首尔国立大学数据科学与人工智能实验室发表在CVPR 2022的工作 论文地址 Code地址 Abstract 扩散模型通过优化相应损失项的加权和&#xff08;即去噪得分匹配损失&…
阅读更多...
IEEE 754浮点数表示

IEEE 754浮点数表示

浮点数组成 以单精度浮点数(32位)为例说明&#xff1a; 十进制浮点数组成&#xff1a; 十进制基数(base)为10 二进制浮点数组成&#xff1a; 二进制基数(base)为2 以IEEE 754标准表示十进制数&#xff1a; ( 7.625 ) 10 (7.625)_{10} (7.625)10​&#xff0c;先将其转成…
阅读更多...
一，掌心里的智慧：我的 TinyML 学习之旅

一，掌心里的智慧：我的 TinyML 学习之旅

从云端到掌心&#xff1a;TinyML 的故事 想象一下&#xff0c;有一天你起床&#xff0c;伸手去关闭窗边的小闹钟&#xff0c;却发现这个小家伙已经提前预判到你的醒来时间——因为它能够“听到”你昨晚的呼吸变化&#xff0c;分析出你什么时候会醒。这个场景可能听起来像科幻小…
阅读更多...
网络编程基础概述

网络编程基础概述

文章目录 协议网络协议栈(osi)局域网IPIP和Mac地址端口号TCP和UDP网络字节序 协议 (网络协议的)意义:为了让计算机传输之间将信息正确传输给目标机器 不同系统之间能接入网络是因为定制了一套通用的协议以便支持不同系统间的网络通信 1.网络通信的问题: 将数据可靠的从A传给B a…
阅读更多...
什么是 SMB 服务器以及它如何工作？

什么是 SMB 服务器以及它如何工作？

在本文中&#xff0c;您将了解 SMB 服务器以及它们如何促进网络文件共享。 我们将介绍它们的基本功能、主要特性以及如何安全地设置它们。无论您是新手还是需要复习&#xff0c;本指南都将帮助您更好地了解 SMB 服务器。 什么是 SMB 服务器&#xff1f; SMB&#xff08;服务器…
阅读更多...
线性代数 第七讲 二次型_标准型_规范型_坐标变换_合同_正定二次型详细讲解_重难点题型总结

线性代数 第七讲 二次型_标准型_规范型_坐标变换_合同_正定二次型详细讲解_重难点题型总结

文章目录 1.二次型1.1 二次型、标准型、规范型、正负惯性指数、二次型的秩1.2 坐标变换1.3 合同1.4 正交变换化为标准型 2.二次型的主要定理3.正定二次型与正定矩阵4.重难点题型总结4.1 配方法将二次型化为标准型4.2 正交变换法将二次型化为标准型4.3 规范型确定取值范围问题4.…
阅读更多...
基于HPLC的低压电力采集方案

基于HPLC的低压电力采集方案

1. 组网部署 2. 组网部件 3. 原理
阅读更多...
【03】深度学习——神经网络原理 | 多层感知机 | 前向传播和反向传播 | 多层感知机代码实现 | 回归问题、分类问题 | 多分类问题代码实现

【03】深度学习——神经网络原理 | 多层感知机 | 前向传播和反向传播 | 多层感知机代码实现 | 回归问题、分类问题 | 多分类问题代码实现

深度学习 1.神经网络原理1.1神经元模型1.2神经网络结构1.3隐藏层1.3.1激活函数层1.4输出层1.4.1softmax层1.5损失函数1.6反向传播2.多层感知机2.1线性网络的局限性2.2引入非线性2.3多层感知机（Multi-Layer Perceptron，MLP）2.4激活函数（Activation Function）2.4.1Sigmoid函…
阅读更多...
SpringCloud入门（一）SpringCloud简介

SpringCloud入门（一）SpringCloud简介

一、为什么要学SpringCloud&#xff1f; 企业开发都使用微服务&#xff0c;面试必问微服务 要学会微服务开发的问题和解决方案。应对用户的增长和并发需求。 要应对用户需求变化&#xff1b; 单点式架构无法应对高并发&#xff1b; 服务之间的错综复杂调用&…
阅读更多...
C++多态讲解

C++多态讲解

多态 多态的概念 通俗来说&#xff0c;就是多种形态。多态分为编译时多态(静态多态)和运行时多态(动态多态)这里重点讲运行时多态。 运行时多态 运行时多态&#xff0c;具体点就是去完成某个行为(函数)&#xff0c;可以传不同的对象就会完成不同的行为&#xff0c;就达到多种形…
阅读更多...
【数学建模】2024年国赛成绩公布时间预测

【数学建模】2024年国赛成绩公布时间预测

经过三天三夜的奋战&#xff0c;2024年数学建模国赛也宣告结束&#xff0c;相信这几天超高强度的比赛也让大家精疲力竭了&#xff0c;所以经过几天的调整&#xff0c;大家都恢复过来了吧。能够在高强度的压力下坚持这么久&#xff0c;大家都超级厉害的&#xff01; 当然完整提交…
阅读更多...
基于R语言的统计分析基础：使用键盘输入数据

基于R语言的统计分析基础：使用键盘输入数据

在R语言中&#xff0c;键盘输入数据是一种灵活且直接的数据获取方式&#xff0c;适用于处理小数据集或需要即时用户交互的场景。通常用于交互式数据探索和分析、临时数据处理、交互式图形绘制、脚本自动化中的用户交互、特定应用场景下的数据录入中。 比如利用readline()函数根…
阅读更多...
秋韵虫趣.

秋韵虫趣.

文章目录 虫鸣概览虫坛文化蟀种纷呈中华蟋蟀宁阳蟋蟀刻点铁蟋长颚斗蟋 油葫芦棺头蟋中华灶蟋小素蟋树皮蟋蟀 花生大蟋斑腿针蟋其他鸣虫树蟋&#xff0c;又名竹蛉、邯郸梨片蟋&#xff0c;又名金钟、天蛉、绿蛣蛉、银琵琶凯纳奥蟋&#xff0c;又名石蛉&#xff0c;鳞蟋黄蛉蟋&am…
阅读更多...
数据湖-方案对比

数据湖-方案对比

数据湖架构结合了数据湖和数据仓库。虽然它不仅仅是两者之间的简单集成&#xff0c;但其理念是充分发挥两种架构的优势&#xff1a;数据仓库的可靠交易以及数据湖的可扩展性和低成本。 Lakehouse 架构支持管理各种数据类型&#xff0c;例如结构化、半结构化和非结构化数据&…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023