您应该使用活动处理程序调用所有活动操作。因此，如果你在某个线程中，你应该创建一个Runnable，并使用活动的处理程序发布。否则你的应用程序有时会崩溃，出现致命异常。

为了找到解决这个困境的方法，我已经辛苦了一个星期，而不是求助于编辑清单文件。这个解决方案的假设是:

您总是需要使用进度对话框 一次只执行一个任务 您需要在电话旋转时保持任务，并且进度对话框将自动退出。

实现

你需要将这篇文章底部的两个文件复制到你的工作区中。只要确保:

你所有的activity都应该扩展BaseActivity 在onCreate()中，super.onCreate()应该在初始化ASyncTasks需要访问的任何成员后调用。同样，重写getContentViewId()来提供表单布局id。 像往常一样重写onCreateDialog()来创建由活动管理的对话框。 请参阅下面的示例静态内部类来创建AsyncTasks。您可以将结果存储在mResult中以供以后访问。

final static class MyTask extends SuperAsyncTask<Void, Void, Void> {

    public OpenDatabaseTask(BaseActivity activity) {
        super(activity, MY_DIALOG_ID); // change your dialog ID here...
                                       // and your dialog will be managed automatically!
    }

    @Override
    protected Void doInBackground(Void... params) {

        // your task code

        return null;
    }

    @Override
    public boolean onAfterExecute() {
        // your after execute code
    }
}

最后，启动你的新任务:

mCurrentTask = new MyTask(this);
((MyTask) mCurrentTask).execute();

就是这样!我希望这个强大的解决方案能帮助到一些人。

java(自己组织导入)

protected abstract int getContentViewId();

public abstract class BaseActivity extends Activity {
    protected SuperAsyncTask<?, ?, ?> mCurrentTask;
    public HashMap<Integer, Boolean> mDialogMap = new HashMap<Integer, Boolean>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(getContentViewId());

        mCurrentTask = (SuperAsyncTask<?, ?, ?>) getLastNonConfigurationInstance();
        if (mCurrentTask != null) {
            mCurrentTask.attach(this);
            if (mDialogMap.get((Integer) mCurrentTask.dialogId) != null
                && mDialogMap.get((Integer) mCurrentTask.dialogId)) {
        mCurrentTask.postExecution();
            }
        }
    }

    @Override
    protected void onPrepareDialog(int id, Dialog dialog) {
    super.onPrepareDialog(id, dialog);

        mDialogMap.put(id, true);
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        if (mCurrentTask != null) {
            mCurrentTask.detach();

            if (mDialogMap.get((Integer) mCurrentTask.dialogId) != null
                && mDialogMap.get((Integer) mCurrentTask.dialogId)) {
                return mCurrentTask;
            }
        }

        return super.onRetainNonConfigurationInstance();
    }

    public void cleanupTask() {
        if (mCurrentTask != null) {
            mCurrentTask = null;
            System.gc();
        }
    }
}

SuperAsyncTask.java

public abstract class SuperAsyncTask<Params, Progress, Result> extends AsyncTask<Params, Progress, Result> {
    protected BaseActivity mActivity = null;
    protected Result mResult;
    public int dialogId = -1;

    protected abstract void onAfterExecute();

    public SuperAsyncTask(BaseActivity activity, int dialogId) {
        super();
        this.dialogId = dialogId;
        attach(activity);
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        mActivity.showDialog(dialogId); // go polymorphism!
    }    

    protected void onPostExecute(Result result) {
        super.onPostExecute(result);
        mResult = result;

        if (mActivity != null &&
                mActivity.mDialogMap.get((Integer) dialogId) != null
                && mActivity.mDialogMap.get((Integer) dialogId)) {
            postExecution();
        }
    };

    public void attach(BaseActivity activity) {
        this.mActivity = activity;
    }

    public void detach() {
        this.mActivity = null;
    }

    public synchronized boolean postExecution() {
        Boolean dialogExists = mActivity.mDialogMap.get((Integer) dialogId);
        if (dialogExists != null || dialogExists) {
            onAfterExecute();
            cleanUp();
    }

    public boolean cleanUp() {
        mActivity.removeDialog(dialogId);
        mActivity.mDialogMap.remove((Integer) dialogId);
        mActivity.cleanupTask();
        detach();
        return true;
    }
}

您应该使用活动处理程序调用所有活动操作。因此，如果你在某个线程中，你应该创建一个Runnable，并使用活动的处理程序发布。否则你的应用程序有时会崩溃，出现致命异常。

虽然Mark (CommonsWare)的答案确实适用于方向更改，但如果Activity被直接销毁(比如在电话的情况下)，它就会失败。

你可以通过使用一个应用对象来引用ASyncTask来处理方向变化和很少被破坏的Activity事件。

对于这个问题和解决方案，这里有一个很好的解释:

这一点完全要归功于瑞恩。

4年后，谷歌解决了问题，只是在onCreate活动中调用setRetainInstance(true)。它将在设备旋转期间保存您的活动实例。对于旧版本的Android，我也有一个简单的解决方案。

这是我的解决方案:https://github.com/Gotchamoh/Android-AsyncTask-ProgressDialog

基本步骤如下:

我使用onSaveInstanceState保存任务，如果它仍然 处理。 在onCreate我得到的任务，如果它被保存。 在onPause我放弃ProgressDialog如果它是显示。 在onResume中，如果任务仍然，我将显示ProgressDialog 处理。