コードに次のような警告が表示されます。

このAsyncTaskクラスは静的でなければなりません。そうでないとリークが発生する可能性があります（匿名のandroid.os.AsyncTask）

完全な警告は次のとおりです。

このAsyncTaskクラスは静的である必要があります。そうしないとリークが発生する可能性があります（匿名のandroid.os.AsyncTask）。静的フィールドはコンテキストをリークします。非静的内部クラスには、外部クラスへの暗黙的な参照があります。その外部クラスが例えばフラグメントまたはアクティビティである場合、この参照は、実行時間の長いハンドラー/ローダー/タスクが、ガベージコレクションが実行されないようにするアクティビティへの参照を保持することを意味します。同様に、これらの長時間実行インスタンスからのアクティビティとフラグメントへの直接フ​​ィールド参照は、リークを引き起こす可能性があります。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は閉じた後、アクティビティをガベージコレクションできません。）解決策は、アクティビティ（または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);
  }

• この警告を無視し、非静的クラスを使用するだけの理由はいくつかあります。結局のところ、AsyncTaskは非常に短期間（最長で数秒）になるように設計されており、とにかく終了するとアクティビティへの参照を解放します。これとこれを見てください。
• 優れた記事：コンテキストをリークする方法：ハンドラーと内部クラス

コトリン

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