在使用AsyncTask时，有必要创建一个类继任者，并在其中注册我们所需的方法的实现。本节课我们将学习三种方法:

doInBackground -将在一个新线程中执行，在这里我们解决了所有困难的任务。因为非主线程不能访问UI。

onPreExecute -在doInBackground之前执行，并可以访问UI

onPostExecute -在doInBackground之后执行(如果AsyncTask被取消就不工作-关于这个在下一课中)，并可以访问UI。

这是MyAsyncTask类:

class MyAsyncTask extends AsyncTask<Void, Void, Void> {

  @Override
  protected void onPreExecute() {
    super.onPreExecute();
    tvInfo.setText("Start");
  }

  @Override
  protected Void doInBackground(Void... params) {
    // Your background method
    return null;
  }

  @Override
  protected void onPostExecute(Void result) {
    super.onPostExecute(result);
    tvInfo.setText("Finish");
  }
}

这是如何调用你的Activity或Fragment:

MyAsyncTask myAsyncTask = new MyAsyncTask();
myAsyncTask.execute();

好的，您正在尝试通过另一个线程访问GUI。总的来说，这不是一种好的做法。

AsyncTask在另一个线程中执行doInBackground()中的所有内容，该线程不能访问视图所在的GUI。

preExecute()和postExecute()提供了在这个新线程中发生重大操作之前和之后访问GUI的权限，甚至可以将长时间操作的结果传递给postExecute()，然后显示处理的任何结果。

看到这些行，你稍后更新你的TextView:

TextView txt = findViewById(R.id.output);
txt.setText("Executed");

把它们放在onPostExecute()中。

然后你会看到你的TextView文本更新后，doInBackground完成。

我注意到你的onClick监听器没有检查哪个视图已被选中。我发现最简单的方法是通过switch语句。我有一个完整的类编辑下面所有的建议，以避免混乱。

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.provider.Settings.System;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.view.View.OnClickListener;

public class AsyncTaskActivity extends Activity implements OnClickListener {

    Button btn;
    AsyncTask<?, ?, ?> runningTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        btn = findViewById(R.id.button1);

        // Because we implement OnClickListener, we only
        // have to pass "this" (much easier)
        btn.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        // Detect the view that was "clicked"
        switch (view.getId()) {
        case R.id.button1:
            if (runningTask != null)
                runningTask.cancel(true);
            runningTask = new LongOperation();
            runningTask.execute();
            break;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Cancel running task(s) to avoid memory leaks
        if (runningTask != null)
            runningTask.cancel(true);
    }

    private final class LongOperation extends AsyncTask<Void, Void, String> {

        @Override
        protected String doInBackground(Void... params) {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // We were cancelled; stop sleeping!
                }
            }
            return "Executed";
        }

        @Override
        protected void onPostExecute(String result) {
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText("Executed"); // txt.setText(result);
            // You might want to change "executed" for the returned string
            // passed into onPostExecute(), but that is up to you
        }
    }
}

移动这两条线:

TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");

你的AsyncTask的doInBackground方法，并把它们放在onPostExecute方法。你的AsyncTask应该看起来像这样:

private class LongOperation extends AsyncTask<String, Void, String> {

    @Override
    protected String doInBackground(String... params) {
        try {
            Thread.sleep(5000); // no need for a loop
        } catch (InterruptedException e) {
            Log.e("LongOperation", "Interrupted", e);
            return "Interrupted";
        }
        return "Executed";
    }      

    @Override
    protected void onPostExecute(String result) {               
        TextView txt = (TextView) findViewById(R.id.output);
        txt.setText(result);
    }
}

我建议使用这个库来做背景工作，让你的生活更轻松:

https://github.com/Arasthel/AsyncJobLibrary

就是这么简单……

AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {

    @Override
    public void doOnBackground() {
        startRecording();
    }
});

这里的概念和代码

我已经创建了一个简单的例子使用AsyncTask的Android。它从onPreExecute()， doInBackground()， publishProgress()开始，最后是onProgressUpdate()。

在这种情况下，doInBackground()作为后台线程工作，而其他线程在UI线程中工作。你不能访问doInBackground()中的UI元素。顺序和我之前提到的一样。

然而，如果你需要从doInBackground更新任何小部件，你可以从doInBackground发布进度，它会调用onProgressUpdate来更新你的UI小部件。

class TestAsync extends AsyncTask<Void, Integer, String> {
    String TAG = getClass().getSimpleName();

    protected void onPreExecute() {
        super.onPreExecute();
        Log.d(TAG + " PreExceute","On pre Exceute......");
    }

    protected String doInBackground(Void...arg0) {
        Log.d(TAG + " DoINBackGround", "On doInBackground...");

        for (int i=0; i<10; i++){
            Integer in = new Integer(i);
            publishProgress(i);
        }
        return "You are at PostExecute";
    }

    protected void onProgressUpdate(Integer...a) {
        super.onProgressUpdate(a);
        Log.d(TAG + " onProgressUpdate", "You are in progress update ... " + a[0]);
    }

    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        Log.d(TAG + " onPostExecute", "" + result);
    }
}

在你的活动中这样称呼它:

new TestAsync().execute();

开发人员参考资料

我的完整答案在这里，但这里有一个解释性的图像来补充本页上的其他答案。对我来说，理解所有变量的走向是最让我困惑的部分。