EventBus3.0源码学习(4) threadMode

线程模式

• POSTING：该模式不需要线程切换，为默认模式。在post线程直接调用事件订阅函数。
• MAIN：若post线程是主线程，则与POSTING模式一样；否则，由mainThreadPoster进行处理，从主线程调用事件订阅函数。
• BACKGROUND：若post线程不是主线程，则与POSTING一样；否则，由backgroundPoster进行处理，从background线程调用事件订阅函数。
• ASYNC：该模式总是需要进行线程切换，由asyncPoster进行处理。

EventBus中与线程相关的成员变量如下：

public class EventBus {
    private final HandlerPoster mainThreadPoster; // MAIN
    private final BackgroundPoster backgroundPoster; // BACKGROUND
    private final AsyncPoster asyncPoster; // ASYNC
    private final ExecutorService executorService; // Executors.newCachedThreadPool()

    EventBus(EventBusBuilder builder) {
        mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
        backgroundPoster = new BackgroundPoster(this);
        asyncPoster = new AsyncPoster(this);
        executorService = builder.executorService;
    }
}

mainThreadPoster使用mainLooper，而backgroundPoster、syncPoster都是使用exectuorService提供的线程。

HandlerPoster

final class HandlerPoster extends Handler {

    private final PendingPostQueue queue;
    private final int maxMillisInsideHandleMessage;
    private final EventBus eventBus;
    private boolean handlerActive;

    HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
        super(looper);
        this.eventBus = eventBus;
        this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
        queue = new PendingPostQueue();
    }

    void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            queue.enqueue(pendingPost);
            if (!handlerActive) {
                handlerActive = true;
                if (!sendMessage(obtainMessage())) {
                    throw new EventBusException("Could not send handler message");
                }
            }
        }
    }

    @Override
    public void handleMessage(Message msg) {
        boolean rescheduled = false;
        try {
            long started = SystemClock.uptimeMillis();
            while (true) {
                PendingPost pendingPost = queue.poll();
                if (pendingPost == null) {
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            handlerActive = false;
                            return;
                        }
                    }
                }
                eventBus.invokeSubscriber(pendingPost);
                long timeInMethod = SystemClock.uptimeMillis() - started;
                if (timeInMethod >= maxMillisInsideHandleMessage) {
                    if (!sendMessage(obtainMessage())) {
                        throw new EventBusException("Could not send handler message");
                    }
                    rescheduled = true;
                    return;
                }
            }
        } finally {
            handlerActive = rescheduled;
        }
    }
}

第15-26行，enqueue操作将subscription和event封装成一个pendingPost对象，将其放入queue队列中。若handlerActive为false，表明主线程没有正在处理queue中的消息，则调用sendMessage(obtainMessage())通知Looper线程处理。

HandlerPoster继承Handler，enqueue操作调用sendMessage，会导致handleMessage回调从Looper线程中触发。第33-54行，handleMessage中使用一个循环处理queue队列中的消息。若queue队列为空，则退出循环；若当前处理事件总耗时超过了maxMillisInsideHandleMessage，则调用sendMessage并退出循环(此时handlerActive仍为true，因为Looper线程会在处理完handleMessage运行期间积压的事务之后再次触发handleMessage回调)。

第36-43行的synchronized块和第17-25行的synchronized块，共同保证handlerActive的值被正确设置。不过，第56行没有在synchronized块中，这可能导致sendMessage被重复调用，但并不会出现queue队列中有元素却没有得到及时处理。

BackgroundPoster

final class BackgroundPoster implements Runnable {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    private volatile boolean executorRunning;

    BackgroundPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            queue.enqueue(pendingPost);
            if (!executorRunning) {
                executorRunning = true;
                eventBus.getExecutorService().execute(this);
            }
        }
    }

    @Override
    public void run() {
        try {
            try {
                while (true) {
                    PendingPost pendingPost = queue.poll(1000);
                    if (pendingPost == null) {
                        synchronized (this) {
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }

}

第13-22行，enqueue操作将subscription和event封装成一个pendingPost对象，将其放入queue队列中。若executorRunning为false，表明background线程没有正在处理queue队列中的消息，则调用eventBus.getExecutorService().execute(this)执行backgroundPoster。

BackgroundPoster继承Runnable，run中使用一个循环处理queue队列中的消息。第29行，若queue队列为空时，poll(1000)会等待1000毫秒，若超时后还没取到消息，则进入synchronized块再poll一次，若此时若仍返回空，则退出循环。

第31-38行的synchronized块和第15-21行的synchronized块，共同保证executorRunning的值被正确设置。不过，第46行没有在synchronized块中，这可能导致backgroundPost同时运行在两个线程中，这跟backgroudPoster的定义是乎并不一致。

从代码实现来看，BackgroundPoster保证的是串行化，但并不是使用同一线程实现的。

AsyncPoster

class AsyncPoster implements Runnable {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    AsyncPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        queue.enqueue(pendingPost);
        eventBus.getExecutorService().execute(this);
    }

    @Override
    public void run() {
        PendingPost pendingPost = queue.poll();
        if(pendingPost == null) {
            throw new IllegalStateException("No pending post available");
        }
        eventBus.invokeSubscriber(pendingPost);
    }

}

AsyncPoster继承Runnable，enqueue操作将subscription和event封装成一个pendingPost对象，将其放入queue队列中。每次enqueue操作都将调用eventBus.getExecutorService().execute(this)，从线程池获取一个线程执行asyncPoster，处理queue队列中的消息。每次线程只执行一个pendingPost请求。

PendingPostQueue结构

final class PendingPostQueue {
    private PendingPost head;
    private PendingPost tail;

    synchronized void enqueue(PendingPost pendingPost) {
        if (pendingPost == null) {
            throw new NullPointerException("null cannot be enqueued");
        }
        if (tail != null) {
            tail.next = pendingPost;
            tail = pendingPost;
        } else if (head == null) {
            head = tail = pendingPost;
        } else {
            throw new IllegalStateException("Head present, but no tail");
        }
        notifyAll();
    }

    synchronized PendingPost poll() {
        PendingPost pendingPost = head;
        if (head != null) {
            head = head.next;
            if (head == null) {
                tail = null;
            }
        }
        return pendingPost;
    }

    synchronized PendingPost poll(int maxMillisToWait) throws InterruptedException {
        if (head == null) {
            wait(maxMillisToWait);
        }
        return poll();
    }

}

PendingPostQueue底层使用head和tail维护一个PendingPost队列。enqueue和poll操作都由synchronized修饰。

PendingPost

final class PendingPost {
    private final static List<PendingPost> pendingPostPool = new ArrayList<PendingPost>();

    Object event;
    Subscription subscription;
    PendingPost next;

    private PendingPost(Object event, Subscription subscription) {
        this.event = event;
        this.subscription = subscription;
    }

    static PendingPost obtainPendingPost(Subscription subscription, Object event) {
        synchronized (pendingPostPool) {
            int size = pendingPostPool.size();
            if (size > 0) {
                PendingPost pendingPost = pendingPostPool.remove(size - 1);
                pendingPost.event = event;
                pendingPost.subscription = subscription;
                pendingPost.next = null;
                return pendingPost;
            }
        }
        return new PendingPost(event, subscription);
    }

    static void releasePendingPost(PendingPost pendingPost) {
        pendingPost.event = null;
        pendingPost.subscription = null;
        pendingPost.next = null;
        synchronized (pendingPostPool) {
            // Don't let the pool grow indefinitely
            if (pendingPostPool.size() < 10000) {
                pendingPostPool.add(pendingPost);
            }
        }
    }

}

PendingPost封装了subscription和event，并提供静态对象池，用于对象复用。