ฉันได้รับคำเตือนในรหัสของฉันที่ระบุว่า:

คลาส AsyncTask นี้ควรเป็นแบบคงที่หรืออาจเกิดการรั่วไหล (android.os.As.TyncTask แบบไม่ระบุชื่อ)

คำเตือนที่สมบูรณ์คือ:

คลาส AsyncTask นี้ควรเป็นแบบสแตติกหรืออาจเกิดการรั่วไหล (android.os.As.TyncTask แบบไม่ระบุชื่อ) ฟิลด์แบบสแตติกจะรั่วบริบท ชั้นในแบบไม่คงที่มีการอ้างอิงโดยนัยถึงชั้นนอกของพวกเขา หากคลาสภายนอกนั้นเป็นตัวอย่าง 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แต่แล้วคุณก็เสี่ยงต่อการรั่วไหลของหน่วยความจำแบบเดียวกัน (Android ไม่สามารถเก็บรวบรวมขยะในกิจกรรมได้หลังจากปิดถ้าคลาส AsyncTask มีการอ้างอิงที่แข็งแกร่ง) การแก้ปัญหาคือการอ้างอิงที่อ่อนแอไปยังกิจกรรม (หรืออะไรก็ตามที่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

• หากคุณไม่ต้องการกิจกรรม แต่ยังต้องการบริบท (เช่นเพื่อแสดง a Toast) คุณสามารถส่งผ่านการอ้างอิงถึงบริบทแอป ในกรณีนี้ตัวAsyncTaskสร้างจะมีลักษณะเช่นนี้:

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

• มีข้อโต้แย้งบางอย่างที่มีสำหรับการละเว้นคำเตือนนี้และเพียงแค่ใช้คลาสที่ไม่คงที่ ท้ายที่สุด, AsyncTask ตั้งใจจะสั้นมาก (สองสามวินาทีที่ยาวที่สุด), และมันจะปล่อยการอ้างอิงถึงกิจกรรมเมื่อเสร็จสิ้นต่อไป. ดูนี้และนี้
• บทความที่ยอดเยี่ยม: วิธีการรั่วบริบท: ตัวจัดการ & ชั้นใน

Kotlin

ใน 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จะไม่ปล่อยเหตุการณ์จะถูกทำลาย => การรั่วไหล

โซลูชั่นสำหรับการอัปเดต UI หลังจากทำให้ AsyncTask เป็นคลาสแบบสแตติก

1) ใช้WeakReferenceเช่น @Suragch คำตอบ
2) ส่งและลบActivityการอ้างอิงถึง (จาก)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);
        }
    }
}