Question

I am doing an Android service that gives content to other apps that can register as callback.

I am not 100% sure about how the Android Handler class works, so can someone confirm me that this code is thread safe?

public class MyService extends Service {
    private static final String MESSAGE = "message";

    private final RemoteCallbackList<IMyCallback> readerCallbacks = new RemoteCallbackList<IMyCallback>();

    private static final int REPORT_MSG = 1;

    private Thread readerThread;

    @Override
    public void onCreate() {

        readerThread = new Thread(readerRunnable);
        readerThread.setDaemon(true);
        readerThread.start();

    }

    private Runnable readerRunnable = new Runnable() {
        @Override
        public void run() {
            while (!Thread.interrupted()) {

                // Blocking call
                byte[] message = JniCommunicator.readMessage();

                if (message == null || message.length == 0) {
                    continue;
                }

                Bundle b = new Bundle();
                b.putByteArray(MESSAGE, message);
                Message m = readHandler.obtainMessage(REPORT_MSG);
                m.setData(b);
                readHandler.sendMessage(m);
            }
        }
    };

    private final Handler readHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {

            switch (msg.what) {
            case REPORT_MSG:

                byte[] message = msg.getData().getByteArray(MESSAGE);

                // Broadcast the new message to all clients
                final int N = readerCallbacks.beginBroadcast();
                for (int i = 0; i < N; i++) {
                    try {
                        readerCallbacks.getBroadcastItem(i).newMessage(message);
                    } catch (RemoteException e) {
                        // The RemoteCallbackList will take care of removing
                        // the dead object for us.
                    }
                }
                readerCallbacks.finishBroadcast();

                break;
            }
        }
    };

        @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    private final IService.Stub mBinder = new IService.Stub() {

        public void registerCallback(IMyCallback cb) {
            if (cb != null)
                readerCallbacks.register(cb);
        }

        public void unregisterCallback(IMyCallback cb) {
            if (cb != null)
                readerCallbacks.unregister(cb);
        }
    };
}

In particular, if someone calls unregisterCallback() while the Handler is in the for loop, will it crash?

From my understanding, the Handler run in the same thread, so it is thread safe, but I am not sure.

Thanks

Answer 1

Handlers are thread safe, that is their entire purpose.
I’ll agree that the documentation on the thread safety of handlers isn’t the best but it would be very ironic if a class designed to communicate between thread weren’t thread safe.

About the remote callbacks, they are also designed to be thread safe, you should read the documentation on this, it states clearly:

Performs locking of the underlying list of interfaces to deal with multithreaded incoming calls, and a thread-safe way to iterate over a snapshot of the list without holding its lock

All you have to make sure is that all variables multiple thread access are thread safe (which they are in your case) and that they aren’t being changed (yours are final so no worries there either)