netty（1）：NIO 基础之三大组件和ByteBuffer

news2025/1/16 15:44:48

1 三大组件

1.1 Channel & Buffer

channel 有一点类似于 stream，它就是读写数据的双向通道，可以从 channel 将数据读入 buffer，也可以将 buffer 的数据写入 channel，而之前的 stream 要么是输入，要么是输出，channel 比 stream 更为底层

常见的 Channel 有

  • FileChannel
  • DatagramChannel
  • SocketChannel
  • ServerSocketChannel

buffer 则用来缓冲读写数据，常见的 buffer 有

  • ByteBuffer

        MappedByteBuffer

        DirectByteBuffer

        HeapByteBuffer

  • ShortBuffer
  • IntBuffer
  • LongBuffer
  • FloatBuffer
  • DoubleBuffer
  • CharBuffer

1.2 Selector

selector 单从字面意思不好理解，需要结合服务器的设计演化来理解它的用途

多线程版设计

多线程版缺点

  • 内存占用高
  • 线程上下文切换成本高
  • 只适合连接数少的场景

线程池版设计

线程池版缺点

  • 阻塞模式下，线程仅能处理一个 socket 连接
  • 仅适合短连接场景

selector 版设计

selector 的作用就是配合一个线程来管理多个 channel，获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，不会让线程吊死在一个 channel 上。适合连接数特别多，但流量低的场景（low traffic）

调用 selector 的 select() 会阻塞直到 channel 发生了读写就绪事件，这些事件发生，select 方法就会返回这些事件交给 thread 来处理

2 ByteBuffer

有一普通文本文件 data.txt，内容为

1234567890abcd

使用 FileChannel 来读取文件内容

package org.example.demo1;

import lombok.extern.slf4j.Slf4j;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

@Slf4j
public class ChannelDemo1 {
    public static void main(String[] args) {
        try (FileChannel channel = new FileInputStream("data.txt").getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocate(10);
            do {
                // 向 buffer 写入
                int len = channel.read(buffer);
                log.debug("读到字节数：{}", len);
                if (len == -1) {
                    break;
                }
                // 切换 buffer 读模式
                buffer.flip();
                while(buffer.hasRemaining()) {
                    byte b = buffer.get();
                    log.debug("实际字节{}", (char)b);
                }
                // 切换 buffer 写模式
                buffer.clear();
            } while (true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

输出

15:03:39.467 [main] DEBUG org.example.demo1.ChannelDemo1 - 读到字节数：10
15:03:39.475 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节1
15:03:39.475 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节2
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节3
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节4
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节5
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节6
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节7
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节8
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节9
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节0
15:03:39.476 [main] DEBUG org.example.demo1.ChannelDemo1 - 读到字节数：4
15:03:39.477 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节a
15:03:39.477 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节b
15:03:39.477 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节c
15:03:39.477 [main] DEBUG org.example.demo1.ChannelDemo1 - 实际字节d
15:03:39.477 [main] DEBUG org.example.demo1.ChannelDemo1 - 读到字节数：-1

2.1 ByteBuffer 正确使用姿势

  • 向 buffer 写入数据，例如调用 channel.read(buffer)
  • 调用 flip() 切换至读模式
  • 从 buffer 读取数据，例如调用 buffer.get()
  • 调用 clear() 或 compact() 切换至写模式
  • 重复 1~4 步骤

2.2 ByteBuffer 结构

ByteBuffer 有以下重要属性

  • capacity
  • position
  • limit

一开始

写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态

flip 动作发生后，position 切换为读取位置，limit 切换为读取限制

读取 4 个字节后，状态

clear 动作发生后，状态

compact 方法，是把未读完的部分向前压缩，然后切换至写模式 

调试工具类

package org.example.utils;

import io.netty.util.internal.StringUtil;

import java.nio.ByteBuffer;

import static io.netty.util.internal.MathUtil.isOutOfBounds;
import static io.netty.util.internal.StringUtil.NEWLINE;

public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }
}

测试如下：

package org.example.demo1;

import java.nio.ByteBuffer;

import static org.example.utils.ByteBufferUtil.debugAll;

public class TestByteBufferReadWrite {
    public static void main(String[] args){
        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
        byteBuffer.put((byte) 0x61);// a
        debugAll(byteBuffer);
        byteBuffer.put(new byte[]{0x62,0x63,0x64});
        debugAll(byteBuffer);
        byteBuffer.get();
        debugAll(byteBuffer);
        //切换为读的状态
        byteBuffer.flip();
        byteBuffer.get();
        debugAll(byteBuffer);
        byteBuffer.compact();
        debugAll(byteBuffer);
    }
}

运行结果如下：

18:12:55.063 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 00 00 00 00 00 00 00 00 00                   |a.........      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [4], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [5]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [4], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 62 63 64 00 00 00 00 00 00 00                   |bcd.......      |
+--------+-------------------------------------------------+----------------+

Process finished with exit code 0

2.3 ByteBuffer 常见方法

分配空间

可以使用 allocate 方法为 ByteBuffer 分配空间，其它 buffer 类也有该方法

Bytebuffer buf = ByteBuffer.allocate(16);

例子：

package org.example.demo1;

import java.nio.ByteBuffer;

public class TestByteBufferAllocate {
    public static void main(String[] args){
        System.out.println(ByteBuffer.allocate(16).getClass());
        System.out.println(ByteBuffer.allocateDirect(16).getClass());

    }
}

运行结果如下： 

注意：
        class java.nio.HeapByteBuffer    -java 堆内存，读写效率低，受到GC的影响
        class java.nio.DirectByteBuffer   -直接内存，读写效率高（少一次拷贝），不会受GC影响，分配的效率低

向 buffer 写入数据

有两种办法

  • 调用 channel 的 read 方法
  • 调用 buffer 自己的 put 方法
int readBytes = channel.read(buf);

和

buf.put((byte)127);

从 buffer 读取数据

同样有两种办法

  • 调用channel的write方法
  • 调用buffer自己的get方法
int writeBytes = channel.write(buf);

和

byte b = buf.get();

get 方法会让 position 读指针向后走，如果想重复读取数据

  • 可以调用 rewind 方法将 position 重新置为 0
package org.example.demo1;

import java.nio.ByteBuffer;

import static org.example.utils.ByteBufferUtil.debugAll;

public class TestByteBufferRead {
    public static void main(String[] args){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'});
        buffer.flip();

        //rewind 从头开始读
        buffer.get(new  byte[4]);
        debugAll(buffer);
        System.out.println("===============================rewind================================");
        buffer.rewind();
        System.out.println((char)buffer.get());

    }
}

调用结果：

+--------+-------------------- all ------------------------+----------------+
position: [4], limit: [4]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
===============================rewind================================
a

  • 或者调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针
package org.example.demo1;

import java.nio.ByteBuffer;

import static org.example.utils.ByteBufferUtil.debugAll;

public class TestByteBufferRead {
    public static void main(String[] args){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'});
        buffer.flip();

        //get(i) 不会改变读索引的位置
        System.out.println((char) buffer.get(3));
        debugAll(buffer);

    }
}

调用结果：

 

mark 和 reset

mark 是在读取时，做一个标记，即使 position 改变，只要调用 reset 就能回到 mark 的位置

package org.example.demo1;

import java.nio.ByteBuffer;

import static org.example.utils.ByteBufferUtil.debugAll;

public class TestByteBufferRead {
    public static void main(String[] args){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'});
        buffer.flip();

        //mark & reset
        //mark 做一个标记，记录position位置，reset 是将position重置到mark的位置
        System.out.println((char) buffer.get());
        System.out.println((char) buffer.get());
        buffer.mark();//加标记，索引2的位置
        System.out.println((char) buffer.get());
        System.out.println((char) buffer.get());
        buffer.reset();//将position重置到索引2
        System.out.println((char) buffer.get());
        System.out.println((char) buffer.get());

    }
}

测试结果：

a
b
c
d
c
d

注意

rewind 和 flip 都会清除 mark 位置

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

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

相关文章

C++生成.dll文件后在Python中引用（包括传递参数是double型、char*数组，接收参数也为数组）

C++生成.dll文件后在Python中引用（包括传递参数是double型、char*数组，接收参数也为数组）

一、问题描述 博主想要实现的C函数原型如下&#xff1a; double* getInfo(int flag, double xyz[], char *xodrPath)也就是需要传递参数为三个不同类型的参数&#xff0c;返回值为double类型的指针&#xff08;数组&#xff09;。 那么如何在Python中如何通过这个函数生成的…
阅读更多...
完全兼容GM8775C方案|替代GM8775C设计|CS5518替代GM8775C DSI转双LVDS设计方案

完全兼容GM8775C方案|替代GM8775C设计|CS5518替代GM8775C DSI转双LVDS设计方案

GM8775C 型 DSI 转双通道 LVDS 发送器产品主要实现将 MIPI DSI 转单/双通道 LVDS功能。GM8775C输入端DSI符合 协议支持 MIPI D-PHY 1.00.00 和MIPI DSI 1.02.00&#xff0c;可实现 1 到 4通道 DSI 信号接收。最大数据率 1Gbps/通道。视频输入格式支持 16bit RGB565、18bit RGB6…
阅读更多...
Mybatis 一对一、一对多、多对多

Mybatis 一对一、一对多、多对多

今天我们来复习一下 Mybatis 框架吧 总所周知&#xff0c;Mybatis 是一款优秀的 基于ORM 半自动 轻量化 的 持久层框架 ORM&#xff1a;对象关系映射&#xff0c;简单的说就是表结构对应实体类 半自动&#xff1a;可灵活配置SQL&#xff0c;优化代码性能 轻量化&#xff1a…
阅读更多...
php源代码保护——PHP加密方案分析解密还原

php源代码保护——PHP加密方案分析解密还原

前言 php是一种解释型脚本语言.与编译型语言不同,php源代码不是直接翻译成机器语言.而是翻译成中间代码(OPCODE) ,再由解释器(ZEND引擎)对中间代码进行解释运行 . 在php源代码的保护在原理可以分为3大类. 源代码混淆(编码)OPCODE混淆(编码)修改解释引擎(虚拟机) 在部署上可…
阅读更多...
Vue学习笔记 ④

Vue学习笔记 ④

文章目录template 选项Vue 生命周期生命周期图示生命周期钩子beforeCreatecreatedbeforeMountmountedbeforeUpdateupdatedbeforeDestroydestroyed组件基础组件是什么&#xff1f;组件注册全局组件局部组件组件名组件复用自闭合组件组件的 data 选项单个根元素组件\_Prop注册自定…
阅读更多...
怎么排除无效问卷？

怎么排除无效问卷？

目录 1、答题限制 1&#xff09;设置问卷验证码/密码 2&#xff09;设置填写唯一链接 2、题目设置 1&#xff09;设置陷阱题目 2&#xff09;打乱题目顺序 3&#xff09;设置跳转逻辑 4&#xff09;题目数量限制 3、问卷筛选 问卷调查是一种能够在进行社会调研时帮助我…
阅读更多...
SAP ABAP发送HTML格式的邮件

SAP ABAP发送HTML格式的邮件

输入参数&#xff1a; I_SUBJECT&#xff1a;内容的简短描述 IT_MESSAGE_BODY&#xff1a;邮件主体部分&#xff08;convert string to table&#xff09; IT_ATTACHMENTS&#xff1a;附件内容 I_SENDER_MAIL&#xff1a;发送者的电子邮件地址 I_ATTMSG_CHECK&#xff1a;…
阅读更多...
浙大MBA/MPA/MEM复试中的五大认知误区

浙大MBA/MPA/MEM复试中的五大认知误区

在每年的研究生复试过程中都不乏大意失荆州者&#xff0c;经过联考初试的洗礼走到复试环节&#xff0c;却因为录取排名的变化而止步于录取大门口。在这些案例中&#xff0c;不少考生其实是针对复试这个环节有诸多认知误区&#xff0c;本期杭州达立易考结合MBA/MEM/MPA在职类硕士…
阅读更多...
CentOS配置静态IP

CentOS配置静态IP

CentOS配置静态IP1.获取VMnet8虚拟网卡的网段2.编辑虚拟机虚拟网络3.虚拟机中网络配置4.验证配置1.获取VMnet8虚拟网卡的网段 通过ipconfig -all查询VMnet8网卡的网段&#xff0c;这个等会需要使用 这里是&#xff1a;192.168.177 这里注意&#xff0c;还需要记录一下宿主机&…
阅读更多...
rust字符串

rust字符串

字符串类型 诸位在入门rust的时候&#xff0c;要认真&#xff0c;因为字符串类型在rust中有好几种&#xff0c;一不小心就搞混了类型&#xff0c;导致代码编译报错。好在有强大的rust-analyzer和vscode帮助我们。我们直接通过一段代码来开始认识rust的字符串类型。 fn main()…
阅读更多...
nginx学习笔记5（小d课堂）

nginx学习笔记5（小d课堂）

全局异常兜底数据返回 我们如果访问的路径不存在&#xff0c;会给我们返回一个404.那么我们就可以通过nginx配置去返回兜底数据&#xff1a; 修改完配置&#xff0c;重启nginx。 这样我们就返回我们的兜底数据了。 nginx封禁恶意ip 我们现在随便选择一个ip进行封禁测试。 我们现…
阅读更多...
.Net Core 6.0 WebApi配置跨域

.Net Core 6.0 WebApi配置跨域

ASP.Net Core 6.0 WebApi配置跨域 Program.cs文件代码如下&#xff1a; //配置跨域 builder.Services.AddCors(cor > {var cors configuration.GetSection("CorsUrls").GetChildren().Select(p > p.Value);cor.AddPolicy("Cors", policy >{poli…
阅读更多...
92、【树与二叉树】leetcode ——111. 二叉树的最小深度：层次遍历+先序DFS+后序DFS[子问题分解]（C++版本）

92、【树与二叉树】leetcode ——111. 二叉树的最小深度：层次遍历+先序DFS+后序DFS[子问题分解]（C++版本）

题目描述 原题链接&#xff1a;111. 二叉树的最小深度 解题思路 1、迭代法&#xff1a;层序遍历BFS 最小深度的特点是第一次遍历到结点的左右指针为NULL&#xff0c;此时该路径为最短路径。 /*** Definition for a binary tree node.* struct TreeNode {* int val;* …
阅读更多...
探索SpringMVC-组件之HandlerExceptionResolver

探索SpringMVC-组件之HandlerExceptionResolver

前言 在介绍完Handler、HandlerAdapter、HandlerMapping之后&#xff0c;剩下的比较关键的组件就是HandlerExceptionResolver、ViewResolver。其他的像国际化、主题、文件上传、重定向&#xff0c;这些锦上添花的组件都是一个框架需要关心的。但不是我们平常使用的核心功能&am…
阅读更多...
蓝桥杯省赛习题练习(三)

蓝桥杯省赛习题练习(三)

题目来源&#xff1a;2022年第十三届省赛(B组)真题 目录1.九进制转十进制运行结果2. 顺子日期运行结果3. 刷题统计运行结果4. 积木画1.九进制转十进制 问题描述&#xff1a;九进制正整数 (2022)9 转换成十进制等于多少&#xff1f; #include<stdio.h> #include<math.h…
阅读更多...
一文带你深入了解线程池

一文带你深入了解线程池

目录一. 什么是线程池二. 为什么要使用线程池三. 线程池的参数四. 线程池的工作流程五. 使用Executors 创建常见的功能线程池一. 什么是线程池 简单来说&#xff0c;线程池就是提前创建好一批线程&#xff0c;当有任务的时候&#xff0c;从池子中取出一个线程去执行该任务&…
阅读更多...
再说多线程（二）——细说Monitor类

再说多线程（二）——细说Monitor类

在上一节我们已经讨论了使用Lock来保证并发程序的一致性&#xff0c;Lock锁是借助了Monitor类的功能。本节将详细的介绍Monitor类&#xff0c;以及如何通过Monitor类的成员函数实现并行程序的一致性。1.Monitor类介绍根据微软的说法&#xff0c;C#中的监视器类提供了一种同步对…
阅读更多...
Microsoft Visual SourceSafe的使用

Microsoft Visual SourceSafe的使用

1、介绍 Microsoft Visual SourceSafe&#xff0c;简称vss。是一款早期微软推出的版本管理工具。跟据官方的定义&#xff0c;vss有两种控制模式&#xff1a;独占&#xff08;Lock-Modify-Unlock Model&#xff09;和并行&#xff08;Copy-Modify-Merge Model&#xff09;。独占…
阅读更多...
程序的安装——软件安装包的制作、软件源的使用

程序的安装——软件安装包的制作、软件源的使用

读书笔记 —— 《嵌入式C语言自我修养》 软件安装 linux 安装包的制作 编译 软件安装包路径 使用dpkg命令来制作安装包 及 安装包的卸载 软件仓库 更新源 查看具体需要更新的软件包 更新软件包 软件安装 软件安装的过程其实就是将一个可执行文件安装到ROM的过…
阅读更多...
安全狗云原生安全从1.X到2.X的演变之路（1）

安全狗云原生安全从1.X到2.X的演变之路（1）

随着云计算技术的蓬勃发展&#xff0c;传统上云实践中的应用升级缓慢、架构臃肿、无法快速迭代等“痛点”日益明显。能够有效解决这些“痛点”的云原生技术正蓬勃发展&#xff0c;成为赋能业务创新的重要推动力&#xff0c;并已经应用到企业核心业务。然而&#xff0c;云原生技…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023