非静态内部类保存对包含类的引用。当你将AsyncTask声明为内部类时，它可能比包含它的Activity类存在的时间更长。这是因为对包含类的隐式引用。这将防止活动被垃圾收集，从而导致内存泄漏。

要解决问题，要么使用静态嵌套类，而不是匿名、局部和内部类，要么使用顶级类。

如何使用静态内部AsyncTask类

为了防止泄漏，可以将内部类设置为静态的。但是，这样做的问题是，您不再能够访问Activity的UI视图或成员变量。你可以传入对Context的引用，但是这样你就会面临同样的内存泄漏风险。(如果AsyncTask类有强引用，Android不能在Activity关闭后进行垃圾收集。)解决方案是对Activity(或任何你需要的Context)进行弱引用。

public class MyActivity extends AppCompatActivity {


int mSomeMemberVariable = 123;


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);


// start the AsyncTask, passing the Activity context
// in to a custom constructor
new MyTask(this).execute();
}


private static class MyTask extends AsyncTask<Void, Void, String> {


private WeakReference<MyActivity> activityReference;


// only retain a weak reference to the activity
MyTask(MyActivity context) {
activityReference = new WeakReference<>(context);
}


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


// do some long running task...


return "task finished";
}


@Override
protected void onPostExecute(String result) {


// get a reference to the activity if it is still there
MyActivity activity = activityReference.get();
if (activity == null || activity.isFinishing()) return;


// modify the activity's UI
TextView textView = activity.findViewById(R.id.textview);
textView.setText(result);


// access Activity member variables
activity.mSomeMemberVariable = 321;
}
}
}

笔记

• 据我所知，这种类型的内存泄漏危险一直存在，但我只是在Android Studio 3.0中才开始看到这种警告。很多主要的AsyncTask教程仍然没有处理它(参见在这里， 在这里， 在这里和在这里)。
• 如果AsyncTask是顶级类，也可以遵循类似的过程。静态内部类基本上与Java中的顶级类相同。
• 如果你不需要活动本身，但仍然想要上下文(例如，显示Toast)，你可以传入一个对应用程序上下文的引用。在这种情况下，AsyncTask构造函数看起来像这样:

  private WeakReference<Application> appReference;
  
  
  MyTask(Application context) {
  appReference = new WeakReference<>(context);
  }
  

• There are some arguments out there for ignoring this warning and just using the non-static class. After all, the AsyncTask is intended to be very short lived (a couple seconds at the longest), and it will release its reference to the Activity when it finishes anyway. See this and this.
• Excellent article: How to Leak a Context: Handlers & Inner Classes

Kotlin

In Kotlin just don't include the inner keyword for the inner class. This makes it static by default.

class MyActivity : AppCompatActivity() {


internal var mSomeMemberVariable = 123


override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)


// start the AsyncTask, passing the Activity context
// in to a custom constructor
MyTask(this).execute()
}


private class MyTask
internal constructor(context: MyActivity) : AsyncTask<Void, Void, String>() {


private val activityReference: WeakReference<MyActivity> = WeakReference(context)


override fun doInBackground(vararg params: Void): String {


// do some long running task...


return "task finished"
}


override fun onPostExecute(result: String) {


// get a reference to the activity if it is still there
val activity = activityReference.get()
if (activity == null || activity.isFinishing) return


// modify the activity's UI
val textView = activity.findViewById(R.id.textview)
textView.setText(result)


// access Activity member variables
activity.mSomeMemberVariable = 321
}
}
}

AsyncTask类应该是静态的，否则可能发生泄漏，因为

• 当Activity被销毁时，AsyncTask(包括static或non-static)仍在运行
• 如果内部类是non-static (AsyncTask)类，它将引用外部类(Activity)。
• 如果一个对象没有引用指向它，Garbage Collected将释放它。如果一个对象未使用并且Garbage Collected 不能 release它=>泄漏内存

=>如果AsyncTask是non-static， Activity不会释放事件，它被破坏=>泄漏

将AsyncTask作为静态类后更新UI的解决方案

public class NoLeakAsyncTaskActivity extends AppCompatActivity {
private ExampleAsyncTask asyncTask;


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


// START AsyncTask
asyncTask = new ExampleAsyncTask();
asyncTask.setListener(new ExampleAsyncTask.ExampleAsyncTaskListener() {
@Override
public void onExampleAsyncTaskFinished(Integer value) {
// update UI in Activity here
}
});
asyncTask.execute();
}


@Override
protected void onDestroy() {
asyncTask.setListener(null); // PREVENT LEAK AFTER ACTIVITY DESTROYED
super.onDestroy();
}


static class ExampleAsyncTask extends AsyncTask<Void, Void, Integer> {
private ExampleAsyncTaskListener listener;


@Override
protected Integer doInBackground(Void... voids) {
...
return null;
}


@Override
protected void onPostExecute(Integer value) {
super.onPostExecute(value);
if (listener != null) {
listener.onExampleAsyncTaskFinished(value);
}
}


public void setListener(ExampleAsyncTaskListener listener) {
this.listener = listener;
}


public interface ExampleAsyncTaskListener {
void onExampleAsyncTaskFinished(Integer value);
}
}
}