Cara ideal untuk membatalkan AsyncTask yang sedang dieksekusi

Saya menjalankan operasi pengambilan file audio dan pemutaran file audio jarak jauh di utas latar belakang menggunakan AsyncTask. SEBUAHCancellable progress bar ditampilkan untuk waktu pengambilan operasi berjalan.

Saya ingin membatalkan / membatalkan proses AsyncTaskketika pengguna membatalkan (memutuskan) operasi. Bagaimana cara yang ideal untuk menangani kasus seperti itu?

Hanya menemukan bahwa AlertDialogs's boolean cancel(...);saya telah menggunakan mana-mana sebenarnya tidak apa-apa. Bagus.
Begitu...

public class MyTask extends AsyncTask<Void, Void, Void> {

    private volatile boolean running = true;
    private final ProgressDialog progressDialog;

    public MyTask(Context ctx) {
        progressDialog = gimmeOne(ctx);

        progressDialog.setCancelable(true);
        progressDialog.setOnCancelListener(new OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                // actually could set running = false; right here, but I'll
                // stick to contract.
                cancel(true);
            }
        });

    }

    @Override
    protected void onPreExecute() {
        progressDialog.show();
    }

    @Override
    protected void onCancelled() {
        running = false;
    }

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

        while (running) {
            // does the hard work
        }
        return null;
    }

    // ...

}

Jika Anda melakukan perhitungan :

• Anda harus memeriksanya isCancelled()secara berkala.

Jika Anda melakukan permintaan HTTP :

• Simpan contoh Anda HttpGetatauHttpPost suatu tempat (mis. Bidang publik).
• Setelah menelepon cancel, telepon request.abort(). Ini akan menyebabkan IOExceptionterlempar ke dalam Anda doInBackground.

Dalam kasus saya, saya memiliki kelas konektor yang saya gunakan di berbagai AsyncTasks. Untuk membuatnya tetap sederhana, saya menambahkan abortAllRequestsmetode baru ke kelas itu dan memanggil metode ini langsung setelah memanggil cancel.

Masalahnya adalah panggilan AsyncTask.cancel () hanya memanggil fungsi onCancel dalam tugas Anda. Di sinilah Anda ingin menangani permintaan pembatalan.

Berikut adalah tugas kecil yang saya gunakan untuk memicu metode pembaruan

private class UpdateTask extends AsyncTask<Void, Void, Void> {

        private boolean running = true;

        @Override
        protected void onCancelled() {
            running = false;
        }

        @Override
        protected void onProgressUpdate(Void... values) {
            super.onProgressUpdate(values);
            onUpdate();
        }

        @Override
        protected Void doInBackground(Void... params) {
             while(running) {
                 publishProgress();
             }
             return null;
        }
     }

Sederhana: jangan gunakan file AsyncTask. AsyncTaskdirancang untuk pengoperasian singkat yang berakhir dengan cepat (puluhan detik) dan karenanya tidak perlu dibatalkan. "Pemutaran file audio" tidak memenuhi syarat. Anda bahkan tidak memerlukan utas latar belakang untuk pemutaran file audio biasa.

Satu-satunya cara untuk melakukannya adalah dengan memeriksa nilai metode isCancelled () dan menghentikan pemutaran saat mengembalikan nilai true.

Ini adalah bagaimana saya menulis AsyncTask saya
, titik kuncinya adalah menambahkan Thread.sleep (1);

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

        Log.d(TAG, PRE + "url:" + params[0]);
        Log.d(TAG, PRE + "file name:" + params[1]);
        downloadPath = params[1];

        int returnCode = SUCCESS;
        FileOutputStream fos = null;
        try {
            URL url = new URL(params[0]);
            File file = new File(params[1]);
            fos = new FileOutputStream(file);

            long startTime = System.currentTimeMillis();
            URLConnection ucon = url.openConnection();
            InputStream is = ucon.getInputStream();
            BufferedInputStream bis = new BufferedInputStream(is);

            byte[] data = new byte[10240]; 
            int nFinishSize = 0;
            while( bis.read(data, 0, 10240) != -1){
                fos.write(data, 0, 10240);
                nFinishSize += 10240;
                **Thread.sleep( 1 ); // this make cancel method work**
                this.publishProgress(nFinishSize);
            }              
            data = null;    
            Log.d(TAG, "download ready in"
                  + ((System.currentTimeMillis() - startTime) / 1000)
                  + " sec");

        } catch (IOException e) {
                Log.d(TAG, PRE + "Error: " + e);
                returnCode = FAIL;
        } catch (Exception e){
                 e.printStackTrace();           
        } finally{
            try {
                if(fos != null)
                    fos.close();
            } catch (IOException e) {
                Log.d(TAG, PRE + "Error: " + e);
                e.printStackTrace();
            }
        }

        return returnCode;
    }

Variabel kelas AsyncTask global kami

LongOperation LongOperationOdeme = new LongOperation();

Dan tindakan KEYCODE_BACK yang mengganggu AsyncTask

   @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            LongOperationOdeme.cancel(true);
        }
        return super.onKeyDown(keyCode, event);
    }

Ini bekerja untuk saya.

Saya tidak suka memaksa interupsi tugas asinkron saya dengan cancel(true)tidak perlu karena mereka mungkin memiliki sumber daya untuk dibebaskan, seperti menutup soket atau aliran file, menulis data ke database lokal dll. Di sisi lain, saya telah menghadapi situasi di mana tugas async menolak untuk menyelesaikan sendiri sebagian waktu, misalnya kadang-kadang ketika aktivitas utama ditutup dan saya meminta tugas asinkron untuk diselesaikan dari dalam metode aktivitas onPause(). Jadi, ini bukan hanya soal menelepon running = false. Saya harus mencari solusi campuran: keduanya memanggil running = false, lalu memberikan tugas asinkron beberapa milidetik untuk diselesaikan, dan kemudian memanggil salah satu cancel(false)atau cancel(true).

if (backgroundTask != null) {
    backgroundTask.requestTermination();
    try {
        Thread.sleep((int)(0.5 * 1000));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    if (backgroundTask.getStatus() != AsyncTask.Status.FINISHED) {
        backgroundTask.cancel(false);
    }
    backgroundTask = null;
}

Akibatnya, setelah doInBackground()selesai, terkadang onCancelled()metode ini dipanggil, dan terkadang onPostExecute(). Tapi setidaknya penghentian tugas asinkron dijamin.

Dengan mengacu pada jawaban Yanchenko pada 29 April '10: Menggunakan pendekatan 'while (running)' adalah hal yang rapi ketika kode Anda di bawah 'doInBackground' harus dijalankan beberapa kali selama setiap eksekusi AsyncTask. Jika kode Anda di bawah 'doInBackground' harus dijalankan hanya sekali per eksekusi AsyncTask, menggabungkan semua kode Anda di bawah 'doInBackground' dalam loop 'while (running)' tidak akan menghentikan kode latar belakang (utas latar belakang) agar tidak berjalan ketika AsyncTask sendiri dibatalkan, karena kondisi 'while (running)' hanya akan dievaluasi setelah semua kode di dalam while loop telah dieksekusi setidaknya sekali. Karena itu, Anda harus (a.) Memecah kode Anda di bawah 'doInBackground' menjadi beberapa blok 'saat (menjalankan)' atau (b.) Melakukan banyak 'isCancelled'https://developer.android.com/reference/android/os/AsyncTask.html .

Untuk opsi (a.), Seseorang dapat mengubah jawaban Yanchenko sebagai berikut:

public class MyTask extends AsyncTask<Void, Void, Void> {

private volatile boolean running = true;

//...

@Override
protected void onCancelled() {
    running = false;
}

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

    // does the hard work

    while (running) {
        // part 1 of the hard work
    }

    while (running) {
        // part 2 of the hard work
    }

    // ...

    while (running) {
        // part x of the hard work
    }
    return null;
}

// ...

Untuk opsi (b.) Kode Anda di 'doInBackground' akan terlihat seperti ini:

public class MyTask extends AsyncTask<Void, Void, Void> {

//...

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

    // part 1 of the hard work
    // ...
    if (isCancelled()) {return null;}

    // part 2 of the hard work
    // ...
    if (isCancelled()) {return null;}

    // ...

    // part x of the hard work
    // ...
    if (isCancelled()) {return null;}
}

// ...