调用 removeCallbacks() 时，在新线程上启动的可运行对象不会停止

Question

我有以下代码。

//This is global for the activity.
Handler handler = new Handler()
{
    @Override
    public void handleMessage(Message msg)
    {   
               //update the UI
    }
};

在我的 onResume() 中，我正在启动一个运行可运行对象的新线程。

protected void onResume()
{
    super.onResume();

    Thread t = new Thread(runnable);
    t.start();
}

我的runnable如下：

Runnable runnable = new Runnable()
{
    public void run()
    {
                  // some networking stuff 
                  // some db stuff
                  // whatever


        handler.sendEmptyMessage(0);
        handler.postDelayed(new Runnable()
        {
            public void run()
            {
                new Thread(runnable).start();
            }
        }, 30000);
    }
}

我在 onPause() 里面有这个：

protected void onPause()
    {       
        super.onPause();
            handler.removeCallbacks(runnable);
    }

最后我调用handler.sendEmptyMessage(0);，以便调用handleMessage(Message msg)并更改UI，我重复任务但启动一个新的runnable，它启动一个运行与此相同的runnable的新线程.

澄清问题：

1. 我正在我的 onResume() 中启动一个新线程，这意味着可运行对象没有在 UI 线程上运行，但是，处理程序是在 UI 线程上创建的，并且自然附加到 UI 线程. UI 是如何完美改变的？

2. 它应该用于 handler.removeCallbacks(runnable)，但是，每当我最小化应用程序时，runnable 仍然每 30 秒运行一次。 （这可能是因为它在一个新线程上，与创建的处理程序无关）。我怎样才能让它停止？

Answer 1

public class MainActivity extends Activity {

    public static final int UPDATE = 1;
    public static final int WORK = 2;

    private Handler uiHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case UPDATE:
                // Perform UI updates here
                ....
                // UI Updates done, schedule WORK in 30 seconds:
                this.sendMessageDelayed(this.obtainMessage(WORK), 30000);
                break;
            case WORK:
                new Thread(doWork).start();
                break;

            default:
                super.handleMessage(msg);
            }
        }

    };

private WeakReference<Handler> handlerRef = new WeakReference<Handler>( uiHandler );

    private Runnable doWork = new Runnable() {

        @Override
        public void run() {
            // This will run on a different thread.

            // If UI is still around, tell it to update
            Handler ui = handlerRef.get();
            if( ui != null )
                ui.sendEmptyMessage(MainActivity.UPDATE);
        }
    };  

    @Override
    protected void onPause() {
        uiHandler.removeMessages(WORK);
        super.onPause();
    }

    @Override
    protected void onResume() {
        super.onResume();
        // Resume UI updates in 500ms, allowing UI to settle
        uiHandler.sendMessageDelayed(uiHandler.obtainMessage(WORK), 500);
    }

    ....
}

此模式在 UI 线程上使用单个处理程序。后台工作在 Runnable 中完成，ui 处理程序将发布到新线程，因此避免 NetworkOnMainThreadException 和 - 更重要的是 - 无响应的 UI。此外，在后台进程完成后 30 秒安排新的更新，以避免长时间运行的更新对系统造成负担。后台线程使用WeakReference 到ui 处理程序，所以如果Activity 在线程工作时被杀死，它不会向它发送UI 更新。