使用GreenRobot EventBus從線程到線程進行通信

Question

剛開始使用GreenRobot的EventBus 。

只有一件事讓我苦苦掙扎：你如何在不同的線程之間進行通信，以便onEventXY（）方法實際上也在訂閱的線程中執行。

似乎當您發布事件時，訂閱者onEvent方法是從與發布事件的線程相同的線程調用的。 那不是我想要的。

我希望能夠使用EventBus進行線程間通信，使得實際接收的事件對象由接收事件對象的線程中的onEvent方法處理。

那可能嗎？

例：

• mainThread
• backGroundThread1
• backGroundThread2

MainThread在EventBus上發布事件，backGroundThread1在其onEventXY（）方法中接收它並在其自己的線程中執行代碼（設置一些變量），backGroundThread2在其onEventXY方法中接收它並在其自己的線程中執行代碼（設置一些變量）。

如果這還不可能（我），我注定要使用線程隊列，比如BlockingQueue，這很難實現。

有任何想法嗎？

Answer 1

來自Greenrobot docs， 網址為https://github.com/greenrobot/EventBus

BackgroundThread
訂閱者將在后台線程中調用。 如果發布線程不是主線程，則將在發布線程中直接調用事件處理程序方法。 如果發布線程是主線程，則EventBus使用單個后台線程，該線程將按順序傳遞其所有事件。 使用此模式的事件處理程序應嘗試快速返回以避免阻止后台線程。

Async
事件處理程序方法在單獨的線程中調用。 這始終獨立於發布線程和主線程。 發布事件永遠不會等待使用此模式的事件處理程序方法。 如果事件處理程序的執行可能需要一些時間，例如用於網絡訪問，則應使用此模式。 避免同時觸發大量長時間運行的異步處理程序方法來限制並發線程數。 EventBus使用線程池從已完成的異步事件處理程序通知中有效地重用線程。

創建回調時，需要將名稱后綴添加到onEvent ，如下所示：

• onEventMainThread(YourEvent eventInstance)和簡寫onEvent(YourEvent eventInstance)
  總是調度到主UI線程
• onEventBackgroundThread(YourEvent eventInstance)
  這最適合您的問題
• onEventAsync(YourEvent eventInstance)
  總是在一個新線程中，如果你從這里調度大量事件就有風險，可以輕松點擊一個Thread異常

Answer 2

我遇到了同樣的問題，我使用了Looper ， Handler和HandlerThread 。

這是我的BackgroundHandlerThread類：

import android.annotation.TargetApi;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.os.Process;
import android.util.Log;

import java.lang.reflect.Method;
import java.util.UUID;


public class BackgroundHandlerThread extends Handler {

    private static final String TAG = BackgroundHandlerThread.class.getSimpleName();

    private HandlerThread handlerThread;
    private Object busHandler;

    public BackgroundHandlerThread(HandlerThread handlerThread, Object busHandler) {
        super(handlerThread.getLooper());
        this.handlerThread = handlerThread;
        this.busHandler = busHandler;
    }

    public void onEvent(Object event) {
        Log.d(TAG, "onEvent(Object), thread: " + Thread.currentThread().getId() + ", class: " + event.getClass().getName());
        Message message = obtainMessage();
        message.obj = event;
        sendMessage(message);
    }

    @Override
    public void handleMessage(Message msg) {
        Method[] aClassMethods = busHandler.getClass().getDeclaredMethods();
        for (Method m : aClassMethods) {
            if (m.getName().equals("onHandlerThreadEvent")) {
                if (m.getParameterTypes().length == 1 && m.getParameterTypes()[0].equals(msg.obj.getClass())) {
                    try {
                        m.invoke(busHandler, msg.obj);
                    } catch (Exception e) {
                        Log.wtf(TAG, e);
                    }
                }
            }
        }
    }

    public boolean quit() {
        return handlerThread.quit();
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
    public boolean quitSafely() {
        return handlerThread.quitSafely();
    }

    public static class Builder {
        private HandlerThread handlerThread;
        private Object busHandler;

        public Builder(Object busHandler) {
            this.busHandler = busHandler;
        }

        public Builder setHandlerThread(HandlerThread handlerThread) {
            this.handlerThread = handlerThread;
            return this;
        }

        public BackgroundHandlerThread build() {
            if (handlerThread == null) {
                handlerThread = new HandlerThread("BackgroundHandlerThread: " + UUID.randomUUID().toString(), Process.THREAD_PRIORITY_BACKGROUND);
            }

            if (!handlerThread.isAlive()) {
                handlerThread.start();
            }

            return new BackgroundHandlerThread(handlerThread, busHandler);
        }
    }
}

我在我的服務中使用它，但BackgroundHandlerThread對象可以綁定到任何對象。

import android.app.Service;
import android.bluetooth.BluetoothDevice;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

import de.greenrobot.event.EventBus;

public class DeviceService extends Service {

    private static final String TAG = DeviceService.class.getSimpleName();

    private BluetoothDevice bluetoothDevice;
    private BackgroundHandlerThread handlerThread;
    private boolean connected = false;

    //region Lifecycle
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate, thread: " + Thread.currentThread().getId());
        handlerThread = new BackgroundHandlerThread.Builder(this).build();
        EventBus.getDefault().register(handlerThread);
    }

    @Override
    public void onDestroy() {
        EventBus.getDefault().unregister(handlerThread);
        handlerThread.quit();
        super.onDestroy();
    }
    //endregion

    public void onHandlerThreadEvent(ConnectToDeviceEvent event) {
        Log.d(TAG, "onHandlerThreadEvent, thread: " + Thread.currentThread().getId());
        connected = true;
        bluetoothDevice = event.device;
        EventBus.getDefault().post(new ConnectionStateChangedEvent(bluetoothDevice, connected));
    }

    //region Static manipulation
    public static void startService(Context context) {
        Intent intent = new Intent(context, DeviceBinder.class);
        context.startService(intent);
    }
    //endregion
}

和活動類：

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.util.Log;

import de.greenrobot.event.EventBus;

public class MainActivity extends Activity {

    private static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.startButton).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d(TAG, "onStartClick, thread: " + Thread.currentThread().getId());
                EventBus.getDefault().post(new ConnectToDeviceEvent(application.getCurrentStateProvider().getDevice()));
            }
        });
        DeviceService.startService(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    protected void onStop() {
        EventBus.getDefault().unregister(this);
        super.onStop();
    }

    public void onEventMainThread(ConnectionStateChangedEvent event) {
        Log.d(TAG, "onEventMainThread(ConnectionStateChangedEvent), thread: " + Thread.currentThread().getId());
    }

}

日志輸出：

D/MainActivity: onStartClick, thread: 1
D/BackgroundHandlerThread: onEvent(Object), thread: 1, class: ConnectToDeviceEvent
D/DeviceService: onHandlerThreadEvent, thread: 4399
D/BackgroundHandlerThread: onEvent(Object), thread: 4399, class: ConnectionStateChangedEvent
D/MainActivity: onEventMainThread(ConnectionStateChangedEvent), thread: 1

類似： 具有線程安全性的eventbus的最佳實踐