Loopers、Handlers与Threads：主线程向工作线程传字节数组示例请求

Got it, let's clear up your confusion first—you're right that most examples use Handler with the main thread's Looper, which is why their code runs on the UI thread. But Handler can absolutely be tied to a worker thread's Looper, letting you send data from the main thread to a background thread easily. Let's walk through a few practical approaches, from simple to modern:

1. Simple Thread with Parameter (One-Time Data Pass) #

If you just need to send the byte array once and don't need ongoing communication, this is the easiest way. We'll create a custom Runnable that holds your data, then pass it to a Thread.

// Inside MainActivity (main thread)
byte[] yourByteArray = ...; // Your byte array data

// Create a worker thread with your data
Thread workerThread = new Thread(new ByteArrayRunnable(yourByteArray));
workerThread.start();

// Custom Runnable to hold the byte array
private static class ByteArrayRunnable implements Runnable {
    private final byte[] data;

    public ByteArrayRunnable(byte[] data) {
        this.data = data;
    }

    @Override
    public void run() {
        // This runs on the worker thread—no UI blocking!
        processByteArray(data);
    }
}

// Your actual data processing logic
private void processByteArray(byte[] data) {
    // Do heavy work here: parsing, encryption, file I/O, etc.
}

2. Handler + Looper (For Ongoing Communication) #

If you need to send multiple batches of data to the worker thread over time, this approach works well. We'll initialize a Looper in the worker thread, then create a Handler tied to that Looper—so any messages sent to this Handler will be processed in the background.

private Handler workerHandler;

// Call this from MainActivity to start the worker thread
private void startWorkerThread() {
    Thread workerThread = new Thread(() -> {
        // Initialize the worker thread's Looper
        Looper.prepare();

        // Create a Handler bound to this worker thread's Looper
        workerHandler = new Handler(Looper.myLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                // This runs on the worker thread
                byte[] data = (byte[]) msg.obj;
                if (data != null) {
                    processByteArray(data);
                }
            }
        };

        // Keep the thread alive to listen for messages
        Looper.loop();
    });
    workerThread.start();
}

// Call this from the main thread to send data to the worker
private void sendDataToWorker(byte[] data) {
    if (workerHandler != null) {
        Message msg = workerHandler.obtainMessage();
        msg.obj = data;
        workerHandler.sendMessage(msg);
    }
}

// Clean up to avoid memory leaks when the activity is destroyed
@Override
protected void onDestroy() {
    super.onDestroy();
    if (workerHandler != null) {
        workerHandler.getLooper().quitSafely();
    }
}

3. Kotlin Coroutines (Android's Recommended Modern Approach) #

If you're using Kotlin, coroutines simplify background threading a lot and are the current best practice for Android. They let you write async code that looks synchronous, and easily switch between threads.

// Inside MainActivity (Kotlin)
val yourByteArray: ByteArray = ... // Your byte array data

// Launch a coroutine on the IO thread (for heavy work)
lifecycleScope.launch(Dispatchers.IO) {
    // This runs on a background thread
    processByteArray(yourByteArray)
    
    // If you need to update the UI after processing, switch back to main thread
    withContext(Dispatchers.Main) {
        // Update UI elements here (e.g., show a success message)
    }
}

// Your data processing function
private fun processByteArray(data: ByteArray) {
    // Do your heavy work here: parsing, network calls, etc.
}

Quick Clarification on Your Handler Confusion #

The key point you missed: a Handler is tied to the Looper of the thread it's created in. Most examples create Handler in the main thread (which has a default Looper), so their handleMessage runs on the UI thread. But if you create a Handler inside a worker thread after initializing Looper, that Handler will process messages in the worker thread—exactly what you need!

内容的提问来源于stack exchange，提问作者Noam Azoulay