如何在 AsyncTask 中使用 Runnable.wait()？为什么 AsyncTask 不等待...？

Question

我正在使用 AsyncTask 运行后台操作。当然，在已经在后台线程中工作时切换到另一个线程通常没有多大意义，除了另一个线程是 UI 线程。这就是我想要的：当任务运行时，我需要“访问”用户界面，例如显示一个对话框，询问用户如何继续。

• 运行后台任务
• 停止任务以获取用户反馈
• 切换到 UI 线程以显示对话框并要求输入
• 切换回后台任务并继续工作

如何做到这一点？我以为我可以将Runnable 与myActivity.runOnUiThread(runnable) 一起使用，但这不起作用：

private void copyFiles() {
    CopyTask copyTask = new CopyTask(this);
    copyTask.execute();
}

// CustomAsyncTask is a AsyncTask subclass that takes a reference to the current
// activity as parameter
private class CopyTask extends CustomAsyncTask<Void, Void, Void> {
    private doCopy;

    @Override
    protected Boolean doInBackground(Void... params) {              
        // Custom code, e.g. copy files from A to B and check for conflict
        for (File file : allFiles) {
            doCopy = true;

            if (isConflict(file)) {
                // Stop current thread and ask for user feedback on UI Thread

                Runnable uiRunnable = new Runnable() {
                    public void run() {
                        // Pos 1. --> Execute custom code, e.g. use AlertDialog to ask user if file should be replaced...
                        doCopy = false;

                        synchronized (this) {
                           this.notify();
                        }
                    }
                });  

                synchronized(uiRunnable) {
                    // Execute code on UI thread
                    activity.runOnUiThread(uiRunnable);

                    // Wait until runnable finished
                    try {
                        uiRunnable.wait();
                    }
                    catch (InterruptedException e ) {
                        e.printStackTrace();
                    }
                }
            }

            // Pos 2. --> Continue work
            if (doCopy)
               copyFromAToB(File);
        }

        return null;
    }
}

在doInBackground() 内（--> 在后台线程中）AsyncTask 调用activity.runOnUiThread(uiRunnable)。接下来调用uiRunnable.wait()。关于docu wait() 应该做到以下几点：

使调用线程等待直到另一个线程调用 此对象的 notify() 或 notifyAll() 方法。

因此，后台线程应该等到this.notify() (== uiRunnable.notifiy()) 在另一个线程（= UI 线程）上被调用后才能继续工作，不是吗？

好吧，id 不等待！ 调用uiRunnable.wait() 后，后台线程立即继续跳转到if (doCopy)...。似乎后台线程和主线程是并行执行的（这并不奇怪，因为这是线程所做的......），因此无论是 UI 线程上的 doCopy = false 还是后台线程上的 if (doCopy) 都是竞争条件最先到达。

这怎么可能？为什么wait() 没有按描述工作？ 还是我有什么问题？

非常感谢！

编辑： 为了避免误解：我当然知道 AsyncTask 的生命周期方法，但据我了解，它们不是我想要的（请参阅我对评论的回复）。

一旦需要 UI 交互就中断 AsyncTask，当然可以查询 UI 并启动一个新的 AsyncTask。然而，这会导致代码非常难以阅读/理解/维护。

据我了解wait() 的文档，这里一切正常。主要问题不是如何在 AsyncTask 的生命周期中进行 UI 交互，而是为什么 wait() 不能按预期工作。

Answer 1

基础知识

当您首先启动 AsyncTask 时，onPreExecute() 方法会在 UI 线程上运行。您可以覆盖此方法以在 doInBackground() 方法运行之前对 UI 进行更改。

doInBackground() 方法完成后，onPostExecute() 方法在 UI 线程上运行，因此您可以使用它从此处对 UI 进行更改。如果您需要在doInBackground() 方法期间 对 UI 线程进行定期更改，请覆盖在 UI 线程上运行的 onProgressUpdate() 方法，然后从 doInBackground() 中调用它，这将允许您定期更新 UI。

你可以使用类似下面的东西；

private class DoStuffTask extends AsyncTask {

   @Override
   protected void doInBackground(Object... args) {
       // Do stuff
       onProgressUpdate(x);
       // Do more stuff
   }

   @Override
   protected void onProgressUpdate(Object... args) {
       // Update your UI here
   }
}

现在，如果这还不能完全做到，并且您希望 AsyncTask 在doInBackground() 方法期间等待输入，那么可能值得考虑使用多个AsyncTasks。然后您可以完成每个AsyncTask，请求输入，然后开始一个新的AsyncTask 以继续工作。

鉴于AlertDialog 实例是异步的，这可能是首选解决方案，因为您可以从AlertDialog 本身启动下一个AsyncTask。

在 AsyncTask 中使用 wait()

如果您希望使用单个 AsyncTask，您可以在 AsyncTask 中使用 wait 来阻止执行继续，直到满足某些条件。在这个实例中，我们只使用两个线程，而不是使用新的Runnable，运行doInBackground() 的线程和主线程，我们在AsycTask 本身上进行同步。

以下示例；

public class TestTask extends AsyncTask{

    private boolean notified;
    private Promptable p;
    public interface Promptable { public abstract void prompt(); }

    public TestTask(Promptable p){
        this.p = p;
    }

    @Override
    protected Object doInBackground(Object... arg0) {
        Log.d("First", "First");
        onProgressUpdate(null);
        synchronized(this){
            while(!notified){
                try{
                    this.wait();
                }
                catch(InterruptedException e){ }                    
            }
        }
        Log.d("Second", "Second");
        return null;
    }

    @Override 
    protected void onProgressUpdate(Object... args){       
        synchronized(this){
            notified = true;
            p.prompt();               
            this.notify();
        }
    }
}

在上面的示例中，假设您的Activity 被解析为AsyncTask 的构造函数，并且它实现了我们创建的名为Promptable 的接口。您会注意到，即使我们调用wait()，我们也将其置于一个while 循环中。如果我们不这样做，并且以某种方式在wait() 之前调用了notify()，那么您的线程将无限期锁定。此外，您不能依赖线程将永远等待这一事实，因此 while 循环可确保在调用 notify 之前它不会继续。

我希望这会有所帮助。