RocketMQ MappedFile设计思路

请说说RocketMQ的MappedFile设计思路

RocketMQ是一款分布式消息队列，它具有高性能、高可用和高可靠性。为了实现高性能的消息存储，RocketMQ采用了映射文件（MappedFile）来存储消息。MappedFile是RocketMQ中重要的设计思路之一，主要有以下几点：

1. 利用内存映射文件（Memory Mapped File）：MappedFile实际上是对内存映射文件（Memory Mapped File）的封装。内存映射文件是将磁盘上的文件直接映射到内存地址空间，这样读写文件就可以直接通过内存地址进行，避免了磁盘IO的性能瓶颈。这种设计大大提高了RocketMQ的消息存储性能。

2. 顺序写：RocketMQ的消息存储采用了顺序写的策略，这样可以充分利用磁盘的顺序写性能。同时，顺序写还可以避免磁盘碎片的产生，从而保持磁盘的高性能。

3. 预分配文件空间：为了提高文件写入性能，RocketMQ在创建MappedFile时，会预先分配一定大小的文件空间。这样写入消息时就不需要不断地进行文件空间的扩展，从而提高了写入性能。

4. 异步刷盘：RocketMQ支持异步刷盘，即将内存中的数据异步地写入磁盘。这样可以进一步提高写入性能，同时保证了消息的持久化。

5. 引用计数与回收：为了及时回收不再使用的MappedFile，RocketMQ使用了引用计数的机制。当引用计数为0时，对应的MappedFile会被回收，从而释放内存资源。

内存映射文件的工作原理

内存映射文件（Memory Mapped File）是一种将磁盘上的文件直接映射到内存地址空间的技术。它允许程序以访问内存的方式来操作磁盘上的文件，从而提高文件读写性能。以下是内存映射文件的工作原理：

1. 文件映射：操作系统会将磁盘上的文件映射到虚拟内存地址空间，这样程序可以直接通过内存地址访问文件。映射过程中，操作系统会将文件按照固定大小的页（page）进行划分，并将这些页映射到虚拟内存地址空间。这种映射关系是逻辑上的，实际上文件内容仍然存储在磁盘上。

2. 读取文件：当程序通过内存地址访问文件时，操作系统会检查对应的虚拟内存页是否已经加载到物理内存中。如果已经加载，程序就可以直接读取内存中的数据；如果没有加载，操作系统会触发一个缺页中断（page fault），并将磁盘上的文件内容加载到物理内存中，然后程序再访问内存地址来读取文件内容。这个过程被称为按需加载（demand paging），即只有在程序实际访问文件内容时才加载到内存中。

3. 写入文件：当程序通过内存地址修改文件内容时，操作系统会将对应的内存页标记为“脏”（dirty）。这表示内存中的数据已经被修改，需要将数据写回磁盘。操作系统会在适当的时机将脏页写回磁盘，从而实现文件的持久化。这个过程称为写回（write-back）。

4. 优势与局限：内存映射文件的优势在于提供了一种简单、高效的访问文件的方法。由于程序可以直接通过内存地址访问文件，避免了传统的磁盘IO操作，从而显著提高了文件读写性能。同时，由于内存映射文件使用了操作系统的虚拟内存管理和缓存机制，可以实现按需加载和写回，进一步提高性能。然而，内存映射文件也有一定的局限性，如地址空间的大小受到操作系统的限制，因此对于非常大的文件可能无法完整映射到内存中。

操作系统的虚拟内存管理

虚拟内存管理是操作系统中的一种内存管理技术，它允许程序拥有独立的、连续的地址空间，并将这些地址空间映射到物理内存和磁盘上的存储资源。虚拟内存管理为程序提供了连续、一致的内存地址空间，从而简化了程序的编写和执行。以下是虚拟内存管理的主要组成部分和工作原理：

1. 地址空间：操作系统为每个程序提供了一套完整的、独立的虚拟地址空间。程序在运行时使用的所有内存地址都属于这个虚拟地址空间。虚拟地址空间的大小通常远大于物理内存的大小，从而使程序可以访问更多的内存资源。

2. 页表：为了实现虚拟地址到物理地址的映射，操作系统引入了页表的概念。页表是一种数据结构，用于存储虚拟地址与物理地址之间的映射关系。操作系统为每个程序分配一个页表，并负责维护和更新页表中的映射关系。

3. 分页：虚拟内存管理采用了分页技术，将虚拟地址空间和物理内存分为大小相等的页（page）。这些页是虚拟内存管理的基本单位，用于存储程序的代码、数据和堆栈等信息。虚拟地址由页号和页内偏移量组成，通过查找页表可以找到对应的物理地址。

4. 按需加载：虚拟内存管理允许程序只加载部分代码和数据到物理内存中，而不是一次性加载所有内容。当程序访问一个尚未加载到内存的虚拟地址时，操作系统会触发一个缺页中断（page fault）。在处理缺页中断时，操作系统会分配一个物理内存页，并将磁盘上的数据加载到这个页中，然后更新页表中的映射关系。这种按需加载策略可以有效地节省内存资源，提高程序的执行效率。

5. 页面置换：当物理内存不足以分配新的一页时，操作系统会执行页面置换算法（如LRU、FIFO等）来选择一个物理内存页进行回收。需要注意的是，在选择回收的物理内存页时，操作系统会考虑这个页的使用情况，如是否被修改（脏页）。如果这个页被修改过，操作系统需要将其写回磁盘，然后才能回收这个页。

6. 内存保护：虚拟内存管理还提供了内存保护功能，确保一个程序不能访问另一个程序的内存空间。这是通过在页表中为每个页设置访问权限（如读、写、执行等）来实现的。当程序试图访问一个没有权限的页时，操作系统会触发一个保护中断（protection fault），从而保护其他程序的内存空间不被非法访问。

操作系统会为Java程序分配独立的虚拟地址空间吗

是的，操作系统会为每个运行的Java程序分配独立的虚拟地址空间。实际上，操作系统为每个运行的进程（无论是Java程序还是其他程序）都分配了一个独立的虚拟地址空间。

当你运行一个Java程序时，Java虚拟机（JVM）实际上是作为一个独立的进程运行在操作系统上。操作系统会为JVM分配一个独立的虚拟地址空间，Java程序的代码、数据和堆栈等信息都存储在这个虚拟地址空间里。

在Java程序运行期间，JVM会负责管理这个虚拟地址空间，如分配和回收内存等。JVM与操作系统之间的内存管理是协同工作的，JVM会根据程序的实际需求从操作系统申请内存资源，并在不再需要内存时将其归还给操作系统。

所以，操作系统确实会为每个运行的Java程序（实际上是为JVM进程）分配独立的虚拟地址空间。这样可以确保每个Java程序在一个独立、隔离的内存环境中运行，避免了程序之间的内存访问冲突。

请结合RocketMQ的MappedFile代码，说明MappedFile是如何使用内存映射文件机制的

RocketMQ中的MappedFile是对内存映射文件（Memory Mapped File）机制的封装，主要用于高性能地读写磁盘文件。以下结合RocketMQ的MappedFile代码，说明MappedFile是如何使用内存映射文件机制的：

1. 创建内存映射文件：在MappedFile的构造函数中，会创建一个磁盘文件，并调用initMappedByteBuffer方法初始化内存映射文件。这个方法使用FileChannel的map方法来创建内存映射文件，将磁盘文件映射到虚拟内存地址空间。

   public MappedFile(final String fileName, final int fileSize) {
     // ...
     this.mappedByteBuffer = initMappedByteBuffer(fileSize);
   }
   
   private MappedByteBuffer initMappedByteBuffer(final int fileSize) throws IOException {
     FileChannel fileChannel = this.file.getChannel();
     MappedByteBuffer mappedByteBuffer = fileChannel.map(MapMode.READ_WRITE, 0, fileSize);
     return mappedByteBuffer;
   }
   

2. 写入数据：MappedFile中的appendMessage方法用于写入数据。这个方法接收一个字节数组作为参数，并将其写入内存映射文件。由于内存映射文件实际上是直接映射到虚拟内存地址空间，因此写入数据时只需将字节数组复制到内存映射文件对应的地址即可。这样就避免了传统的磁盘IO操作，提高了写入性能。

   public AppendMessageResult appendMessage(final byte[] msgData) {
     // ...
     this.mappedByteBuffer.put(msgData);
     // ...
   }
   

3. 读取数据：MappedFile中的selectMappedBuffer方法用于读取数据。这个方法根据给定的文件位置创建一个ByteBuffer，并将内存映射文件的内容复制到这个ByteBuffer中。由于内存映射文件直接映射到虚拟内存地址空间，因此读取数据时只需将内存映射文件的内容复制到ByteBuffer即可。这样就避免了传统的磁盘IO操作，提高了读取性能。

   public SelectMappedBufferResult selectMappedBuffer(int pos) {
     // ...
     ByteBuffer byteBuffer = this.mappedByteBuffer.slice();
     byteBuffer.position(pos);
     // ...
   }
   

4. 刷盘：MappedFile中的flush方法用于将内存映射文件的内容刷盘。这个方法使用MappedByteBuffer的force方法来强制将内存中的数据写入磁盘。这样可以确保内存映射文件的内容在程序退出或系统崩溃时能够持久化。

   public int flush(final int flushLeastPages) {
     // ...
     this.mappedByteBuffer.force();
     // ...
   }
   

   内存映射文件映射的是堆内内存还是堆外内存

内存映射文件映射的是堆外内存。当我们使用内存映射文件时，磁盘上的数据会被映射到操作系统管理的虚拟内存地址空间，而不是Java堆内存中。这意味着在使用内存映射文件时，我们实际上是在操作堆外内存。

这种设计有以下几个优点：

1. 避免了额外的内存拷贝：当我们从磁盘文件读取数据时，如果不使用内存映射文件，数据需要先从磁盘读取到操作系统的缓冲区，然后再从缓冲区拷贝到Java堆内存中。利用内存映射文件可以直接让Java程序访问操作系统的缓冲区，从而避免了额外的内存拷贝操作。

2. 提高内存利用率：内存映射文件使用操作系统的虚拟内存管理和按需加载策略，因此只有在实际访问文件内容时才会将数据加载到物理内存中。这种按需加载策略可以有效地提高内存的利用率。

3. 避免了Java堆内存的压力：由于内存映射文件使用的是堆外内存，因此它不会影响Java堆内存的分配和回收。这样可以避免在处理大量文件时对Java堆内存造成压力，从而提高程序的性能。

Java程序使用堆外内存有限制吗

Java程序使用堆外内存（即直接内存）通常是有限制的。这个限制取决于JVM参数-XX:MaxDirectMemorySize的设置。默认情况下，Java虚拟机的直接内存大小等于堆内存大小。例如，如果堆内存大小设置为1GB（-Xmx1g），那么直接内存大小也将默认为1GB。当然，可以使用-XX:MaxDirectMemorySize参数设置一个自定义的直接内存大小。

在Java程序中，可以通过java.nio.ByteBuffer的allocateDirect方法来分配直接内存。分配的直接内存不受Java垃圾收集器的管理，因此在使用直接内存时需要注意内存泄露的问题。为避免内存泄漏，可以使用java.nio.ByteBuffer的cleaner方法（JDK 8及以下版本）或者引用计数等技术来确保及时释放不再使用的直接内存。

需要注意的是，如果Java程序分配的直接内存超过JVM参数-XX:MaxDirectMemorySize设置的大小，将抛出OutOfMemoryError异常。因此，在使用直接内存时需要确保程序分配的直接内存不超过JVM设置的限制。

总之，Java程序使用堆外内存是受到限制的，这个限制由JVM参数-XX:MaxDirectMemorySize设置。在使用直接内存时，需要注意内存泄漏问题并确保分配的直接内存不超过JVM设置的限制。

RocketMQ的MappedFile如何使用引用计数管理堆外内存

RocketMQ的MappedFile使用引用计数机制来管理堆外内存，确保不再使用的堆外内存可以被及时释放。以下是MappedFile如何使用引用计数管理堆外内存的主要步骤：

1. 增加引用计数：在MappedFile类中，定义了一个原子整型变量this.mappedFileCount，作为引用计数。当需要使用MappedFile对象时，调用MappedFile的retain()方法来增加引用计数。

   public boolean retain() {
     if (this.available()) {
       this.mappedFileCount.incrementAndGet();
       return true;
     }
     return false;
   }
   

2. 减少引用计数：当完成MappedFile对象的使用后，调用MappedFile的release()方法来减少引用计数。

   public void release() {
     long value = this.mappedFileCount.decrementAndGet();
     // 引用计数为0，尝试触发堆外内存的回收
     if (value == 0) {
       if (this.mappedByteBuffer != null) {
         // 尝试将堆外内存标记为可回收
         clean(this.mappedByteBuffer);
         this.mappedByteBuffer = null;
       }
     }
   }
   

3. 回收堆外内存：当MappedFile对象的引用计数减少到0时，说明这个对象已经不再被使用。这时，MappedFile会调用clean()方法尝试回收堆外内存。

   public static void clean(final ByteBuffer buffer) {
     if (buffer.isDirect() && buffer instanceof DirectBuffer) {
       ((DirectBuffer) buffer).cleaner().clean();
     }
   }
   

((DirectBuffer) buffer).cleaner().clean()失败，会不会造成堆外内存泄漏 

在某些极端情况下，((DirectBuffer) buffer).cleaner().clean()可能无法立即释放堆外内存。如果堆外内存无法被正确释放，那么确实可能会导致内存泄漏的问题。然而，在实际应用中，clean()方法失败的情况相对罕见。

要确保堆外内存能够被正确回收，你可以采取以下措施：

1. 在使用完DirectByteBuffer之后，记得调用((DirectBuffer) buffer).cleaner().clean()方法，以触发堆外内存的回收。

2. 合理管理DirectByteBuffer对象的生命周期。当你确保不再需要一个DirectByteBuffer对象时，要让它脱离引用关系，以便垃圾回收器可以发现并回收它。RokcetMQ在调用clean方法后解除对堆外内存对象的引用关系：this.mappedByteBuffer = null; 在JVM垃圾回收过程中，DirectByteBuffer对象被回收时，其关联的堆外内存也将被回收。

3. 关注JVM的垃圾回收策略和实现细节，确保垃圾回收器能够正确发现和回收不再使用的DirectByteBuffer对象。在需要时，可以调整JVM参数以优化垃圾回收的性能。

总之，在实际应用中，只要遵循以上最佳实践，((DirectBuffer) buffer).cleaner().clean()方法失败导致堆外内存泄漏的情况应该是非常罕见的。在正确管理DirectByteBuffer对象的生命周期的前提下，堆外内存的回收问题通常不会成为一个严重的问题。

JVM垃圾回收能回收堆外内存吗

JVM垃圾回收主要负责回收堆内内存（Java堆），而不直接回收堆外内存。然而，JVM垃圾回收可以间接影响堆外内存的回收。具体来说，当JVM垃圾回收发现一个包含堆外内存引用的对象不再被使用时，它会触发堆外内存的回收。

例如，在Java NIO中，ByteBuffer可以分为堆内存（HeapByteBuffer）和堆外内存（DirectByteBuffer）。当我们使用DirectByteBuffer分配堆外内存时，DirectByteBuffer对象本身会被分配在Java堆中，而实际的数据存储在堆外内存中。当JVM垃圾回收发现DirectByteBuffer对象不再被使用时，它会回收DirectByteBuffer对象，并触发堆外内存的回收。

需要注意的是，JVM垃圾回收不会直接回收堆外内存，它只负责回收Java堆中的对象。因此，堆外内存的回收取决于DirectByteBuffer对象的生命周期。为了确保堆外内存能够被正确回收，应该遵循以下最佳实践：

1. 合理管理DirectByteBuffer对象的生命周期，确保不再使用的DirectByteBuffer对象可以被垃圾回收器发现和回收。

2. 使用((DirectBuffer) buffer).cleaner().clean()方法显式释放堆外内存，以触发堆外内存的回收。

总之，JVM垃圾回收不能直接回收堆外内存，但可以间接影响堆外内存的回收。在实际使用中，应该合理管理DirectByteBuffer对象的生命周期，并在需要时显式释放堆外内存，以确保堆外内存能够被正确回收。

FileChannel的设计原理

FileChannel是Java NIO（New I/O）中的一个核心类，它是对文件I/O操作的抽象。FileChannel为文件提供了一种异步、高性能、非阻塞的读写访问方式。以下是FileChannel的设计原理：

1. 通道（Channel）：通道是Java NIO中的一种抽象概念，用于在字节缓冲区（ByteBuffer）与实体（如文件、套接字等）之间传输数据。FileChannel是通道的一种实现，用于文件的读写操作。

2. 缓冲区（Buffer）：Java NIO引入了缓冲区的概念，它是用于存储数据的容器。缓冲区是通过ByteBuffer类来实现的，ByteBuffer提供了许多方法用于操作存储在其中的数据。在使用FileChannel时，所有的数据都是通过ByteBuffer进行传输的。

3. 异步操作：FileChannel支持异步的文件I/O操作。这意味着在进行读写操作时，线程不会被阻塞，可以继续执行其他任务。这种异步操作方式可以提高程序的并发性能。

4. 非阻塞模式：FileChannel可以工作在非阻塞模式下，在这种模式下，读写操作会立即返回，而不会等待数据的到达或写入完成。这种非阻塞模式进一步提高了程序的性能。

5. 内存映射文件：FileChannel支持内存映射文件，即将磁盘上的文件映射到内存地址空间。通过内存映射文件，程序可以通过访问内存地址来读写文件，避免了磁盘IO操作，从而提高了文件读写性能。

6. 文件锁定：FileChannel提供了文件锁定机制，用于在多个线程或进程之间同步文件访问。文件锁定可以确保在一个线程或进程访问文件时，其他线程或进程不能进行相互干扰的操作。

结合FileChannel的代码说明FileChannel的设计原理

1. 通道：FileChannel是一个抽象类，它继承了抽象基类AbstractInterruptibleChannel。AbstractInterruptibleChannel提供了基本的通道功能，如打开、关闭、中断等。FileChannel是专门用于文件操作的通道实现。

   public abstract class FileChannel extends AbstractInterruptibleChannel implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel {
       // ...
   }
   

2. 缓冲区：在FileChannel的读写操作中，都使用ByteBuffer作为数据传输的容器。例如，read方法从通道中读取数据到ByteBuffer中，write方法将ByteBuffer中的数据写入通道。

   public abstract int read(ByteBuffer dst) throws IOException;
   
   public abstract int write(ByteBuffer src) throws IOException;
   

3. 内存映射文件：FileChannel提供了map方法来创建内存映射文件。这个方法接收三个参数：映射模式（读/写）、起始位置和映射长度。map方法会返回一个MappedByteBuffer对象，这个对象表示磁盘上的文件已映射到内存地址空间。

   public final MappedByteBuffer map(MapMode mode, long position, long size) throws IOException {
       // ...
   }
   

4. 文件锁定：FileChannel提供了lock和tryLock方法来实现文件锁定。这两个方法都返回一个FileLock对象，表示文件已成功锁定。FileLock对象提供了release方法来释放文件锁。文件锁定机制可以确保在多个线程或进程之间同步文件访问。

   public final FileLock lock(long position, long size, boolean shared) throws IOException;
   
   public final FileLock tryLock(long position, long size, boolean shared) throws IOException;
   

5. 异步操作和非阻塞模式：在Java NIO中，FileChannel与Selector的搭配使用主要是针对网络IO（套接字通道），例如SocketChannel和ServerSocketChannel。对于文件IO操作，使用AsynchronousFileChannel类来实现异步、非阻塞操作。

   import java.io.IOException;
   import java.nio.ByteBuffer;
   import java.nio.channels.AsynchronousFileChannel;
   import java.nio.channels.CompletionHandler;
   import java.nio.file.Paths;
   import java.nio.file.StandardOpenOption;
   import java.util.concurrent.CountDownLatch;
   
   public class AsyncFileIOExample {
       public static void main(String[] args) {
           final String filePath = "test.txt"; // 文件路径
   
           try (AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get(filePath), StandardOpenOption.READ)) {
               ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配缓冲区大小
               CountDownLatch latch = new CountDownLatch(1); // 使用CountDownLatch等待异步操作完成
   
               // 异步读取文件
               fileChannel.read(buffer, 0, null, new CompletionHandler() {
                   @Override
                   public void completed(Integer bytesRead, Void attachment) {
                       System.out.println("Read bytes: " + bytesRead);
                       buffer.flip();
                       byte[] data = new byte[buffer.limit()];
                       buffer.get(data);
                       System.out.println("File content: " + new String(data));
                       latch.countDown(); // 读取完成，CountDownLatch计数减1
                   }
   
                   @Override
                   public void failed(Throwable exc, Void attachment) {
                       System.out.println("Failed to read file: " + exc.getMessage());
                       latch.countDown(); // 读取失败，CountDownLatch计数减1
                   }
               });
   
               System.out.println("Waiting for file read to complete...");
               latch.await(); // 等待异步操作完成
               System.out.println("File read completed.");
           } catch (IOException | InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
   

   import java.io.IOException;
   import java.net.InetSocketAddress;
   import java.nio.ByteBuffer;
   import java.nio.channels.SelectionKey;
   import java.nio.channels.Selector;
   import java.nio.channels.ServerSocketChannel;
   import java.nio.channels.SocketChannel;
   import java.util.Iterator;
   import java.util.Set;
   
   public class EchoServer {
   
       public static void main(String[] args) {
           int port = 8080; // 服务器监听的端口号
   
           try {
               // 创建ServerSocketChannel并配置为非阻塞模式
               ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
               serverSocketChannel.configureBlocking(false);
               serverSocketChannel.socket().bind(new InetSocketAddress(port));
   
               // 创建Selector并将ServerSocketChannel注册到Selector上
               Selector selector = Selector.open();
               serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
   
               System.out.println("Echo server started on port " + port);
   
               while (true) {
                   selector.select(); // 阻塞等待就绪的通道
   
                   Set selectedKeys = selector.selectedKeys();
                   Iterator iterator = selectedKeys.iterator();
   
                   while (iterator.hasNext()) {
                       SelectionKey key = iterator.next();
                       iterator.remove();
   
                       if (key.isAcceptable()) {
                           // 处理客户端连接请求
                           ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                           SocketChannel clientChannel = serverChannel.accept();
                           System.out.println("Accepted connection from " + clientChannel);
                           clientChannel.configureBlocking(false);
                           clientChannel.register(selector, SelectionKey.OP_READ);
                       } else if (key.isReadable()) {
                           // 处理客户端发送的数据
                           SocketChannel clientChannel = (SocketChannel) key.channel();
                           ByteBuffer buffer = ByteBuffer.allocate(1024);
                           int bytesRead = clientChannel.read(buffer);
   
                           if (bytesRead == -1) {
                               // 客户端断开连接
                               clientChannel.close();
                               System.out.println("Closed connection from " + clientChannel);
                           } else {
                               // 将接收到的数据返回给客户端
                               buffer.flip();
                               clientChannel.write(buffer);
                           }
                       }
                   }
               }
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }
   

   FileChannel中的通道是什么意思

 

在Java NIO中，通道（Channel）是一种抽象概念，用于在字节缓冲区（ByteBuffer）与实体（如文件、套接字等）之间传输数据。通道提供了一种高效、非阻塞的数据传输方式，可以用于异步地读取和写入数据。通道类似于传统的流（Stream），但在实现和性能上有很大差异。

FileChannel是通道的一种实现，它为文件提供了一种高效、非阻塞的读写访问方式。FileChannel是专门用于文件操作的通道，包括文件读写、内存映射文件、文件锁定等功能。当我们将FileChannel与ByteBuffer结合使用时，可以实现高效、安全的文件操作。

在FileChannel中，通道的意义是提供了一种抽象，用于在字节缓冲区与文件之间传输数据。FileChannel将文件操作抽象为通道，这样我们可以使用相同的通道接口来处理不同的实体（如文件、套接字等），简化了数据传输的处理方式。

通道和流有什么本质的区别 

通道（Channel）和流（Stream）都是Java I/O系统中用于数据传输的抽象概念，但它们在实现方式和性能上存在本质的区别。以下是通道和流之间的主要区别：

1. 阻塞与非阻塞：流通常是阻塞的，当执行读写操作时，线程会被阻塞，直到操作完成。而通道可以工作在非阻塞模式下，这意味着通道的读写操作可以立即返回，而不会等待数据的到达或写入完成。非阻塞模式可以提高程序的并发性能。

2. 读写模式：流通常是单向的，即一个流只能用于读取数据或写入数据。例如，InputStream用于读取数据，OutputStream用于写入数据。而通道是双向的，即一个通道可以同时用于读取和写入数据。

3. 数据传输：流是基于字节的，数据传输是逐字节进行的。而通道是基于缓冲区（Buffer）的，数据传输是通过缓冲区进行的。在通道中，数据从实体（如文件、套接字等）读取到缓冲区，或从缓冲区写入实体。通过使用缓冲区，通道可以实现更高效的数据传输。

4. 异步操作：通道支持异步操作，即通道可以在后台执行读写操作，而不会阻塞主线程。这种异步操作方式可以提高程序的并发性能。而流通常不支持异步操作，读写操作都是同步进行的。

5. 内存映射文件：通道支持内存映射文件，即将磁盘上的文件映射到内存地址空间。通过内存映射文件，程序可以直接访问内存地址来读写文件，避免了磁盘IO操作，从而提高了文件读写性能。而流没有内存映射文件功能。

综上所述，通道和流在阻塞与非阻塞、读写模式、数据传输方式、异步操作以及内存映射文件等方面具有本质的区别。通道提供了一种高效、非阻塞的数据传输方式，可以用于异步地读取和写入数据，而流是基于字节的、阻塞的数据传输方式。在Java NIO中，通道作为一种新的I/O模型，为程序提供了更高效、灵活的数据处理能力。