弯针，处理程序和线程

Question

I'm wishing to pass a byte array from the main thread of a application (MainActivity) to a "working thread" so that I can do whatever I wanna do in the working thread without blocking the UI (Main Thread). So I read about Looper and Handler but I didn't understood it because I read that everything Im writing in the handler is done in the main thread, but I only want to pass arguments/data from the Main thread to the other thread. Can someone please give me an example?

Answer 1

Handlers process messages and Runnable objects that are dispatched from a Looper. Newly created threads do not have a Looper by default as they are usually created to perform a specific task. If you want a thread to sit and process messages from other threads then you can create a Looper for that thread plus a handler that uses the looper

This is a very simple example and there are probably other ways of doing it:

public class TestActivity extends AppCompatActivity {

TestThread thread;


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_test);

    thread = new TestThread();
    thread.start();
}



public void testClick(View view) {
    // Check that handler object is assigned, as handler is initialised by the thread
    // itself after it has started running
    if(thread.handler != null) thread.handler.sendMessage(thread.handler.obtainMessage(123, new byte[12]));
}



private class TestThread extends Thread {

    Handler handler;


    @Override
    @SuppressLint("HandlerLeak")
    public void run() {
        // Creates the Looper object for this thread
        Looper.prepare();

        // Default Handler constructor uses the Looper of the current thread (the Looper we just created)
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // Handle message here, running within the thread
                if((msg.what == 123) && (msg.obj != null) && (msg.obj instanceof byte[]))
                    Log.d("Test", Integer.toString(((byte[])msg.obj).length) + " byte(s) received");
            }
        };

        // Does the work of actually looping and processing messages. This will
        // not return until the thread is being terminated
        Looper.loop();
    }

}

Here is the activity:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".TestActivity">
<Button
    android:id="@+id/button2"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginStart="16dp"
    android:layout_marginTop="16dp"
    android:onClick="testClick"
    android:text="Test"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
</android.support.constraint.ConstraintLayout>

You can also create Handlers that uses the main thread's Looper. This is done so that to your thread can send messages back to the main thread. In that instance you create your handler like this:

Handler handler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        // Process message within main UI thread
    }
};

To sum it up, Handlers execute within the thread that is running a particular Looper. So if you send a message to a handler that is using the main UI thread's Looper then the code will execute in the main UI thread. If you send the message to a Handler that has it's own Looper that runs within a different thread, then it will run within that particular thread.

[Edit] Hmmm. Reading back, my answer's still not totally clear so let me explain what's happening in the example: Here, the onCreate() method runs within the UI thread and creates another thread (we'll call it Thread2). It then starts Thread2 which creates a Looper and Handler and then sits in an infinite loop, processing messages it receives by calling Looper.loop()

When the Test button is clicked a message is sent to the Thread2 Handler. Thread2, which is doing nothing but sitting there waiting for messages, notices the new message and passes it on to the Handler which calls the overridden handleMessage() method, which writes to the log. Thread2 then resumes it's task of waiting for messages