AsyncTask มีข้อบกพร่องทางแนวคิดจริงๆหรือฉันแค่ทำบางสิ่งหายไป?

ฉันได้ตรวจสอบปัญหานี้มาหลายเดือนแล้วและหาวิธีแก้ปัญหาที่แตกต่างกันไปซึ่งฉันไม่พอใจเพราะมันเป็นแฮ็คขนาดใหญ่ ฉันยังไม่สามารถเชื่อได้ว่าคลาสที่มีข้อบกพร่องด้านการออกแบบทำให้มันเข้ากับกรอบงานและไม่มีใครพูดถึงมันดังนั้นฉันคิดว่าฉันต้องพลาดบางสิ่งบางอย่าง

AsyncTaskปัญหาอยู่ที่ ตามเอกสารนั้น

"อนุญาตให้ดำเนินการพื้นหลังและเผยแพร่ผลลัพธ์บนเธรด UI โดยไม่ต้องจัดการกับเธรดและ / หรือตัวจัดการ"

ตัวอย่างแล้วยังแสดงให้เห็นว่าบางอย่างที่เป็นแบบอย่างวิธีการที่เรียกว่าshowDialog() onPostExecute()นี้ แต่ดูเหมือนว่าที่วางแผนอย่างสิ้นเชิงกับผมเพราะแสดงโต้ตอบเสมอต้องมีการอ้างอิงถึงที่ถูกต้องContextและ AsyncTask ไม่ต้องถืออ้างอิงที่แข็งแกร่งให้กับวัตถุบริบท

เหตุผลชัดเจน: เกิดอะไรขึ้นถ้ากิจกรรมถูกทำลายซึ่งก่อให้เกิดงาน? สิ่งนี้สามารถเกิดขึ้นได้ตลอดเวลาเช่นเนื่องจากคุณพลิกหน้าจอ หากงานนั้นจะมีการอ้างอิงถึงบริบทที่สร้างคุณไม่เพียง แต่จะถือวัตถุบริบทที่ไร้ประโยชน์ (หน้าต่างจะถูกทำลายและการโต้ตอบ UI ใด ๆจะล้มเหลวด้วยข้อยกเว้น!) คุณยังมีความเสี่ยงในการสร้าง หน่วยความจำรั่ว

ยกเว้นว่าตรรกะของฉันมีข้อบกพร่องนี่แปลเป็น: onPostExecute()ไร้ประโยชน์อย่างสิ้นเชิงเพราะวิธีนี้จะทำงานบนเธรด UI ได้ดีเพียงใดหากคุณไม่สามารถเข้าถึงบริบทใด ๆ คุณไม่สามารถทำอะไรที่มีความหมายได้ที่นี่

วิธีแก้ปัญหาหนึ่งคือการไม่ส่งอินสแตนซ์บริบทไปยัง AsyncTask แต่เป็นHandlerอินสแตนซ์ ใช้งานได้: เนื่องจากตัวจัดการผูกบริบทและภารกิจไว้อย่างหลวม ๆ คุณสามารถแลกเปลี่ยนข้อความระหว่างกันโดยไม่เสี่ยงต่อการรั่วไหล (ใช่ไหม) แต่นั่นหมายความว่าสถานที่ตั้งของ AsyncTask คือคุณไม่จำเป็นต้องกังวลกับตัวจัดการผิด ดูเหมือนว่าการใช้ Handler ในทางที่ผิดเนื่องจากคุณกำลังส่งและรับข้อความในเธรดเดียวกัน (คุณสร้างมันบนเธรด UI และส่งผ่านมันใน onPostExecute () ซึ่งยังทำงานบนเธรด UI)

ยิ่งไปกว่านั้นคุณยังมีปัญหาว่าเมื่อบริบทถูกทำลายคุณไม่มีบันทึกของงานที่ถูกไล่ออก นั่นหมายความว่าคุณต้องเริ่มงานใหม่เมื่อสร้างบริบทขึ้นมาใหม่เช่นหลังจากการเปลี่ยนแนวหน้าจอ ช้าและสิ้นเปลือง

วิธีแก้ปัญหาของฉันในเรื่องนี้ (ตามที่นำไปใช้ในไลบรารี Droid-Fu ) คือการรักษาการแมปของWeakReferenceชื่อคอมโพเนนต์ไปยังอินสแตนซ์ปัจจุบันของพวกเขาบนวัตถุแอปพลิเคชันที่ไม่ซ้ำกัน เมื่อใดก็ตามที่ AsyncTask เริ่มต้นมันจะบันทึกบริบทการโทรในแผนที่นั้นและในทุกการติดต่อกลับมันจะดึงอินสแตนซ์บริบทปัจจุบันจากการทำแผนที่นั้น สิ่งนี้ทำให้มั่นใจได้ว่าคุณจะไม่อ้างอิงอินสแตนซ์บริบทเก่าและคุณสามารถเข้าถึงบริบทที่ถูกต้องในการเรียกกลับเพื่อให้คุณสามารถใช้ UI ที่มีความหมายได้ นอกจากนี้ยังไม่รั่วไหลเนื่องจากการอ้างอิงอ่อนแอและถูกล้างเมื่อไม่มีอินสแตนซ์ขององค์ประกอบที่กำหนดอีกต่อไป

ถึงกระนั้นมันก็เป็นวิธีการแก้ปัญหาที่ซับซ้อนและต้องการให้ชั้นย่อยของห้องสมุด Droid-Fu บางคลาสทำให้วิธีการนี้ค่อนข้างน่ารำคาญ

ตอนนี้ฉันแค่อยากรู้ว่า:ฉันเพิ่งทำอะไรบางอย่างหายไปอย่างมากมายหรือว่า AsyncTask มีข้อบกพร่องจริงๆหรือ ประสบการณ์ของคุณทำงานกับมันอย่างไร คุณแก้ปัญหาเหล่านี้ได้อย่างไร

ขอบคุณสำหรับข้อมูลของคุณ

เกี่ยวกับบางสิ่งเช่นนี้:

class MyActivity extends Activity {
    Worker mWorker;

    static class Worker extends AsyncTask<URL, Integer, Long> {
        MyActivity mActivity;

        Worker(MyActivity activity) {
            mActivity = activity;
        }

        @Override
        protected Long doInBackground(URL... urls) {
            int count = urls.length;
            long totalSize = 0;
            for (int i = 0; i < count; i++) {
                totalSize += Downloader.downloadFile(urls[i]);
                publishProgress((int) ((i / (float) count) * 100));
            }
            return totalSize;
        }

        @Override
        protected void onProgressUpdate(Integer... progress) {
            if (mActivity != null) {
                mActivity.setProgressPercent(progress[0]);
            }
        }

        @Override
        protected void onPostExecute(Long result) {
            if (mActivity != null) {
                mActivity.showDialog("Downloaded " + result + " bytes");
            }
        }
    }

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

        mWorker = (Worker)getLastNonConfigurationInstance();
        if (mWorker != null) {
            mWorker.mActivity = this;
        }

        ...
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        return mWorker;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mWorker != null) {
            mWorker.mActivity = null;
        }
    }

    void startWork() {
        mWorker = new Worker(this);
        mWorker.execute(...);
    }
}

เหตุผลชัดเจน: เกิดอะไรขึ้นถ้ากิจกรรมถูกทำลายซึ่งก่อให้เกิดงาน?

ด้วยตนเองยกเลิกการเชื่อมโยงกิจกรรมจากในAsyncTask onDestroy()อีกครั้งด้วยตนเองเชื่อมโยงกิจกรรมใหม่ไปในAsyncTask onCreate()สิ่งนี้ต้องใช้คลาสภายในแบบคงที่หรือคลาส Java มาตรฐานรวมถึงโค้ด 10 บรรทัด

ดูเหมือนว่าAsyncTaskเป็นบิตมากขึ้นกว่าเพียงแค่ข้อบกพร่องแนวคิด มันยังใช้ไม่ได้จากปัญหาความเข้ากันได้ เอกสาร Android อ่านแล้ว:

เมื่อเปิดตัวครั้งแรก AsyncTasks จะถูกดำเนินการตามลำดับบนเธรดพื้นหลังเดียว เริ่มต้นด้วย DONUT สิ่งนี้ถูกเปลี่ยนเป็นกลุ่มของเธรดที่อนุญาตให้งานหลายอย่างทำงานพร้อมกัน เริ่มต้น HONEYCOMB งานจะกลับมาดำเนินการในเธรดเดี่ยวเพื่อหลีกเลี่ยงข้อผิดพลาดทั่วไปของแอปพลิเคชันที่เกิดจากการดำเนินการแบบขนาน หากคุณต้องการการประมวลผลแบบขนานอย่างแท้จริงคุณสามารถใช้ executeOnExecutor(Executor, Params...) เวอร์ชันของวิธีนี้ด้วย THREAD_POOL_EXECUTOR ; อย่างไรก็ตามดูความเห็นที่นั่นสำหรับคำเตือนในการใช้งาน

ทั้งสองexecuteOnExecutor()และTHREAD_POOL_EXECUTORถูกเพิ่มใน API ระดับ 11 (Android 3.0.x, HONEYCOMB)

ซึ่งหมายความว่าหากคุณสร้างสองAsyncTaskไฟล์เพื่อดาวน์โหลดสองไฟล์การดาวน์โหลดครั้งที่สองจะไม่เริ่มจนกว่าไฟล์แรกจะเสร็จสิ้น หากคุณแชทผ่านเซิร์ฟเวอร์สองเครื่องและเซิร์ฟเวอร์แรกไม่ทำงานคุณจะไม่เชื่อมต่อกับเซิร์ฟเวอร์ที่สองก่อนการเชื่อมต่อกับเซิร์ฟเวอร์แรกจะหมดเวลา (ยกเว้นว่าคุณใช้คุณสมบัติ API11 ใหม่ แต่จะทำให้โค้ดของคุณไม่สามารถใช้ได้กับ 2.x)

และหากคุณต้องการกำหนดเป้าหมายทั้ง 2.x และ 3.0 ขึ้นไปสิ่งต่างๆจะยุ่งยากมาก

นอกจากนี้เอกสารพูดว่า:

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

อาจเป็นไปได้ว่าเราทุกคนรวมถึง Google นั้นใช้มุมมองMVCAsyncTaskในทางที่ผิด

กิจกรรมเป็นตัวควบคุมและควบคุมไม่ควรเริ่มดำเนินการที่อาจอายุยืนดู นั่นคือ AsyncTasks ควรใช้จากModelจากคลาสที่ไม่ได้ผูกไว้กับวงจรชีวิตของกิจกรรม - โปรดจำไว้ว่ากิจกรรมจะถูกทำลายเมื่อหมุน (สำหรับมุมมองคุณมักจะไม่ได้เรียนโปรแกรมที่มาจากเช่น android.widget.Button แต่คุณสามารถทำได้โดยปกติสิ่งเดียวที่คุณทำเกี่ยวกับมุมมองคือ xml)

กล่าวอีกนัยหนึ่งมันเป็นความผิดที่จะวาง AsyncTask ในวิธีการของอนุพันธ์ OTOH ถ้าเราไม่ต้องใช้ AsyncTasks ในกิจกรรม AsyncTask จะสูญเสียความน่าดึงดูดใจ: มันเคยถูกโฆษณาว่าเป็นการแก้ไขที่ง่ายและรวดเร็ว

ฉันไม่แน่ใจว่าเป็นความจริงที่คุณเสี่ยงต่อหน่วยความจำรั่วโดยอ้างอิงจากบริบทจาก AsyncTask

วิธีการใช้งานตามปกติคือการสร้างอินสแตนซ์ AsyncTask ใหม่ภายในขอบเขตของหนึ่งในวิธีการของกิจกรรม ดังนั้นหากกิจกรรมถูกทำลายดังนั้นเมื่อ AsyncTask เสร็จสมบูรณ์แล้วจะไม่สามารถเข้าถึงได้และมีสิทธิ์ได้รับการรวบรวมขยะหรือไม่ ดังนั้นการอ้างอิงถึงกิจกรรมจะไม่สำคัญเนื่องจาก AsyncTask นั้นจะไม่ทำงาน

มันจะมีประสิทธิภาพมากขึ้นในการเก็บ WeekReference ในกิจกรรมของคุณ:

public class WeakReferenceAsyncTaskTestActivity extends Activity {
    private static final int MAX_COUNT = 100;

    private ProgressBar progressBar;

    private AsyncTaskCounter mWorker;

    @SuppressWarnings("deprecation")
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_async_task_test);

        mWorker = (AsyncTaskCounter) getLastNonConfigurationInstance();
        if (mWorker != null) {
            mWorker.mActivity = new WeakReference<WeakReferenceAsyncTaskTestActivity>(this);
        }

        progressBar = (ProgressBar) findViewById(R.id.progressBar1);
        progressBar.setMax(MAX_COUNT);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_async_task_test, menu);
        return true;
    }

    public void onStartButtonClick(View v) {
        startWork();
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        return mWorker;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mWorker != null) {
            mWorker.mActivity = null;
        }
    }

    void startWork() {
        mWorker = new AsyncTaskCounter(this);
        mWorker.execute();
    }

    static class AsyncTaskCounter extends AsyncTask<Void, Integer, Void> {
        WeakReference<WeakReferenceAsyncTaskTestActivity> mActivity;

        AsyncTaskCounter(WeakReferenceAsyncTaskTestActivity activity) {
            mActivity = new WeakReference<WeakReferenceAsyncTaskTestActivity>(activity);
        }

        private static final int SLEEP_TIME = 200;

        @Override
        protected Void doInBackground(Void... params) {
            for (int i = 0; i < MAX_COUNT; i++) {
                try {
                    Thread.sleep(SLEEP_TIME);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.d(getClass().getSimpleName(), "Progress value is " + i);
                Log.d(getClass().getSimpleName(), "getActivity is " + mActivity);
                Log.d(getClass().getSimpleName(), "this is " + this);

                publishProgress(i);
            }
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            if (mActivity != null) {
                mActivity.get().progressBar.setProgress(values[0]);
            }
        }
    }

}

ทำไมไม่เพียงแค่แทนที่onPause()วิธีในการเป็นเจ้าของกิจกรรมและยกเลิกAsyncTaskจากที่นั่น?

คุณพูดถูก - นั่นคือเหตุผลที่การเคลื่อนไหวห่างจากการใช้งาน async / loader ในกิจกรรมเพื่อดึงข้อมูลกำลังได้รับแรงผลักดัน หนึ่งในวิธีการใหม่คือการใช้เฟรมเวิร์กของวอลเล่ย์ที่ให้การโทรกลับเมื่อข้อมูลพร้อม - สอดคล้องกับรูปแบบ MVC มากขึ้น วอลเล่ย์ได้รับความนิยมใน Google I / O 2013 ไม่แน่ใจว่าทำไมคนอื่นถึงไม่รู้เรื่องนี้

โดยส่วนตัวแล้วฉันเพิ่งขยาย Thread และใช้อินเตอร์เฟสการโทรกลับเพื่ออัปเดต UI ฉันไม่สามารถทำให้ AsyncTask ทำงานได้อย่างถูกต้องหากไม่มีปัญหา FC ฉันยังใช้คิวที่ไม่บล็อกเพื่อจัดการกลุ่มการเรียกใช้

ฉันคิดว่าการยกเลิกการทำงาน แต่ไม่ได้

ที่นี่พวกเขา RTFMing เกี่ยวกับเรื่องนี้:

"" ถ้างานเริ่มขึ้นแล้วพารามิเตอร์ mayInterruptIfRunning จะกำหนดว่าเธรดที่เรียกใช้งานนี้ควรถูกขัดจังหวะในความพยายามที่จะหยุดงานหรือไม่ "

แต่นั่นไม่ได้แปลว่าเธรดนั้นสามารถอินเตอร์รัปต์ได้ นั่นคือสิ่งที่จาวาไม่ใช่สิ่งที่ AsyncTask "

http://groups.google.com/group/android-developers/browse_thread/thread/dcadb1bc7705f1bb/add136eb4949359d?show_docid=add136eb4949359d

คุณน่าจะคิดว่า AsyncTask เป็นสิ่งที่แนบคู่กับกิจกรรม, บริบท, ContextWrapper และอื่น ๆ ได้สะดวกยิ่งขึ้นเมื่อเข้าใจขอบเขตของมันอย่างสมบูรณ์

ตรวจสอบให้แน่ใจว่าคุณมีนโยบายการยกเลิกในวงจรชีวิตของคุณเพื่อที่ว่าในที่สุดมันก็จะถูกเก็บขยะและในที่สุดก็ไม่มีการอ้างอิงถึงกิจกรรมของคุณอีกต่อไป

โดยไม่ต้องยกเลิก AsyncTask ของคุณในขณะที่อยู่ห่างจากบริบทของคุณคุณจะพบกับการรั่วไหลของหน่วยความจำและ NullPointerExceptions ถ้าคุณเพียงแค่ต้องการให้ข้อเสนอแนะเช่น Toast เป็นกล่องโต้ตอบแบบเรียบง่าย

AsyncTask ไม่ได้เลวร้ายอะไรนัก แต่มีเวทมนตร์มากมายที่สามารถนำไปสู่การผิดพลาดที่ไม่คาดฝัน

สำหรับ "ประสบการณ์การทำงานกับมัน": เป็นไปได้ที่จะฆ่ากระบวนการพร้อมกับ AsyncTasks ทั้งหมด Android จะสร้างกิจกรรมสแต็กใหม่อีกครั้งเพื่อให้ผู้ใช้ไม่ต้องพูดถึงอะไร