1.记一次源码追踪分析，从Java到JNI，再到JVM的C++：fileChannel.map()为什么快；源码分析map方法，put方法
2.深入浅出 Java FileChannel 的堆外内存使用
3.架构师必知必会：Java内置的控制反转机制”Service Provider”
4.Java的并行世界-Netty中线程模型源码讲解-续集Handler、Channel
5.Java教程：dubbo源码解析-网络通信
6.I/O 简要分析

记一次源码追踪分析，从Java到JNI，asp表单提交 源码再到JVM的C++：fileChannel.map()为什么快；源码分析map方法，put方法

       前言

       在系统IO相关的系统调用有read/write，mmap，sendfile等这些。

       其中read/write是普通的读写，每次都需要将buffer从用户空间拷贝到内核空间；

       而mmap使用的是内存映射，会将磁盘文件对应的页映射（拷贝）到内核空间的page cache，并记录到用户进程的页表中，使得用户空间也可以像操作用户空间一样操作该文件的映射，最后再由操作系统来讲该映射（脏页）回写到磁盘；

       sendfile则使用的是零拷贝技术，在mmap的基础上，当发送数据的时候只拷贝fd和offset等元数据信息，而将数据主体直接拷贝至protocol buffer，实现了内核数据零冗余的零拷贝技术

       本文地址：/post//

问题/目的问题1Java中哪些API使用到了mmap问题2怎么知道该API使用到了mmap，如何追踪程序的系统调用目的1源码中分析验证，从Java到JNI，再到C++：fileChannel.map()使用的是系统调用mmap目的2源码验证分析：调用mmapedByteBuffer.put(Byte[])时JVM在搞些什么？mmap比普通的read/write快在哪？揭晓答案1mmap在Java NIO中的体现/使用

       看一个例子

// 1GBpublic static final int _GB = 1**;File file = new File("filename");FileChannel fileChannel = new RandomAccessFile(file, "rw").getChannel();MappedByteBuffer mmapedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, _GB);for (int i = 0; i < _GB; i++) { count++;mmapedByteBuffer.put((byte)0);}

       其中fileChannel.map()底层使用的就是系统调用mmap，函数签名为： public abstract MappedByteBuffer map(MapMode mode,long position, long size)throws IOException

答案2程序执行的系统调用追踪/** * @author Tptogiar * @description * @date /5/ - : */public class TestMappedByteBuffer{ public static final int _4kb = 4*;public static final int _GB= 1**;public static void main(String[] args) throws IOException, InterruptedException { // 为了方便在日志中找到本段代码的开始位置和结束位置，这里利用文件io来打开始标记FileInputStream startInput = null;try { startInput = new FileInputStream("start1.txt");startInput.read();} catch (IOException e) { e.printStackTrace();}File file = new File("filename");FileChannel fileChannel = new RandomAccessFile(file, "rw").getChannel();MappedByteBuffer map = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, _GB); //我们想分析的语句问题2for (int i = 0; i < _GB; i++) { map.put((byte)0); // 下文中需要分析的语句目的2}// 打结束标记FileInputStream endInput = null;try { endInput = new FileInputStream("end.txt");endInput.read();} catch (IOException e) { e.printStackTrace();}}}

       把上面这段代码编译后把“.class”文件拉到linux执行，并用linux上的strace工具记录其系统调用日志，拿到日志文件我们可以在日志中看到以下信息（关于怎么拿到日志可以参照我的博文：无（代写））：

       注：日志有多行，这里只选取我们关注的

// ...// 看到了我们打的开始标志openat(AT_FDCWD, "start1.txt", O_RDONLY) = -1 ENOENT (No such file or directory)// ... // 打开文件，文件描述符fd为6openat(AT_FDCWD, "filename", O_RDWR|O_CREAT, ) = 6// 判断文件状态fstat(6, { st_mode=S_IFREG|, st_size=, ...}) = 0// ... // 判断文件状态fstat(6, { st_mode=S_IFREG|, st_size=, ...}) = 0// 进行内存映射mmap(NULL, , PROT_READ|PROT_WRITE, MAP_SHARED, 6, 0) = 0x7f2fd6cd// ...// 程序退出exit(0)// 看到了我们打的结束标志openat(AT_FDCWD, "end.txt", O_RDONLY) = -1 ENOENT (No such file or directory)

       在上面程序的系统调用日志中我们确实看到了我们打的开始标志，结束标志。在开始标志和结束标志之间我们看到了我们的文件"filename"确实被打开了，文件描述符fd = 6；在打开文件后紧接着又执行了系统调用mmap，这一点我们Java代码一致，这样，我们就验证了我们答案1中的结论，可以开始我们的下文了

源码追踪分析，从Java到JNI，再到JVM的直播软件源码红豆C++目的1寻源之旅：fileChannel.map()

       我们知道我们执行Java代码fileChannel.map()确实会在底层调用系统调用，那怎么在源码中得到验证呢？怎么落脚于源码进行分析呢？下面开始我们的寻源之旅

       FileChannelImpl.map() 注：由于代码较长，这里代码中略去了一些我们不关注的,比如异常捕获等

public MappedByteBuffer map(MapMode mode, long position, long size)throws IOException{ // ...try { // ...synchronized (positionLock) { // ...long mapPosition = position - pagePosition;mapSize = size + pagePosition;try { // ！我们要找的语句就在这！addr = map0(imode, mapPosition, mapSize);} catch (OutOfMemoryError x) { // 如果内存不足，先尝试进行GCSystem.gc();try { Thread.sleep();} catch (InterruptedException y) { Thread.currentThread().interrupt();}try { // 再次试着mmapaddr = map0(imode, mapPosition, mapSize);} catch (OutOfMemoryError y) { // After a second OOME, failthrow new IOException("Map failed", y);}}} // ...} finally { // ...}}

       上面函数源码中真正执行mmap的语句是在addr = map0(imode, mapPosition, mapSize),于是我们寻着这里继续追踪

       FileChannelImpl.map0()

// Creates a new mappingprivate native long map0(int prot, long position, long length)throws IOException;

       可以看到，该方法是一个native方法，所以后面的源码我们需要到这个FileChannelImpl.class对应的fileChannelImpl.c中去看，所以我们需要去找到JDK的源码

       在JDK源码中我们找到fileChannelImpl.c文件

       fileChannelImpl.c 根据JNI的对应规则，我们找到该文件内对应的Java_sun_nio_ch_FileChannelImpl_map0方法，其源码如下：

JNIEXPORT jlong JNICALLJava_sun_nio_ch_FileChannelImpl_map0(JNIEnv *env, jobject this, jint prot, jlong off, jlong len){ void *mapAddress = 0;jobject fdo = (*env)->GetObjectField(env, this, chan_fd);jint fd = fdval(env, fdo);int protections = 0;int flags = 0;if (prot == sun_nio_ch_FileChannelImpl_MAP_RO) { protections = PROT_READ;flags = MAP_SHARED;} else if (prot == sun_nio_ch_FileChannelImpl_MAP_RW) { protections = PROT_WRITE | PROT_READ;flags = MAP_SHARED;} else if (prot == sun_nio_ch_FileChannelImpl_MAP_PV) { protections =PROT_WRITE | PROT_READ;flags = MAP_PRIVATE;}// ！我们要找的语句就在这里！mapAddress = mmap(0,/* Let OS decide location */len,/* Number of bytes to map */protections,/* File permissions */flags,/* Changes are shared */fd, /* File descriptor of mapped file */off); /* Offset into file */if (mapAddress == MAP_FAILED) { if (errno == ENOMEM) { JNU_ThrowOutOfMemoryError(env, "Map failed");return IOS_THROWN;}return handle(env, -1, "Map failed");}return ((jlong) (unsigned long) mapAddress);}

       我们要找的语句就上面代码中的mapAddress = mmap(0,len,protections,flags,fd,off),至于为什么不是直接的mmap，而是mmap，是因为这里的mmap是一个宏，在文件上方有其定义，如下：

#define mmap mmap

       至此，我们就在源码中得到验证了我们问题2中的结论：fileChannelImpl.map()底层使用的是mmap系统调用

目的2寻源之旅：mmapedByteBuffer.put(Byte[ ])

       接着我们来看看当我们调用mmapedByteBuffer.put(Byte[])JVM底层在搞些什么动作

       MappedByteBuffer ?首先我们得知道，当我们执行MappedByteBuffer map = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, _GB)时，实际返回的对象是DirectByteBuffer类的实例，因为MappedByteBuffer为抽象类，且只有DirectByteBuffer继承了它，看下面两图就明白了

       DirectByteBuffer 于是我们找到DirectByteBuffer内的put(Byte[ ])方法

public ByteBuffer put(byte x) { unsafe.putByte(ix(nextPutIndex()), ((x)));return this;}

       可以看到该方法内实际是调用Unsafe类内的putByte方法来实现功能的，所以我们还得去看Unsafe类

       Unsafe.class

public native voidputByte(long address, byte x);

       该方法在Unsafe内是一个native方法，所以所以我们还得去看unsafe.cpp文件内对应的实现

       unsafe.cpp

       在JDK源码中，我们找到unsafe.cpp

       在这份源码内，没有使用JNI内普通加前缀的方法来形成对应关系

       不过我们还是能顺着源码的蛛丝轨迹找到我们要找的方法

       注意到源码中有这样的注册机制，所以我们可以知道我们要找的代码就是上图中标注的代码

       顺藤摸瓜，我们就找到了该方法的定义

UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \UnsafeWrapper("Unsafe_SetNative"#Type); \JavaThread* t = JavaThread::current(); \t->set_doing_unsafe_access(true); \void* p = addr_from_java(addr); \*(volatile native_type*)p = x; \t->set_doing_unsafe_access(false); \UNSAFE_END \

       该方法内主要的逻辑语句就是以下两句：

/** * @author Tptogiar * @description * @date /5/ - : */public class TestMappedByteBuffer{ public static final int _4kb = 4*;public static final int _GB= 1**;public static void main(String[] args) throws IOException, InterruptedException { // 为了方便在日志中找到本段代码的开始位置和结束位置，这里利用文件io来打开始标记FileInputStream startInput = null;try { startInput = new FileInputStream("start1.txt");startInput.read();} catch (IOException e) { e.printStackTrace();}File file = new File("filename");FileChannel fileChannel = new RandomAccessFile(file, "rw").getChannel();MappedByteBuffer map = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, _GB); //我们想分析的语句问题2for (int i = 0; i < _GB; i++) { map.put((byte)0); // 下文中需要分析的语句目的2}// 打结束标记FileInputStream endInput = null;try { endInput = new FileInputStream("end.txt");endInput.read();} catch (IOException e) { e.printStackTrace();}}}0

       至此，我们就知道：其实我们调用mmapedByteBuffer.put(Byte[ ])时，JVM底层并不需要涉及到系统调用（这里也可以用strace工具追踪从而得到验证）。也就是说通过mmap映射的空间在内核空间和用户空间是共享的，我们在用户空间只需要像平时使用用户空间那样就行了————获取地址，设置值，而不涉及用户态，内核态的切换

总结

       fileChannelImpl.map()底层用调用系统函数mmap

       fileChannelImpl.map()返回的其实不是MappedByteBuffer类对象，而是海东青冰源码DirectByteBuffer类对象

       在linux上可以通过strace来追踪系统调用

       JNI中“.class”文件内方法与“.cpp”文件内函数的对应关系不止是前缀对应的方法，还可以是注册的方式，这一点的追寻代码的时候有很大帮助

       directByteBuffer.put()方法底层并没有涉及系统调用，也就不需要涉及切态的性能开销(其底层知识执行获取地址，设置值的操作)，所以mmap的性能就比普通读写read/write好

       ...

原文：/post/

深入浅出 Java FileChannel 的堆外内存使用

       从一个线上系统 OOM 讲起，我们通过解决用户反馈的 IoTDB 查询卡住问题，深入探讨了 Java FileChannel 中的堆外内存使用。

       首先，让我们了解一下背景知识。FileChannel 是 Java NIO 提供的文件通道类，它允许对文件进行读写操作。而堆外内存是指直接分配在系统内存中的内存区域，不受 Java 堆管理。

       FileChannel 使用堆外内存的原因是提高性能。当使用 DirectByteBuffer 时，数据本来就在堆外内存中，因此在进行 I/O 操作时没有拷贝的过程，这被称为“零拷贝”。然而，操作系统需要将堆上的数据拷贝到堆外内存中进行 I/O 操作，因为操作系统通过内存地址进行数据交互。

       当 JVM 进行垃圾回收（GC）时，可能会导致内存地址的变化，影响正在执行的 I/O 操作。因此，将数据从堆复制到堆外内存，可以保证数据地址在 I/O 过程中保持不变。

       在 JDK 的源码分析中，我们发现 DirectByteBuffer 的分配和回收机制。DirectByteBuffer 在分配时创建的 Cleaner 对象用于堆外内存的回收，当 DirectByteBuffer 仅被 Cleaner 引用时，其可以在任意 GC 时段被回收。这样，虽然堆外内存并非完全不受 GC 控制，但通过 Cleaner 实现了有效的回收机制。

       FileChannel 在读写过程中，使用 DirectByteBuffer 进行数据操作。萍乡崇源码头在分配和回收临时 DirectByteBuffer 时，考虑到系统的资源限制，适当调整 TEMP_BUF_POOL_SIZE 的值可以避免 OOM 的问题。

       回到开头提到的线上问题，用户在使用 IoTDB 时遭遇 OOM。通过源码分析，我们发现没有适当配置 MAX_CACHED_BUFFER_SIZE，导致额外分配的堆外内存缓存过大，最终引发 OOM。通过调整配置，解决了这个问题。

       Java FileChannel 的堆外内存使用，提高了 I/O 操作的性能，但也需要合理配置和管理，避免资源浪费和内存泄露，确保系统的稳定运行。

架构师必知必会：Java内置的控制反转机制”Service Provider”

       Java在服务器编程领域持续主导，Spring框架以其基于控制反转（IoC）的思想，为依赖注入提供了强大的解决方案。然而，在某些特定场景下，如跨平台（如Android和服务端）组件组装或跨JVM语言集成，我们可能希望代码具有更低的依赖性，以适应更广泛的场景。从Java 6开始，Java内置了一套依赖注入的标准——“Service Provider”机制，以及相应的工具“ServiceLoader”，实现了控制反转的自定义实现。这一机制在JDK扩展设计中扮演着重要角色，如脚本引擎（ScriptEngine）、字符集（Charset）、文件系统（FileSystems）、网络通讯（NIO）等，被广泛应用。随着Java 9的发布，对“Service Provider”机制进行了进一步的扩展，使之适应了Java模块化的狼图腾指标源码需求。因此，掌握“Service Provider”机制成为Java架构师不可或缺的知识之一。

       本文将引导读者通过JDK文档和源码探索“Service Provider”机制，学习如何使用Java内置能力实现动态依赖注入，或者按照Java标准扩展JDK、日志、HTTP服务的能力。

       “Service Provider”机制作为Javase的一部分，遵循着一套严格的标准定义，其核心内容包括了服务发布文件路径前缀、使用类加载器查找服务提供者文件、加载服务提供者类并创建服务提供者实例等关键步骤。通过“ServiceLoader.load()”方法，我们可以创建指定类型的“Service Provider”迭代器，通过遍历迭代器获取所有服务提供者的实例。这个过程涉及到了路径的解析、类的加载以及实例的创建，确保了服务提供者必须具有无参构造函数以便于创建实例。

       “Service Provider”机制在Web应用安全隔离中也发挥了重要作用，例如在实现Servlet3.0标准的“ServletContainerInitializer”应用自启动机制中，Tomcat采用了一套遵循“Service Provider”标准的服务查找实现“WebappServiceLoader”，这一实现与标准“ServiceLoader”有所区别，主要在于查找服务提供者文件的位置不同。

       “Service Provider”机制不仅扩展了JDK已有服务，如脚本引擎、字符集、文件系统、网络通讯等，还成为了扩展这些服务的标准选择。以脚本引擎ScriptEngine为例，Java内置了NashornScriptEngine支持直接解析和运行JavaScript脚本。通过“Service Provider”机制，我们可以轻松扩展ScriptEngine，支持其他脚本语言，如Python。ScriptEngineManager正是通过“ServiceLoader.load()”方法来发现所有脚本引擎实现，以实现动态加载。

       Servlet3.0的设计中，“ServletContainerInitializer”提供者通过“Service Provider”机制被发现并创建实例，进而触发用户自定义的初始化过程。例如，在Tomcat的源码中，`ContextConfig`和`StandardContext`类实现了这一机制，用于初始化Web应用。日志框架logback和Spring框架都利用了Servlet3.0的这一机制来初始化日志实现和Bean与服务提供者的集成，而Spring-Boot则进一步实现了Web应用拉起工具基类`SpringBootServletInitializer`，使得在Servlet容器中轻松启动Spring应用成为可能。最新版本的日志外观slf4j2.0和Logback1.3也采用“Service Provider”机制来加载日志实现。

       “Service Provider”机制的重要性体现在众多知名开源软件中的重视上，它不仅影响了开源软件的发展方向，而且对于想要为开源软件贡献代码，或者设计可扩展组件的架构师来说，掌握“Service Provider”机制是必不可少的技能。

Java的并行世界-Netty中线程模型源码讲解-续集Handler、Channel

       Netty 的核心组件 ChannelHandler 在网络应用中扮演着关键角色，它处理各种事件和数据，实现业务逻辑。ChannelHandler 子类众多，根据功能可分为特殊Handler（如Context对象）、出入站Handler，以及用于协议解析和编码的Decoder和Encoder。例如，ChannelInboundHandlerAdapter 和 ChannelOutboundHandlerAdapter 分别用于处理入站和出站事件，ByteToMessageDecoder 和 MessageToByteEncoder 则负责数据的解码和编码。

       特殊Handler如ChannelHandlerContext 提供了处理器与Channel交互的上下文，而ChannelDuplexHandler 则用于双向通信，如聊天服务器。SimpleChannelInboundHandler 是简化版的入站处理器，自动管理消息引用，避免内存泄漏。而出站处理器如SimpleChannelOutboundHandler 则在消息处理后自动释放引用，简化编码流程。

       Channel 是数据传输的抽象，NioServerSocketChannel 和 EpollServerSocketChannel 分别对应基于NIO和Epoll的服务器端套接字。ChannelInitializer 是初始化新Channel的关键，它配置处理器形成处理链，用于处理连接操作和事件，从而实现自定义业务逻辑。

       通过理解这些概念和类的作用，可以构建和配置Netty应用，以满足不同的网络通信需求。想要深入学习，可以研究Netty 4.1源码中如EventLoopGroup、ChannelPipeline、CustomChannelInitializer等核心类。后续会分享详细的中文注释版本，持续关注以获取更多资源和知识。

Java教程：dubbo源码解析-网络通信

       在之前的内容中，我们探讨了消费者端服务发现与提供者端服务暴露的相关内容，同时了解到消费者端通过内置的负载均衡算法获取合适的调用invoker进行远程调用。接下来，我们聚焦于远程调用过程，即网络通信的细节。

       网络通信位于Remoting模块中，支持多种通信协议，包括但不限于：dubbo协议、rmi协议、hessian协议、ty进行网络通讯，NettyClient.doOpen()方法中可以看到Netty的相关类。序列化接口包括但不限于：Serialization接口、Hessian2Serialization接口、Kryo接口、FST接口等。

       序列化方式如Kryo和FST，性能往往优于hessian2，能够显著提高序列化性能。这些高效Java序列化方式的引入，可以优化Dubbo的序列化过程。

       在配置Dubbo RPC时，引入Kryo和FST非常简单，只需在RPC的XML配置中添加相应的属性即可。

       关于服务消费方发送请求，Dubbo框架定义了私有的RPC协议，消息头和消息体分别用于存储元信息和具体调用消息。消息头包括魔数、数据包类型、消息体长度等。消息体包含调用消息，如方法名称、参数列表等。请求编码和解码过程涉及编解码器的使用，编码过程包括消息头的写入、序列化数据的存储以及长度的写入。解码过程则涉及消息头的读取、序列化数据的解析以及调用方法名、参数等信息的提取。

       提供方接收请求后，服务调用过程包含请求解码、调用服务以及返回结果。解码过程在NettyHandler中完成，通过ChannelEventRunnable和DecodeHandler进一步处理请求。服务调用完成后，通过Invoker的invoke方法调用服务逻辑。响应数据的编码与请求数据编码过程类似，涉及数据包的构造与发送。

       服务消费方接收调用结果后，首先进行响应数据解码，获得Response对象，并传递给下一个处理器NettyHandler。处理后，响应数据被派发到线程池中，此过程与服务提供方接收请求的过程类似。

       在异步通信场景中，Dubbo在通信层面为异步操作，通信线程不会等待结果返回。默认情况下，RPC调用被视为同步操作。Dubbo通过CompletableFuture实现了异步转同步操作，通过设置异步返回结果并使用CompletableFuture的get()方法等待完成。

       对于异步多线程数据一致性问题，Dubbo使用编号将响应对象与Future对象关联，确保每个响应对象被正确传递到相应的Future对象。通过在创建Future时传入Request对象，可以获取调用编号并建立映射关系。线程池中的线程根据Response对象中的调用编号找到对应的Future对象，将响应结果设置到Future对象中，供用户线程获取。

       为了检测Client端与Server端的连通性，Dubbo采用双向心跳机制。HeaderExchangeClient初始化时，开启两个定时任务：发送心跳请求和处理重连与断连。心跳检测定时任务HeartbeatTimerTask确保连接空闲时向对端发送心跳包，而ReconnectTimerTask则负责检测连接状态，当判定为超时后，客户端选择重连，服务端采取断开连接的措施。

I/O 简要分析

       本文将从文件IO、网络IO和Java IO接口三个方面来分析IO操作。

       一、文件IO

       一般情况下，我们通过调用read/write接口来进行IO操作，这种操作被称为标准IO，其会先经过页面缓存提高性能。直接IO则会直接作用到磁盘，优点是减少数据拷贝和系统调用消耗，降低CPU使用率和内存占用。还有一种mmap方法，即将文件或对象映射到进程地址空间，减少一次数据拷贝和系统调用。

       二、网络IO

       网络IO由Linux内核统一处理，包括socket读写、数据准备和数据复制两个阶段。网络IO模型包括同步阻塞、同步非阻塞、多路复用、信号驱动和异步IO。同步阻塞IO导致进程阻塞直到数据准备好。同步非阻塞IO则允许进程在等待数据时执行其他操作。多路复用IO则允许同时监听多个连接。信号驱动IO允许在数据准备时发送信号，而异步IO允许在调用后直接获得结果。

       三、Java IO接口

       Java IO接口包括BIO（同步阻塞IO）、NIO（同步非阻塞IO）、AIO（异步非阻塞IO）和Okio。BIO使用InputStream/OutputStream进行IO操作，NIO基于多路复用原理，使用channel、selector和Buffer处理多个连接。AIO在NIO基础上实现数据准备和拷贝的异步操作。Okio是Java IO的封装和优化，提供Sink、Source、TimeOut和Segment等核心类简化IO操作。

       总的来说，通过文件IO、网络IO和Java IO接口的不同模型，我们可以实现高效且灵活的IO操作。不同场景下选择合适的IO模型能够显著提高程序性能和效率。对于Okio的具体使用和详细架构，读者可以进一步探索其源码以深入了解。