在调用另一个线程的处理程序之前，如何确保它不为空？

Question

有一天，当我的程序尝试使用在另一个线程上创建的处理程序向该线程发送消息时，它抛出了 NullPointerException。尽管调用线程已经在另一个线程上调用了 start，但另一个线程创建的 Handler 尚未创建，或者对于调用线程尚不可见。这种情况很少发生。几乎每次测试运行都没有出现异常。

我想知道最好的方法是什么，以最小的复杂性和性能损失来避免这个问题。该程序是一个游戏，对性能非常敏感，尤其是在运行时。因此，例如，我尝试避免在设置后使用同步，并且更愿意避免随时旋转变量。

背景：
在 Android 中，Handler 类可用于“将要在与您自己的线程不同的线程上执行的操作排队”。文档在这里：
http://developer.android.com/intl/de/reference /android/os/Handler.html

Handler 必须在使用它的线程上创建。因此，在线程的构造函数中创建它（该线程由创建该线程的线程运行）不是一种选择。

当Handler用于UI线程以外的线程时，还必须使用Looper类：
http://developer.android.com/intl/de/reference /android/os/Looper.html

文档给出了为此目的使用两个类的示例：

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop();
    }
}

我非常丑陋的解决方法目前看起来像这样：

public class LooperThread extends Thread {

    public volatile Handler mHandler;

    public final ArrayBlockingQueue<Object> setupComplete = new ArrayBlockingQueue<Object>(1);

    public void run() {
        Looper.prepare();

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        setupComplete();

        Looper.loop();
    }

    public void waitForSetupComplete() {
        while ( true ) {
            try {
                setupComplete.take();
                return;
            } catch (InterruptedException e) {
                //Ignore and try again.
            }
        }
    }

    private void setupComplete() {
        while( true ) {
            try {
                setupComplete.put(new Object());
                return;
            } catch (InterruptedException e) {
                //Ignore and try again.
            }        
        }
    }

}

创建线程中的代码看起来像这样：

    LooperThread otherThread = new LooperThread();
    otherThread.start();        
    otherThread.waitForSetupComplete();
    otherThread.mHandler.sendEmptyMessage(0);

有没有更好的方法解决方案？谢谢。

Answer 1

我会选择

public class LooperThread extends Thread {

    private Handler mHandler;

    public void run() {
        Looper.prepare();

        synchronized (this) {
            mHandler = new Handler() {
                public void handleMessage(Message msg) {
                    // process incoming messages here
                }
            };
            notifyAll();
        }

        Looper.loop();
    }

    public synchronized Handler getHandler() {
        while (mHandler == null) {
            try {
                wait();
            } catch (InterruptedException e) {
                //Ignore and try again.
            }
        }
        return mHandler;
    }
}

从 getHandler 返回的经典等待/通知处理程序，然后可以多次使用而无需调用同步 getHandler。

Answer 2

准备 Looper 可能会阻塞一段时间，所以我想您遇到了 prepare() 需要一段时间才能完成的情况，因此 mHandler > 仍未定义。

您可以让您的 Thread 扩展 HandlerThread，但即便如此，您仍然必须等待以确保 Looper 已初始化。也许这样的事情可能会起作用，您单独定义了 Handler ，但利用了自定义线程的 Looper 。

或许。

private void setUp() {
    mHandlerThread = new CustomThread("foo", Process.THREAD_PRIORITY_BACKGROUND);
    mHandlerThread.start();

    // Create our handler; this will block until looper is initialised
    mHandler = new CustomHandler(mHandlerThread.getLooper());
    // mHandler is now ready to use
}

private class CustomThread extends HandlerThread {
    public void run() {
        // ...
    }
}   

private class CustomHandler extends Handler {
    CustomHandler(Looper looper) {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
        // ...
    }
}

Answer 3

我只是想补充一点，检查的答案是最好的答案，但如果你像这样测试它是行不通的，因为你需要在运行方法上调用 super ，因为它负责准备循环器，所以代码应该是这样的：

private void setUp() {
  mHandlerThread = new CustomThread("foo", Process.THREAD_PRIORITY_BACKGROUND);
  mHandlerThread.start();

  // Create our handler; this will block until looper is initialised
  mHandler = new CustomHandler(mHandlerThread.getLooper());
  // mHandler is now ready to use
}

private class CustomThread extends HandlerThread {
   public void run() {
    super.run() // <- VERY IMPORTANT OTHERWISE IT DOES NOT WORK
    // your code goes here
   }
}   

private class CustomHandler extends Handler {
CustomHandler(Looper looper) {
    super(looper);
}

 @Override
 public void handleMessage(Message msg) {
    // ...
 }

}