Java中的高并发设计模式：Disruptor vs Reactor vs Actor模型

最新推荐文章于 2025-05-18 23:46:26 发布

吴晓斌kobe

最新推荐文章于 2025-05-18 23:46:26 发布

阅读量518

点赞数 10

分类专栏： Java学习文章标签： java 设计模式高并发 Disruptor Reactor Actor

本文链接：https://blog.youkuaiyun.com/qq_25216471/article/details/145921646

版权

Java学习专栏收录该内容

45 篇文章

订阅专栏

在高并发场景下，如何高效地处理大量请求是一个关键问题。Java提供了多种高并发设计模式，其中Disruptor、Reactor和Actor模型是三种常见的选择。本文将深入探讨这三种设计模式，并通过代码实战展示它们的应用场景和优缺点。

1. Disruptor：高性能的并发队列

1.1 什么是Disruptor？

Disruptor是一个高性能的并发队列框架，由LMAX公司开发。它通过无锁设计、环形缓冲区和事件驱动机制，实现了极高的吞吐量和低延迟。Disruptor特别适合用于金融交易、实时数据处理等对性能要求极高的场景。

1.2 Disruptor的核心概念

Ring Buffer：环形缓冲区，用于存储事件。
Sequence：序列号，用于跟踪生产者和消费者的进度。
Event：事件，代表需要处理的数据。
Event Handler：事件处理器，负责处理事件。

1.3 Disruptor代码实战

import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.util.DaemonThreadFactory;

public class DisruptorExample {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建事件工厂
        LongEventFactory factory = new LongEventFactory();

        // 2. 指定Ring Buffer大小，必须是2的幂次方
        int bufferSize = 1024;

        // 3. 创建Disruptor
        Disruptor<LongEvent> disruptor = new Disruptor<>(factory, bufferSize, DaemonThreadFactory.INSTANCE);

        // 4. 注册事件处理器
        disruptor.handleEventsWith(new LongEventHandler());

        // 5. 启动Disruptor
        disruptor.start();

        // 6. 获取Ring Buffer
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();

        // 7. 发布事件
        for (long i = 0; i < 10; i++) {
            long sequence = ringBuffer.next();
            try {
                LongEvent event = ringBuffer.get(sequence);
                event.set(i);
            } finally {
                ringBuffer.publish(sequence);
            }
        }

        // 8. 关闭Disruptor
        disruptor.shutdown();
    }
}

class LongEvent {
    private long value;

    public void set(long value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "LongEvent{" + "value=" + value + '}';
    }
}

class LongEventFactory implements com.lmax.disruptor.EventFactory<LongEvent> {
    @Override
    public LongEvent newInstance() {
        return new LongEvent();
    }
}

class LongEventHandler implements com.lmax.disruptor.EventHandler<LongEvent> {
    @Override
    public void onEvent(LongEvent event, long sequence, boolean endOfBatch) {
        System.out.println("Event: " + event);
    }
}

1.4 Disruptor的优缺点

优点：极高的吞吐量、低延迟、无锁设计。
缺点：复杂性较高，适合特定场景。

2. Reactor：事件驱动的并发模型

2.1 什么是Reactor？

Reactor模式是一种事件驱动的并发模型，它通过一个或多个事件循环（Event Loop）来处理大量并发请求。Reactor模式广泛应用于网络编程中，如Netty、Spring WebFlux等框架。

2.2 Reactor的核心概念

Event Loop：事件循环，负责监听和分发事件。
Handler：事件处理器，负责处理具体的事件。
Demultiplexer：多路复用器，用于监听多个事件源。

2.3 Reactor代码实战

import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;

public class ReactorExample {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建一个Flux流，模拟事件源
        Flux<Integer> flux = Flux.range(1, 10)
                .publishOn(Schedulers.parallel()) // 在并行线程中处理
                .map(i -> i * 2); // 对每个事件进行处理

        // 2. 订阅并处理事件
        flux.subscribe(
                value -> System.out.println("Received: " + value),
                error -> error.printStackTrace(),
                () -> System.out.println("Completed")
        );

        // 3. 等待异步处理完成
        Thread.sleep(1000);
    }
}

2.4 Reactor的优缺点

优点：适合处理大量I/O密集型任务，资源利用率高。
缺点：对CPU密集型任务支持较弱，调试复杂。

3. Actor模型：基于消息传递的并发模型

3.1 什么是Actor模型？

Actor模型是一种基于消息传递的并发模型，每个Actor都是一个独立的计算单元，通过消息传递进行通信。Actor模型非常适合分布式系统和并发编程。

3.2 Actor的核心概念

Actor：独立的计算单元，拥有自己的状态和行为。
Message：消息，用于Actor之间的通信。
Mailbox：邮箱，用于存储接收到的消息。

3.3 Actor代码实战（使用Akka框架）

import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;

public class ActorExample {
    public static void main(String[] args) {
        // 1. 创建Actor系统
        ActorSystem system = ActorSystem.create("MySystem");

        // 2. 创建Actor
        ActorRef myActor = system.actorOf(Props.create(MyActor.class), "myActor");

        // 3. 发送消息
        myActor.tell("Hello, Actor!", ActorRef.noSender());

        // 4. 关闭Actor系统
        system.terminate();
    }
}

class MyActor extends AbstractActor {
    @Override
    public Receive createReceive() {
        return receiveBuilder()
                .match(String.class, message -> {
                    System.out.println("Received: " + message);
                })
                .build();
    }
}