一、概述

Android原生有个HandlerThread，从字面上便可看出，这是一个异步事件分发线程。配合Handler一起使用，便可实现一个简单的EventBus。

代码实现在细节上的考虑

1. 组件的销毁，如果不是贯穿整个进程的生命周期，则不需要时可以销毁它，节省内存。

2. 定义一个事件监听器接口，通过泛型来定义事件类型。

3. 监听器对象存储，通过虚引用来存储监听器对象，防止内存泄漏。

4. 并发问题，利用synchronized来处理并发问题。

二、代码实现

package com.example.utils;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.Nullable;
import android.support.v4.util.ArraySet;
import android.util.Log;

import java.lang.ref.WeakReference;
import java.util.Iterator;

/**
 * Created by zqil on 2018/2/5.
 */

public class ZEventBus<T> {
    private Handler mHandler = null;
    private ArraySet<WeakReference<EventListener<T>>> listeners = new ArraySet<>();
    public interface EventListener<T> {
        void onEvent(T t);
    }
    public ZEventBus(String name) {
        HandlerThread thread = new HandlerThread(name);
        thread.start();
        mHandler = new EventHandler<>(thread.getLooper(), this);
    }

    public synchronized void destroy() {
        if (mHandler != null) {
            mHandler.getLooper().quit();
            mHandler = null;
        }
    }

    public boolean isDestroyed() {
        if (mHandler == null) {
            Log.d(ZEventBus.class.getSimpleName(), "EventBus is destroyed !");
            return true;
        }
        return false;
    }

    private static class EventHandler<T> extends Handler {
        private WeakReference<ZEventBus<T>> mWeakRef = null;

        public EventHandler(Looper looper, ZEventBus<T> eventBus) {
            super(looper);
            this.mWeakRef = new WeakReference<ZEventBus<T>>(eventBus);
        }
        private static final int MSG_NOTIFY_EVENT = 1;
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            ZEventBus<T> eventBus = mWeakRef != null ? mWeakRef.get() : null;
            if (eventBus == null) {
                return;
            }
            switch (msg.what) {
                case MSG_NOTIFY_EVENT:
                    eventBus.doNotifyEvent((T) msg.obj);
                    break;
                default:
                    break;
            }
        }
    }

    public synchronized void notifyEvent(T t) {
        if (isDestroyed()) {
            return;
        }
        mHandler.obtainMessage(EventHandler.MSG_NOTIFY_EVENT, t).sendToTarget();
    }

    private void doNotifyEvent(T t) {
        Iterator<WeakReference<EventListener<T>>> it = listeners.iterator();
        while (it.hasNext()) {
            WeakReference<EventListener<T>> weakRef = it.next();
            EventListener<T> listener = weakRef != null ? weakRef.get() : null;
            if (listener != null) {
                listener.onEvent(t);
            } else {
                it.remove();
            }
        }
    }

    @Nullable
    private WeakReference<EventListener<T>> findListener(EventListener listener) {
        Iterator<WeakReference<EventListener<T>>> it = listeners.iterator();
        while (it.hasNext()) {
            WeakReference<EventListener<T>> weakRef = it.next();
            EventListener<T> exist = weakRef != null ? weakRef.get() : null;
            if (exist == null) {
                it.remove();
            } else if (exist == listener) {
                return weakRef;
            }
        }
        return null;
    }

    public synchronized void addListener(EventListener listener) {
        if (findListener(listener) == null) {
            listeners.add(new WeakReference<EventListener<T>>(listener));
        }
    }
    public synchronized void removeListener(EventListener listener) {
        WeakReference<EventListener<T>> weakRef = findListener(listener);
        if (weakRef != null) {
            listeners.remove(weakRef);
        }
    }

}