深入理解网络 I/O：FileOutputStream、BufferFileOutputStream、ByteBuffer

在这里插入图片描述

🔭 嗨，您好 👋 我是 vnjohn，在互联网企业担任 Java 开发，CSDN 优质创作者
📖 推荐专栏：Spring、MySQL、Nacos、Java，后续其他专栏会持续优化更新迭代
🌲文章所在专栏：网络 I/O
🤔 我当前正在学习微服务领域、云原生领域、消息中间件等架构、原理知识
💬 向我询问任何您想要的东西，ID：vnjohn
🔥觉得博主文章写的还 OK，能够帮助到您的，感谢三连支持博客🙏
😄 代词: vnjohn
⚡ 有趣的事实：音乐、跑步、电影、游戏

目录

  • 前言
  • FileOutputStream
    • 代码
    • strace
  • BufferFileOutputStream
    • 源码
    • 代码
    • strace
    • FileOutput VS BufferFileOutput
  • ByteBuffer
    • 介绍
    • 使用
    • 如何使用 ByteBuffer 操作文件
    • 代码
    • strace
  • 总结

前言

在 Java API 中，应用 I/O 有不同的方式，本文会从三种不同方向的 I/O 来介绍写的操作，分别是：FileOutputStream、BufferFileOutputStream、RandomAccessFile

FileOutputStream：普通 I/O 写
BufferFileOutputStream：以一个 Buffer 缓冲的方式写
RandomAccessFile：以指针的方式向前推进读或写，该类的实例支持对随机访问文件的读写

同时会以 strace 追踪日志内容的方式，来分析它们在内核是如何操作的，有无进行用户态内核态切换或者何时进行这个切换动作的

FileOutputStream

FileOutputStream 对应的是文件输出流，FileInputStream 是文件输入流

文件输出流是将数据写入 File 或 FileDescriptor-FD 文件描述符的输出流中，FileOutputStream 通过字节流的方式进行写入，对于字符流的写入，可以使用 FileWriter

文件输入流是从文件系统中的文件中获取输入的字节，可用的文件取决于主机的环境，FileInputStream 用于读取原始字节流，如：图像数据，对于字符流的读取，可以使用 FileReader

代码

下面通过一段简单的代码来使用 FileOutputStream

import java.io.File;
import java.io.FileOutputStream;

/**
 * 普通文件 IO 写
 *
 * @author vnjohn
 * @since 2023/12/18
 */
public class NormalFileIO {
    static byte[] DATA = "1234567890\n".getBytes();
    static String PATH = "/opt/io/normal/out.txt";

    public static void main(String[] args) throws Exception {
        File file = new File(PATH);
        FileOutputStream out = new FileOutputStream(file);
        while (true) {
            // 模拟业务代码，让文件慢点写数据
            Thread.sleep(10);
            out.write(DATA);
        }
    }
}

指定一个要写入字节流的文件输出流：/opt/io/normal/out.txt，开启一个循环不断的往这个文件里写入数据，再循环中使用 Thread#sleep 方法来模拟业务代码的执行

strace

将源文件放入到 Linux 虚拟机节点进行编译执行

1、javac NormalFileIO.java
2、创建目录：/opt/io/normal
3、strace 追踪：strace -ff -o normal_out java NormalFileIO

让它运行一段时间以后，通过：jps 命令查看有哪些 java 进程在运行，通过它的 pid 号+1 就能知道 normal_out 文件前缀的后缀是什么了.

通过 tail -f /opt/io/normal_out.pid 一直观察窗口是否滚动

在这里插入图片描述

可以看到通过 FIleOutputStream 输出流是每调用一次 write 方法都会触发一次系统调用函数：write，也就是每调用一次就触发了一次用户态和内核态的切换，这种方式会极其的影响用户程序的资源和性能。

BufferFileOutputStream

BufferFileOutputStream：该类实现了一个缓冲的输出流，通过设置这样的输出流，应用程序可以将字节写入输出流中，而不必每个写入的字节或每一段写入的字节调用系统函数

它是以一个 buffer 大小进行写入的，当字节总数大于或等于这个 buffer 设置的字节数，那么它就会触发一次系统调用，将它写入到文件中.

源码

BufferFileOutputStream 它提供了两个构造函数，当我们传入一个 FileOutputStream 输出流对象时，在其内部会对其做一层处理，观察如下的方法实现：

// 存储数据的缓冲区
protected byte buf[];
// 计数器：缓冲区的有效字节数，0-buf.length 范围
protected int count;

// 创建一个 8KB 缓冲输出流
public BufferedOutputStream(OutputStream out) {
	this(out, 8192);
}

// 创建一个自定义字节大小的缓冲输出流，比如：1024、2048、4096
public BufferedOutputStream(OutputStream out, int size) {
    super(out);
    if (size <= 0) {
        throw new IllegalArgumentException("Buffer size <= 0");
    }
    buf = new byte[size];
}

/**
 * 将指定字节写入缓冲输出流中.
 *
 * @param      b   要写入的字节
 * @exception  IOException  if an I/O error occurs.
 */
public synchronized void write(int b) throws IOException {
    if (count >= buf.length) {
        flushBuffer();
    }
    buf[count++] = (byte)b;
}

/** 将数据真正触发系统调用写入到文件中后计数器归为 0 */
private void flushBuffer() throws IOException {
    if (count > 0) {
        out.write(buf, 0, count);
        count = 0;
    }
}

在默认的情况下，缓冲输出流是以一个8KB 大小进行写入文件的，而在触发 write 方法时不是像 FileOutputStream 一样立马触发写操作的，而是先判断缓冲区字节数的大小是否超过要写入的长度，超过了立马触发系统调用 write 操作，未超过则将其存入到本地的字节数组中.

所以在使用它的时候，要计算出你本次要写入文件的大小是多少再进行构造，若小于默认的 8KB 时，你永远在文件中是看不到这些要写入的信息的，你需要手动调用 BufferFileOutputStream#flush 方法触写入操作

代码

通过以下简单的代码来使用 BufferFileOutputStream

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;

/**
 * @author vnjohn
 * @since 2023/12/18
 */
public class BufferFileIO {
    static byte[] DATA = "1234567890\n".getBytes();
    static String PATH = "/opt/io/buffer/out.txt";

    public static void main(String[] args) throws Exception {
        File file = new File(PATH);
        // 将 FileOutput 包装为 BufferedOutput
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
        while (true) {
            // 模拟业务代码执行时间
            Thread.sleep(10);
            out.write(DATA);
        }
    }
}

以默认 8KB 字节大小的批次进行写入文件，对 FileOutputStream 进行了一层包装，底层用的是它，但是在操作时使用的是 BufferedOutputStream

strace

通过在 Linux 虚拟机节点中编译以上的源码来观察内核源码的执行情况

1、javac BufferFileIO.java
2、mkdir /opt/io/buffer
3、strace 追踪：strace -ff -o buffer_out java BufferFileIO

运行以下命令后，通过 tail -f buffer_out.pid 文件，来查看它的运行轨迹，运行结果如下图：

在这里插入图片描述

可以观察到等待了很多（直到 8KB 写满）才触发系统函数：write 调用，将其写入到文件中，对比普通 I/O 写 Buffer I/O 方式在性能上以及资源的利用上减少了很多

FileOutput VS BufferFileOutput

在 Buffer 方式下写它的效率一定是会比普通 File 方式写要快很多的

因为通过以上的例子来看，它们两者的区别在用户态与内核态之间的切换次数不同：buffer < 普通 file

Buffer 在 JVM 中是先以 8KB 字节数组存储起来满了以后再调用内核写入到内存的，但是普通 File 它是每一次 write 写入都会触发一次用户态与内核态的切换

普通 File 写

write(4, "1234567890\n", 11)   = 11

Buffer 写

write(5, "1234567890\n1234567890\n1234567890"..., 8184) = 8184

ByteBuffer

ByteBuffer 是 Java NIO 中用于操作字节数据的缓冲区类之一，它提供了一种方便的方式来处理字节数据，支持读取、写入、操作和管理字节数据.

在这里插入图片描述

介绍

主要的特点和功能

  1. ByteBuffer 有固定的容量（capacity — 可容纳的字节总数）同时它还有一个位置（position — 下一个要读取或写入的位置）
  2. ByteBuffer 可以在读取模式和写入模式之间切换，在读取模式下，可以从缓冲区中读取数据；在写入模式下，它可以将数据写入缓冲区
  3. ByteBuffer 提供了许多方法用于读取和写入数据，如：get、put 等，这些方法允许你读取或写入单个字节、字符、整数、长整数、浮点数等各种数据类型
  4. ByteBuffer 支持不同的字节顺序，可以通过 order 方法来设置字节顺序，包括大端序、小端序
  5. ByteBuffer 与通道（Channel）配合使用，例如：FileChannel、SocketChannel 用于文件和网络 I/O 操作
  6. 通过 FileChannel 可以内存映射文件写入，通过 MappedByteBuffer 将文件内容映射到内存中，以便在内存中进行读写操作

ByteBuffer 类主要的方法及其简要说明，如下：

  1. allocate(int capacity)：创建一个新的字节缓冲区，其容量为指定大小的字节数，分配的是应用程序 JVM 堆空间，例如：ByteBuffer buffer = new ByteBuffer.allocate(1024);
public static ByteBuffer allocate(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    return new HeapByteBuffer(capacity, capacity);
}
  1. allocateDirect(int capacity)：创建一个新的直接字节缓冲区，其容量为指定大小的字节数，直接缓冲区将在本地内存（Native Memory）中进行分配，适用于需要高性能的场景
public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}
  1. put(byte b)：将指定的字节写入缓冲区的当前位置，例如：buffer.put((byte)65);
public final ByteBuffer put(byte[] src) {
    return put(src, 0, src.length);
}

// 会将 position 向右移动 1 字节 
public ByteBuffer put(byte[] src, int offset, int length) {
    checkBounds(offset, length, src.length);
    if (length > remaining())
        throw new BufferOverflowException();
    int end = offset + length;
    for (int i = offset; i < end; i++)
        this.put(src[i]);
    return this;
}
  1. putInt(int value)：将指定的整数按照当前的字节顺序写入到缓冲区，例如：buffer.putInt(123);
public ByteBuffer putInt(int x) {
	// position 会向右移动 4 位
    Bits.putInt(this, ix(nextPutIndex(4)), x, bigEndian);
    return this;
}
  1. get()：读取缓冲区当前位置的字节，然后将 position 向前/右移动一个字节，例如：byte b = buffer.get();
public byte get() {
	// position = p + 1;
    return hb[ix(nextGetIndex())];
}
  1. getInt()：从缓冲区的当前 position 读取四个，并根据当前字节顺序返回一个整数，例如：int value = buffer.getInt();
public int getInt() {
    return Bits.getInt(this, ix(nextGetIndex(4)), bigEndian);
}
  1. flip()：将缓冲区从写入模式切换为读取模式，该方法会将 limit 设置为当前 position，然后将 position 重置为 0
public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}
  1. compact()：调用该方法后，缓冲区的位置 position 会被设置为未读取数据的末尾，限制 limit 会被设置为容量 capacity，以便进行后续的写入操作
public ByteBuffer compact() {
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    position(remaining());
    limit(capacity());
    discardMark();
    return this;
}
  1. clear()：清空缓冲区，将 position 设置为 0，limit 设置为 capacity，准备重新写入缓冲区
public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}
  1. rewind()：将 position 设置为 0，不改变 limit，这样可以重新读取缓冲区中的数据
public final Buffer rewind() {
    position = 0;
    mark = -1;
    return this;
}

使用

import java.nio.ByteBuffer;

/**
 * @author vnjohn
 * @since 2023/12/20
 */
public class StudyByteBuffer {
    public static void main(String[] args) {
        whatByteBuffer();
    }

    public static void whatByteBuffer() {
        // JVM 堆内分配
//         ByteBuffer buffer = ByteBuffer.allocate(1024);
        // Java 进程堆内分配、JVM 堆外分配 > 直接内存-与操作系统内存交互的
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        System.out.println("position: " + buffer.position());
        System.out.println("limit: " + buffer.limit());
        System.out.println("capacity: " + buffer.capacity());
        System.out.println("mark: " + buffer);
        System.out.println("------------- put:123 -------------");
        buffer.put("123".getBytes());
        System.out.println("------------- putInt:123 -------------");
        buffer.putInt(123);
        System.out.println("mark: " + buffer);
        // 读写交替：读取之前先要 flip
        System.out.println("------------- flip -------------");
        buffer.flip();
        System.out.println("mark: " + buffer);
        // 取一个字节：position 位置向右移
        buffer.get();
        System.out.println("------------- get -------------");
        buffer.getInt();
        System.out.println("------------- getInt -------------");
        System.out.println("mark: " + buffer);
        System.out.println("------------- rewind -------------");
        buffer.rewind();
        System.out.println("mark: " + buffer);
        // 写操作：从未读取的位置开始重新写入
        System.out.println("------------- compact -------------");
        buffer.compact();
        System.out.println("mark: " + buffer);
        System.out.println("------------- clear -------------");
        buffer.clear();
        System.out.println("mark: " + buffer);
    }
}

运行 main 方法，控制台输出如下：

position: 0
limit: 1024
capacity: 1024
mark: java.nio.DirectByteBuffer[pos=0 lim=1024 cap=1024]
------------- put:123 -------------
------------- putInt:123 -------------
mark: java.nio.DirectByteBuffer[pos=7 lim=1024 cap=1024]
------------- flip -------------
mark: java.nio.DirectByteBuffer[pos=0 lim=7 cap=1024]
------------- get -------------
------------- getInt -------------
mark: java.nio.DirectByteBuffer[pos=5 lim=7 cap=1024]
------------- rewind -------------
mark: java.nio.DirectByteBuffer[pos=0 lim=7 cap=1024]
------------- compact -------------
mark: java.nio.DirectByteBuffer[pos=7 lim=1024 cap=1024]
------------- clear -------------
mark: java.nio.DirectByteBuffer[pos=0 lim=1024 cap=1024]

如何使用 ByteBuffer 操作文件

在说明使用 ByteBuffer 如何读、写、映射文件系统中的文件时，先介绍除了 ByteBuffer 之外的核心类

  1. RandomAccessFile：Java I/O 中的类，用于随机访问文件的内容，它允许在文件中读取和写入数据，支持对文件的随机访问，可以定位到读写的位置

RandomAccessFile 可以以读取和写入的模式打开文件，并允许以任意位置读取或写入数据，因此适用于需要随机访问文件内容的场景

通过 RandomAccessFile#getChannel 方法可以获取对应的 FileChannel 对象

核心方法：
1、read()、write()：从文件读取数据到缓冲区、将数据写入文件
2、seek(long position)：定位文件指针到指定位置，以进行随机访问
3、getFilePointer：获取当前文件指针的位置
4、length()：获取文件的长度
5、close()：关闭文件流

  1. FileChannel：Java NIO(java.nio.channels)中的类，提供了对文件的读写操作，但是它是在 FileChannel 上进行操作而不是直接读写文件，它是与底层操作系统的文件 I/O 操作进行交互的通道

FileChannel 支持顺序读写、随机读写、文件锁定等操作，提供了更高效的文件 I/O 操作，并可以与 MappedByteBuffer 配合使用进行数据的交互

核心方法：
1、read(ByteBuffer dst)：从通道读取数据到缓冲区
2、write(ByteBuffer src)：将缓冲区的数据写入通道
3、position(long newPosition)：设置通道为当前位置
4、size()：获取通道对应文件的大小
5、map(FileChannel.MapMode mode, long position, long size)：将文件区域映射到内存中后返回 MappedByteBuffer 对象
6、lock()、tryLock()：对文件区域进行加锁
7、close()：关闭通道

  1. MappedByteBuffer：MappedByteBuffer 是 ByteBuffer 中的一种特殊实现，通过 FileChannel#map 方法进行创建，它是直接在内存中映射文件的一部分或全部内容，允许直接在内存中对文件进行读写操作

它将文件内容映射到内存中，并且允许对映射区域进行修改，同时修改会同步更新到文件中

1、get()、put()：从缓冲区读取数据、将数据写入缓冲区
2、load()、force()：将文件内容加载到内存、将修改内容强制写入到文件中
3、isLoaded()：检查缓冲区是否已加载到内存
4、isDirect()：检查缓冲区是否是直接缓冲区

RandomAccessFile 提供了对文件的基本读写能力，FileChannel 提供了更高效的文件操作方式，而 MappedByteBuffer 允许直接在内存中对文件内容进行操作.

三者结合，天衣无缝，先打开文件->用高效的 I/O 读写方式->再以缓冲区的方式进行写

各自应用到了它们的优势

代码

import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

/**
 * @author vnjohn
 * @since 2023/12/18
 */
public class MMapFileNIO {
    static String PATH = "/opt/io/mmap/out.txt";

    public static void main(String[] args) throws Exception {
        RandomAccessFile randomAccessFile = new RandomAccessFile(PATH, "rw");
        System.out.println("-------- write --------");
        randomAccessFile.write("hello \n".getBytes());
        randomAccessFile.write("study every day\n".getBytes());
        // 偏移到指定的位置{5}后追加内容
        System.out.println("-------- seek ---------");
        randomAccessFile.seek(5);
        randomAccessFile.write("vnjohn".getBytes());
        // FileChannel 依赖于 RandomAccessFile
        FileChannel fileChannel = randomAccessFile.getChannel();
        // mmap：调用 FileChannel#map 方法映射出一块用户态->内核态之间的共享区域，分配 4KB 大小
        MappedByteBuffer map = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 4096);
        map.put("@".getBytes());
        // mmap 内存映射，仍然受内核的 page cache 体系所约束的
        System.out.println("-------- mmap#put --------");
        // 强制将对该缓冲区内容所做的任何更改写入
        // map.force();
        randomAccessFile.seek(0);
        ByteBuffer buffer = ByteBuffer.allocate(8192);
        // 随机写入完毕的文件再读入到一个给定的字节缓冲区中
        System.out.println("ByteBuffer#read：" + buffer);
        fileChannel.read(buffer);
        // 在开始读取内容时，需要调用 flip 方法归位
        buffer.flip();
        System.out.println("ByteBuffer#flip：" + buffer);
        // 读取字节缓冲区，从 0-buffer.size 这个区间的内容
        for (int i = 0; i < buffer.limit(); i++) {
            Thread.sleep(200);
            System.out.print(((char) buffer.get(i)));
        }
    }
    
}

strace

通过在 Linux 虚拟机节点中编译以上的源码来观察内核源码的执行情况

1、javac MMapFileNIO.java
2、mkdir /opt/io/mmap
3、strace 追踪：strace -ff -o mmap_out java MMapFileNIO

运行以下命令后，通过 tail -f mmap_out.pid 文件，来查看它的运行轨迹，运行结果如下图（只关注 mmap）：

在这里插入图片描述

发现 FileChannel#map 方法映射出一块用户态与内核态之间共享的内存区域，底层调用的就是 mmap 函数.

总结

该篇博文主要介绍了 FileOutputStream、BufferFileOutputStream、ByteBuffer 类的特征，简要介绍了如何使用它们进行文件与内存之间的操作，FileOutStream 每次写都会触发系统调用，BufferFileOutStream 以一个批次的方式触发系统调用，而 ByteBuffer 下有很多种实现，HeapByteBuffer 是属于 JVM 堆内的一块内存区域，DirectByteBuffer 是属于 Java 进程堆内也就是 JVM 堆外的一块内存区域，MappedByteBuffer 它是直接操作用户空间与内核空间的一块共享区域，以上的实现它们都是基于操作系统的页缓存进行操作文件及网络 I/O 的，它们在极端的情况下都会丢失数据

MappedByteBuffer 运用了 mmap 系统函数调用，实现了零拷贝次数（减少了用户态与内核态之间的切换同时也减少了上下文切换的次数）
下篇文章会具体介绍 mmap、sendfile、Direct I/O 特征以及它们在 Java 中如何进行操作

希望您能够喜欢该篇博文提供的知识点篇章，感谢三连支持❤️

🌟🌟🌟愿你我都能够在寒冬中相互取暖，互相成长，只有不断积累、沉淀自己，后面有机会自然能破冰而行！

博文放在 网络 I/O 专栏里，欢迎订阅，会持续更新！

如果觉得博文不错，关注我 vnjohn，后续会有更多实战、源码、架构干货分享！

推荐专栏：Spring、MySQL，订阅一波不再迷路

大家的「关注❤️ + 点赞👍 + 收藏⭐」就是我创作的最大动力！谢谢大家的支持，我们下文见！

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

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

相关文章

怎么选择高压放大器（高压放大器选型指南）

怎么选择高压放大器（高压放大器选型指南）

在许多科学、工程和实验应用中&#xff0c;需要对高压信号进行放大&#xff0c;以便进行测量、激励或其他各种目的。选择适当的高压放大器对于系统性能至关重要。下面将带来高压放大器选型指南的介绍&#xff0c;帮助工程师们在众多选项中做出明智的选择。 1.确定应用需求 首先…
阅读更多...
规则引擎调研情况 URule Pro、VRS和ILOG ODM

规则引擎调研情况 URule Pro、VRS和ILOG ODM

最近调研了三家公司的规则引擎产品&#xff0c;各有利弊&#xff0c;具体情况如下&#xff1a; 1. URule Pro 配置本地环境&#xff1a; Web端测试样例&#xff1a; 产品特点&#xff1a; 编程语言 Java语言 是否有Python接口 否 核心算法 3.0及之前的版本 Rete算法…
阅读更多...
应用 Strangler 模式将遗留系统分解为微服务

应用 Strangler 模式将遗留系统分解为微服务

许多来源在一般情况下提供了微服务的解释&#xff0c;但缺乏特定领域的示例。新来者或不确定从哪里开始的人可能会发现掌握如何将遗留系统过渡到微服务架构具有挑战性。本指南主要面向那些正在努力启动迁移工作的个人&#xff0c;它提供了特定于业务的示例来帮助理解该过程。 …
阅读更多...
还在用nvm？来试试更快的node版本管理工具——fnm

还在用nvm？来试试更快的node版本管理工具——fnm

前言 &#x1f4eb; 大家好&#xff0c;我是南木元元&#xff0c;热衷分享有趣实用的文章&#xff0c;希望大家多多支持&#xff0c;一起进步&#xff01; &#x1f345; 个人主页&#xff1a;南木元元 目录 什么是node版本管理 常见的node版本管理工具 fnm是什么 安装fnm …
阅读更多...
IDEA 设置 SpringBoot logback 彩色日志（附配置文件）

IDEA 设置 SpringBoot logback 彩色日志（附配置文件）

1、背景说明 最开始使用 SpringBoot 时&#xff0c;控制台日志是带彩色的&#xff0c;让人眼前一亮&#x1f604; 后来彩色莫名丢失&#xff0c;由于影响不大&#xff0c;一直没有处理。 2、配置彩色 最近找到了解决方法&#xff08;其实是因为自定义 logback.xml&#xff0…
阅读更多...
多媒体互动橱窗设计如何改变内容展示形式？

多媒体互动橱窗设计如何改变内容展示形式？

橱窗设计在展品展示中扮演着举足轻重的角色&#xff0c;它相较于传统展示形式&#xff0c;能更直观地呈现展品效果&#xff0c;而且优质的橱窗设计还能提升品牌的产品形象&#xff0c;正因此&#xff0c;也被广泛应用于企业、博物馆、店铺等场所。随着多媒体技术的蓬勃发展和行…
阅读更多...
【MATLAB第84期】基于MATLAB的波形叠加极限学习机SW-ELM代理模型的sobol全局敏感性分析法应用

【MATLAB第84期】基于MATLAB的波形叠加极限学习机SW-ELM代理模型的sobol全局敏感性分析法应用

【MATLAB第84期】基于MATLAB的波形叠加极限学习机SW-ELM代理模型的sobol全局敏感性分析法应用 前言 跟往期sobol区别&#xff1a; 1.sobol计算依赖于验证集样本&#xff0c;无需定义变量上下限。 2.SW-ELM自带激活函数&#xff0c;计算具有phi&#xff08;x&#xff09;e^x激…
阅读更多...
命令执行 [SWPUCTF 2021 新生赛]babyrce

命令执行 [SWPUCTF 2021 新生赛]babyrce

打开题目 我们看到题目说cookie值admin等于1时&#xff0c;才能包含文件 bp修改一下得到 访问rasalghul.php&#xff0c;得到 题目说如果我们get传入一个url且不为空值&#xff0c;就将我们get姿势传入的url的值赋值给ip 然后用正则过滤了 / /&#xff0c;如果ip的值没有 / …
阅读更多...
Maven将Jar包打入本地仓库

Maven将Jar包打入本地仓库

Maven将Jar包打入本地仓库 Maven将Jar包打入本地仓库嘚吧嘚下载Maven配置Maven新建MAVEN_HOME编辑Path验证Maven配置 Jar包打入Maven仓库 Maven将Jar包打入本地仓库 嘚吧嘚 最近项目用到一个Jar包&#xff0c;不能从远程仓库拉取&#xff0c;只有一个Jar包&#xff0c;所以需…
阅读更多...
BSWM 模式管理(二)ESH

BSWM 模式管理(二)ESH

BSWM 模式管理 ESH 1 ECU State Handling (ESH)2 BSWM ESH 五大模式与六大通用状态机3 状态机对应的切换条件 conditions or rules4 默认主要的 ACTION 或者 ACTION LIST1 ECU State Handling (ESH) 与 ECUM 相关，整个 ECU 状态管理的状态机制 2 BSWM ESH 五大模式与六大通…
阅读更多...
基于 Flink 的典型 ETL 场景实现方案

基于 Flink 的典型 ETL 场景实现方案

目录 1.实时数仓的相关概述 1.1 实时数仓产生背景 1.2 实时数仓架构 1.3 传统数仓 vs 实时数仓 2.基于 Flink 实现典型的 ETL 场景 2.1 维表 Join ■ 2.1.1 预加载维表 方案 1&#xff1a; 方案 2&#xff1a; ■ 2.1.2 热存储关联 ■ 2.1.3 广播维表 ■ 2.1.4 Tem…
阅读更多...
福建省大数据集团数据应用开发大赛全面升级

福建省大数据集团数据应用开发大赛全面升级

更多精彩&#xff0c;请持续关注 点击链接直达大赛官网 福建省大数据集团数据应用开发大赛 (fjbdg.com.cn)
阅读更多...
车辆违规开启远光灯检测系统：融合YOLO-MS改进YOLOv8

车辆违规开启远光灯检测系统：融合YOLO-MS改进YOLOv8

1.研究背景与意义 项目参考AAAI Association for the Advancement of Artificial Intelligence 研究背景与意义 随着社会的不断发展和交通工具的普及&#xff0c;车辆违规行为成为了一个严重的问题。其中&#xff0c;车辆违规开启远光灯是一种常见的违规行为&#xff0c;给其…
阅读更多...
DBeaver中使用外部格式化程序对进行sql格式化

DBeaver中使用外部格式化程序对进行sql格式化

本文介绍了如何在DBeaver中使用外部格式化程序对sql进行格式化。 一、pgFormatter 1.准备工作 下载地址&#xff1a;https://github.com/darold/pgFormatter/releases/ pgFormatter是perl脚本&#xff0c;所以需要perl运行环境支持。 perl下载地址&#xff1a;https://str…
阅读更多...
【力扣100】543.二叉树的直径

【力扣100】543.二叉树的直径

添加链接描述 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val0, leftNone, rightNone): # self.val val # self.left left # self.right right class Solution:def __init__(self):self.max 0def diamete…
阅读更多...
实现linux与windows进行文件共享

实现linux与windows进行文件共享

目录 一.展现形式 二.场景需求 三.具体操作 1.windows访问sumba 2.Linux访问sumba 一.展现形式 支持以文件夹的形式可视化操作文件 二.场景需求 1.有一台Linux物理机 2.有一台window物理机 3.Linux已配置好sumba服务器 三.具体操作 1.windows访问sumba 首先按下winR…
阅读更多...
PyTorch深度学习实战（26）——卷积自编码器(Convolutional Autoencoder)

PyTorch深度学习实战（26）——卷积自编码器(Convolutional Autoencoder)

PyTorch深度学习实战&#xff08;26&#xff09;——卷积自编码器 0. 前言1. 卷积自编码器2. 使用 t-SNE 对相似图像进行分组小结系列链接 0. 前言 我们已经学习了自编码器 (AutoEncoder) 的原理&#xff0c;并使用 PyTorch 搭建了全连接自编码器&#xff0c;但我们使用的数据…
阅读更多...
【C++初阶】第一站：C++入门基础(下)

【C++初阶】第一站：C++入门基础(下)

前言&#xff1a; 紧接着上两篇文章&#xff0c;c入门基础(上)&#xff1a;C入门基础(上) c入门基础(中)&#xff1a;C入门基础(中) 继续补充完c初阶入门基础的知识点&#xff0c;本章知识点包括&#xff1a; 引用和指针的区别、内联函数、auto关键字(C11)、基于范围的for循环…
阅读更多...
企业在什么场景下使用Windows活动目录？

企业在什么场景下使用Windows活动目录？

Windows活动目录是微软提供的一种集中式身份验证和访问控制服务&#xff0c;它具有许多功能和优势&#xff0c;因此在很多企业中被广泛使用。那么&#xff0c;企业在什么场景下会选择使用Windows活动目录呢&#xff1f; 首先&#xff0c;Windows活动目录适用于中大型企业或组织…
阅读更多...
JavaWeb笔记之前端开发JavaScript

JavaWeb笔记之前端开发JavaScript

一、引言 1.1 简介 JavaScript一种解释性脚本语言&#xff0c;是一种动态类型、弱类型、基于原型继承的语言&#xff0c;内置支持类型。 它的解释器被称为JavaScript引擎&#xff0c;作为浏览器的一部分&#xff0c;广泛用于客户端的脚本语言&#xff0c;用来给HTML网页增加…
阅读更多...
最新文章

Copyright @ 2022~2023