How does Android/DalvikVM process Handlers?

I'm wondering how Handlers are processed in Android/DalvikVM. I'm writing an application for Android, and in one class I have a Handler method which receives messages from another class. Will the Handler method act as a Thread and be asynchronous to the run() method in the same class, or will it wait until a line of code in the run() method is finished (sort of atomic operation)? Or something else?

I'm wondering, because I want to add messages to a queue in the Handler method, and process and remove them in the run() method (producer-consumer).

My code structure:

public class Parser implements Runnable {
    public void run() {
            while(true) {
            // Remove a byte from the ring buffer and parse it
            byte b = Ringbuffer_read();
            // Parse
        try {
                Thread.sleep(40);
            } catch (InterruptedException e) {}
           }
    }

    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MESSAGE_READ:
                // Store all the received bytes in the ring buffer
                for (int i = 0; i < msg.arg1; i++) {
                    Ringbuffer_store(((byte[]) msg.obj)[i]);
                }
                break;
            }
        }
    };
}

When will the code in the handler run? Does it interrupt the code in the run() method at any point? Do I have to have some synchronization or semaphores or something around the code in the run() and handler method so that I don't c开发者_运维问答orrupt my buffer?

An Android Handler associates itself with whatever thread it is created in (assuming that thread has a looper already). By default in Android callbacks run on a thread named "main" which is also called the ui thread. Regardless of what thread the post method is called from the handleMessage method will be called from the thread that the Handler was created in (usually the "main" thread). Because the handleMessage method is always called in the same thread, only one message will be processed at a time.

If your plan is to have only a single consumer then Handler is a good choice. You will not need to remove messages from your consumer (the Handler), instead they will simply arrive in handleMessage for processing. If you want to do processing on the "main" thread then you just make a new Handler, if you want to do processing in the background to avoid ANRs you will likely want to use HandlerThread. Here's an example of a Handler running on it's own background thread:

HandlerThread handlerThread = new HandlerThread("Consumer");
handlerThread.start();
Handler consumer = new Handler(handlerThread.getLooper()) {
    public void handleMessage (Message msg) {
    }
};

Notice that in the description above class does not come into play at all because classes are how code is structured which is unrelated to what thread the code is executed on.