Làm thế nào để tạo một chuỗi Looper, sau đó gửi tin nhắn ngay lập tức?

Question 1

Tôi có một chuỗi công nhân nằm ở chế độ nền, xử lý tin nhắn. Một cái gì đó như thế này:

class Worker extends Thread {

    public volatile Handler handler; // actually private, of course

    public void run() {
        Looper.prepare();
        mHandler = new Handler() { // the Handler hooks up to the current Thread
            public boolean handleMessage(Message msg) {
                // ...
            }
        };
        Looper.loop();
    }
}

Từ chuỗi chính (chuỗi giao diện người dùng, không quan trọng), tôi muốn làm điều gì đó như sau:

Worker worker = new Worker();
worker.start();
worker.handler.sendMessage(...);

Vấn đề là điều này đặt ra cho tôi một điều kiện chạy đua đẹp: tại thời điểm worker.handlerđược đọc, không có cách nào để chắc chắn rằng chuỗi công nhân đã được chỉ định cho trường này!

Tôi không thể chỉ đơn giản tạo ra Handlertừ hàm tạo của Worker', bởi vì hàm tạo chạy trên luồng chính, vì vậy Handlersẽ liên kết chính nó với luồng sai.

Đây dường như là một kịch bản không phổ biến. Tôi có thể nghĩ ra một số cách giải quyết, tất cả chúng đều xấu xí:

Một cái gì đó như thế này:

class Worker extends Thread {

    public volatile Handler handler; // actually private, of course

    public void run() {
        Looper.prepare();
        mHandler = new Handler() { // the Handler hooks up to the current Thread
            public boolean handleMessage(Message msg) {
                // ...
            }
        };
        notifyAll(); // <- ADDED
        Looper.loop();
    }
}

Và từ chủ đề chính:

Worker worker = new Worker();
worker.start();
worker.wait(); // <- ADDED
worker.handler.sendMessage(...);

Nhưng điều này cũng không đáng tin cậy: nếu điều này notifyAll()xảy ra trước wait(), thì chúng ta sẽ không bao giờ bị đánh thức!

Chuyển một ký tự đầu tiên Messagecho hàm tạo Workercủa ', có run()phương thức đăng nó. Một giải pháp đặc biệt, sẽ không hoạt động cho nhiều thư hoặc nếu chúng tôi không muốn gửi ngay nhưng phải gửi ngay sau đó.
Bận-chờ cho đến khi handlerruộng không còn null. Đúng, phương sách cuối cùng ...

Tôi muốn tạo Handlervà MessageQueuethay mặt cho Workerchuỗi, nhưng điều này dường như không thể thực hiện được. Cách thanh lịch nhất trong số này là gì?

Question 2

Giải pháp cuối cùng (trừ kiểm tra lỗi), nhờ CommonsWare:

class Worker extends HandlerThread {

    // ...

    public synchronized void waitUntilReady() {
        d_handler = new Handler(getLooper(), d_messageHandler);
    }

}

Và từ chủ đề chính:

Worker worker = new Worker();
worker.start();
worker.waitUntilReady(); // <- ADDED
worker.handler.sendMessage(...);

Điều này hoạt động nhờ vào ngữ nghĩa của HandlerThread.getLooper()khối nào cho đến khi khởi tạo vòng lặp.

Ngẫu nhiên, điều này tương tự với giải pháp số 1 của tôi ở trên, vì HandlerThreadnó được triển khai gần như như sau (phải thích mã nguồn mở):

public void run() {
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Looper.loop();
}

public Looper getLooper() {
    synchronized (this) {
        while (mLooper == null) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

Sự khác biệt chính là nó không kiểm tra xem luồng công nhân có đang chạy hay không, nhưng nó đã thực sự tạo một trình lặp; và cách để làm như vậy là lưu trữ trình lặp trong một trường riêng tư. Đẹp!

Question 3

hãy xem mã nguồn của HandlerThread

@Override
     public void run() {
         mTid = Process.myTid();
         Looper.prepare();
         synchronized (this) {
             mLooper = Looper.myLooper();
             notifyAll();
         }
         Process.setThreadPriority(mPriority);
         onLooperPrepared();
         Looper.loop();
         mTid = -1;
     }

Về cơ bản, nếu bạn đang mở rộng Thread trong worker và triển khai Looper của riêng mình, thì lớp luồng chính của bạn sẽ mở rộng worker và đặt trình xử lý của bạn ở đó.

Question 4

Đây là giải pháp của tôi: MainActivity:

//Other Code

 mCountDownLatch = new CountDownLatch(1);
        mainApp = this;
        WorkerThread workerThread = new WorkerThread(mCountDownLatch);
        workerThread.start();
        try {
            mCountDownLatch.await();
            Log.i("MsgToWorkerThread", "Worker Thread is up and running. We can send message to it now...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Toast.makeText(this, "Trial run...", Toast.LENGTH_LONG).show();
        Message msg = workerThread.workerThreadHandler.obtainMessage();
        workerThread.workerThreadHandler.sendMessage(msg);

Lớp WorkerThread:

public class WorkerThread extends Thread{

    public Handler workerThreadHandler;
    CountDownLatch mLatch;

    public WorkerThread(CountDownLatch latch){

        mLatch = latch;
    }


    public void run() {
        Looper.prepare();
        workerThreadHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {

                Log.i("MsgToWorkerThread", "Message received from UI thread...");
                        MainActivity.getMainApp().runOnUiThread(new Runnable() {

                            @Override
                            public void run() {
                                Toast.makeText(MainActivity.getMainApp().getApplicationContext(), "Message received in worker thread from UI thread", Toast.LENGTH_LONG).show();
                                //Log.i("MsgToWorkerThread", "Message received from UI thread...");
                            }
                        });

            }

        };
        Log.i("MsgToWorkerThread", "Worker thread ready...");
        mLatch.countDown();
        Looper.loop();
    }
}

Question 5

    class WorkerThread extends Thread {
            private Exchanger<Void> mStartExchanger = new Exchanger<Void>();
            private Handler mHandler;
            public Handler getHandler() {
                    return mHandler;
            }
            @Override
            public void run() {
                    Looper.prepare();
                    mHandler = new Handler();
                    try {
                            mStartExchanger.exchange(null);
                    } catch (InterruptedException e) {
                            e.printStackTrace();
                    }
                    Looper.loop();
            }

            @Override
            public synchronized void start() {
                    super.start();
                    try {
                            mStartExchanger.exchange(null);
                    } catch (InterruptedException e) {
                            e.printStackTrace();
                    }
            }
    }