nacos2.0-源码分析-事件机制分析

最新推荐文章于 2025-08-25 12:15:18 发布

原创

最新推荐文章于 2025-08-25 12:15:18 发布 · 2.3k 阅读

2 ·

CC 4.0 BY-SA版权

本文深入解析Nacos的事件机制，包括异步事件、常规事件和慢事件，以及单事件和多事件订阅者。详细介绍了事件发布者（DefaultPublisher和DefaultSharePublisher）的工作原理，如队列机制、线程执行和事件处理流程。同时，阐述了订阅中心（notifyCenter）的角色，如注册订阅者、发布事件和管理发布者。测试用例展示了如何注册和发布慢事件。

文章目录

前言

nacos的事件机制是异步的，心跳状态变化，服务状态变化都是通过事件机制传递的。发布者发送事件，订阅者订阅事件，并执行逻辑。

1. 事件(Event)

事件包括常规事件和慢事件，都是虚函数。

1.1 常规事件(SlowEvent)

public abstract class Event implements Serializable {
   
   
 //注释1.0
    private static final AtomicLong SEQUENCE = new AtomicLong(0);
    private final long sequence = SEQUENCE.getAndIncrement();

    public long sequence() {
   
   
        return sequence;
    }
}

注释1.0：通过原子自增，保证事件的顺序；

1.2 慢事件(SlowEvent)

public abstract class SlowEvent extends Event {
   
   
   //注释1.1
    public long sequence() {
   
   
        return 0;
    }
}

注释1.1：慢事件继承自常规事件，并覆写sequence()方法，慢事件的序号不是自增的。

2.订阅者(Subscriber)

2.1 单事件订阅者(Subscriber)

//注释2.0
public abstract class Subscriber<T extends Event> {
   
   
	//注释2.1
    public abstract void onEvent(T event);
    //注释2.2
    public abstract Class<? extends Event> subscribeType();
	//注释2.3
    public Executor executor() {
   
   
        return null;
    };
    //注释2.4
    public boolean ignoreExpireEvent() {
   
   
        return false;
    };
}

注释2.0: 订阅者是虚函数；
注释2.1: 事件处理的入口，事件触发时，执行的动作，由对应的事件发布器调用；
注释2.2:订阅者类型，这里只能订阅一种类型；
注释2.3: 线程执行器，由具体的实现类来决定时同步还是异步，如果子类没有实现，则是同步执行；
注释2.4 是否忽略过期事件

2.2 智能订阅者(SmartSubscriber)

//注释2.0
public abstract class SmartSubscriber extends Subscriber {
   
     
    //注释2.1
    public abstract List<Class<? extends Event>> subscribeTypes();
    //注释2.2
    @Override
    public final Class<? extends Event> subscribeType() {
   
   
        return null;
    }
    //注释2.3
    @Override
    public final boolean ignoreExpireEvent() {
   
   
        return false;
    }
}

注释2.0：smartSubscribe和subscriber的区别是前者可以订阅多个事件，后者只能订阅一个事件，smartSubscribe发布者是DefaultSharePublisher,subscribe的发布者是DefaultPublisher;
注释2.1 : 区别于父类Subscriber，这里支持多个事件类型；
注释2.2：继承父类但是用final修饰，不可继续继承;
注释2.3：继承父类但是用final修饰，不可改变，忽略过期事件；

3.发布者 (Publisher)

发布者的顶级接口为EventPublisher

 //事件发布者
public interface EventPublisher extends Closeable {
   
   
    //初始化
    void init(Class<? extends Event> type, int bufferSize);
    long currentEventSize();
    //添加订阅者
    void addSubscriber(Subscriber subscriber);
    //移除订阅者
    void removeSubscriber(Subscriber subscriber);
    //发布事件
    boolean publish(Event event);
    //通知订阅者
    void notifySubscriber(Subscriber subscriber, Event event);
}

发布者的主要功能就是新增订阅者、通知订阅者，目前两种发布者实现是DefaultPublisher和DefaultSharePublisher

3.1 事件发布者（DefaultPublisher）

//实现EventPublisher，继承Thread类，实现run方法，达到多线程的目的
public class DefaultPublisher extends Thread implements EventPublisher {
   
   

    protected static final Logger LOGGER = LoggerFactory.getLogger(DefaultPublisher.class);
    private volatile boolean initialized = false;
	//是否关闭
    private volatile boolean shutdown = false;
	//通知队列的最大值
    private int queueMaxSize = -1;
    //事件放入阻塞队列
    private BlockingQueue<Event> queue;
    //最新的阻塞队列序号
    protected volatile Long lastEventSequence = -1L;
	// 事件序列号更新对象，用于更新原子属性lastEventSequence
    private static final AtomicReferenceFieldUpdater<DefaultPublisher, Long> UPDATER = AtomicReferenceFieldUpdater
            .newUpdater(DefaultPublisher.class, Long.class, "lastEventSequence");
     //事件类型
    private Class<? extends Event> eventType;
     //去重的事件订阅者集合，这里采用的ConcurrentHashSet是自己封装的ConcurrentHashMap,不过value统一为boolean，感兴趣的可以看下
    protected final ConcurrentHashSet<Subscriber> subscribers = new ConcurrentHashSet<>();

初始化

   public void init(Class<? extends Event> type, int bufferSize) {
   
   
        setDaemon(true);
        setName("nacos-publisher-" + type.getName());
        this.eventType = type;
        this.queueMaxSize = bufferSize;
        this.queue = new ArrayBlockingQueue<>(bufferSize);
        start();
    }

初始化将线程设置为守护线程，设置线程名称，设置事件类型，带大小的阻塞队列。

    @Override
    public synchronized void start() {
   
   
        if (!initialized) {
   
   
            //调用线程父类的start,启动线程
            super.start(