docs: Add documentation for Disruptor implementation based on LMAX Disruptor

Added JavaDoc comments to all Disruptor-related classes to clarify that this
implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
and adapted for IoTDB's Pipe module.

Modified files:
- BatchEventProcessor.java
- Disruptor.java
- EventFactory.java
- EventHandler.java
- ExceptionHandler.java
- MultiProducerSequencer.java
- RingBuffer.java
- Sequence.java
- SequenceBarrier.java
- SequenceGroups.java

Each class now includes clear documentation about:
1. Origin from LMAX Disruptor
2. Key features preserved from the original
3. Simplifications made for IoTDB's use case

Author: luoluoyuyu

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/BatchEventProcessor.java

@@ -25,9 +25,10 @@
 /**
  * Batch event processor for consuming events
  *
- * <p>Simplified from Disruptor (removed complex lifecycle management)
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and simplified for IoTDB's Pipe module (removed complex lifecycle management).
  *
- * <p>CORE algorithm (MUST preserve):
+ * <p>Core algorithm preserved from LMAX Disruptor:
  *
  * <ul>
  *   <li>Batch processing loop

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/Disruptor.java

@@ -25,12 +25,17 @@
 import java.util.concurrent.ThreadFactory;
 
 /**
- * High-level API for setting up a lock-free event processing pipeline
+ * Simplified Disruptor implementation for IoTDB Pipe
  *
- * <p>Provides a fluent interface for configuring producers and consumers. Internally manages a
- * RingBuffer and event processor thread.
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and simplified for IoTDB's specific use case in the Pipe module.
  *
- * <p>Configuration is simplified to multi-producer mode with blocking wait strategy.
+ * <p>Key simplifications:
+ * <ul>
+ *   <li>Single event handler support (no complex dependency graphs)
+ *   <li>Simplified lifecycle management
+ *   <li>Removed wait strategies (using simple sleep-based waiting)
+ * </ul>
  *
  * @param <T> event type
  */
@@ -88,7 +93,6 @@ public void setDefaultExceptionHandler(ExceptionHandler<? super T> exceptionHand
     }
   }
 
-  /** Start - MUST keep for IoTDB */
   public RingBuffer<T> start() {
     if (started) {
       throw new IllegalStateException("Disruptor already started");

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/EventFactory.java

@@ -22,6 +22,9 @@
 /**
  * Event factory for pre-allocating events in RingBuffer
  *
+ * <p>This interface is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and adapted for IoTDB's Pipe module.
+ *
  * @param <T> event type
  */
 @FunctionalInterface

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/EventHandler.java

@@ -22,6 +22,9 @@
 /**
  * Event handler for processing events from RingBuffer
  *
+ * <p>This interface is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and adapted for IoTDB's Pipe module.
+ *
  * @param <T> event type
  */
 @FunctionalInterface

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/ExceptionHandler.java

@@ -22,6 +22,9 @@
 /**
  * Exception handler for event processing errors
  *
+ * <p>This interface is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and adapted for IoTDB's Pipe module.
+ *
  * @param <T> event type
  */
 public interface ExceptionHandler<T> {

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/MultiProducerSequencer.java

@@ -22,6 +22,20 @@
 import java.util.concurrent.atomic.AtomicIntegerArray;
 import java.util.concurrent.locks.LockSupport;
 
+/**
+ * Multi-producer sequencer for coordinating concurrent publishers
+ *
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and preserves the core lock-free multi-producer algorithm for IoTDB's Pipe module.
+ *
+ * <p>Key features preserved from LMAX Disruptor:
+ * <ul>
+ *   <li>Lock-free CAS-based sequence claiming
+ *   <li>Availability buffer for out-of-order publishing detection
+ *   <li>Backpressure via gating sequences
+ *   <li>Cache line padding to prevent false sharing
+ * </ul>
+ */
 public final class MultiProducerSequencer {
 
   /** Ring buffer size (must be power of 2) - immutable after construction */

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/RingBuffer.java

@@ -98,6 +98,9 @@ protected final E elementAt(long sequence) {
 /**
  * Lock-free ring buffer for storing pre-allocated event objects
  *
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and preserves the core ring buffer algorithm for IoTDB's Pipe module.
+ *
  * <p>Supports multi-producer concurrent access with zero-garbage design. Events are pre-allocated
  * and reused, avoiding GC pressure. Uses cache line padding to prevent false sharing.
  *

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/Sequence.java

@@ -39,11 +39,14 @@ class RhsPadding extends Value {
 /**
  * Lock-free sequence counter with cache line padding
  *
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and preserves the core sequence tracking mechanism for IoTDB's Pipe module.
+ *
  * <p>Key design features:
  *
  * <ul>
  *   <li>Three-level inheritance ensures proper field ordering for padding
- *   <li>Uses volatile long with Unsafe for direct memory access
+ *   <li>Uses AtomicLong for thread-safe atomic operations
  *   <li>Cache line padding prevents false sharing between CPU cores
  *   <li>Supports both ordered writes (cheaper) and volatile writes (stronger)
  * </ul>

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/SequenceBarrier.java

@@ -22,9 +22,10 @@
 /**
  * Sequence barrier for consumer coordination
  *
- * <p>Simplified from Disruptor (removed Alert mechanism - IoTDB doesn't need it)
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and simplified for IoTDB's Pipe module (removed Alert mechanism - IoTDB doesn't need it).
  *
- * <p>MUST preserve:
+ * <p>Core features preserved from LMAX Disruptor:
  *
  * <ul>
  *   <li>waitFor() logic for waiting sequences

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/source/dataregion/realtime/disruptor/SequenceGroups.java

@@ -24,8 +24,11 @@
 /**
  * Utility for atomic management of sequence arrays
  *
+ * <p>This implementation is based on LMAX Disruptor (https://github.com/LMAX-Exchange/disruptor)
+ * and adapted for IoTDB's Pipe module.
+ *
  * <p>Provides thread-safe operations for adding and removing sequences from gating sequence arrays
- * used to track consumer progress
+ * used to track consumer progress.
  */
 final class SequenceGroups {