我在代码中收到一条警告，指出：

此AsyncTask类应该是静态的，否则可能会发生泄漏（匿名android.os.AsyncTask）

完整的警告是：

此AsyncTask类应该是静态的，否则可能会发生泄漏（匿名android.os.AsyncTask）。静态字段将泄漏上下文。非静态内部类对其外部类具有隐式引用。如果该外部类例如是Fragment或Activity，则此引用意味着长时间运行的处理程序/加载器/任务将持有对该活动的引用，从而防止该活动获取垃圾。同样，对这些较长运行实例的活动和片段的直接字段引用也可能导致泄漏。ViewModel类永远不要指向视图或非应用程序上下文。

这是我的代码：

 new AsyncTask<Void,Void,Void>(){

        @Override
        protected Void doInBackground(Void... params) {
            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    mAdapter.notifyDataSetChanged();
                }
            });

            return null;
        }
    }.execute();

我该如何纠正？

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

要解决您的问题，请使用静态嵌套类而不是匿名，本地和内部类，或使用顶级类。

如何使用静态内部AsyncTask类

为了防止泄漏，可以将内部类设为静态。但是，这样做的问题是您不再有权访问活动的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中的顶级类相同。

• 如果您不需要Activity本身，但仍想要Context（例如显示Toast），则可以传递对应用程序上下文的引用。在这种情况下，AsyncTask构造函数将如下所示：

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

• 有一些参数可以忽略此警告，而仅使用非静态类。毕竟，AsyncTask的寿命很短（最长为几秒钟），并且无论如何完成它都会释放对Activity的引用。看到这个和这个。
• 优秀文章：如何泄漏上下文：处理程序和内部类

科特林

在Kotlin中，只是不要包括inner内部类的关键字。默认情况下将其设为静态。

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 不能释放它=>泄漏内存

=>如果AsyncTask为non-static，Activity则不会释放事件，它会被销毁=>泄漏

使AsyncTask成为静态类而没有泄漏后更新UI的解决方案

1）使用WeakReference类似@Suragch的答案
2）发送并删除Activity对（from）的引用AsyncTask

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);
        }
    }
}