AsyncTask gerçekten kavramsal olarak kusurlu mu yoksa sadece bir şey mi kaçırıyorum?

Bu problemi aylardır araştırdım, hepsi büyük bir hack olduğu için memnun olmadığım farklı çözümler buldum. Tasarımda kusurlu bir sınıfın onu çerçeveye dönüştürdüğüne hala inanamıyorum ve hiç kimse bunun hakkında konuşmuyor, bu yüzden sanırım sadece bir şey eksik olmalıyım.

Sorun şu AsyncTask. Belgelere göre

"iş parçacıklarını ve / veya işleyicileri değiştirmek zorunda kalmadan arka plan işlemleri gerçekleştirmeye ve sonuçları UI iş parçacığında yayınlamaya izin verir."

Örnek daha sonra örnek bir showDialog()yöntemin nasıl çağrıldığını göstermeye devam eder onPostExecute(). Bununla birlikte, bu benim için tamamen çelişkili görünmektedir , çünkü bir diyalogun gösterilmesi her zaman geçerli bir referansa ihtiyaç duyar Contextve AsyncTask hiçbir zaman bir bağlam nesnesine güçlü bir referans içermemelidir .

Sebep açıktır: ya aktiviteyi tahrip eden görevi tahrip ederse? Bu her zaman olabilir, örneğin ekranı çevirdiğiniz için. Görev, onu oluşturan bağlama referans verirse, yalnızca işe yaramaz bir bağlam nesnesine tutunmazsınız (pencere yok edilir ve herhangi bir UI etkileşimi bir istisna dışında başarısız olur!) bellek sızıntısı.

Mantığım burada kusurlu olmadıkça, bu onPostExecute()şu anlama gelir: tamamen işe yaramaz, çünkü herhangi bir bağlama erişiminiz yoksa bu yöntemin UI iş parçacığında çalışması ne kadar iyi? Burada anlamlı bir şey yapamazsınız.

Geçici çözümlerden biri bağlam örneklerini bir AsyncTask'e değil bir Handlerörneğe geçirmektir . Bu işe yarar: Bir İşleyici bağlamı ve görevi gevşek bir şekilde bağladığından, sızıntı riski olmadan aralarında mesaj alışverişi yapabilirsiniz (değil mi?). Ancak bu, AsyncTask'in öncülünün, yani işleyicileri rahatsız etmenize gerek olmadığı anlamına gelir. Aynı iş parçacığında mesaj gönderip aldığınız için de Handler'ı kötüye kullanmak gibi görünüyor (bunu UI iş parçacığında oluşturup UI iş parçacığında da yürütülen onPostExecute () içinde gönderirsiniz).

Her şeyden önemlisi, bu geçici çözümde bile, bağlam yok edildiğinde, tetiklediği görevlerin hiçbir kaydına sahip olmamanız sorununa sahipsiniz . Bu, içeriği yeniden oluştururken, örneğin bir ekran yönlendirme değişikliğinden sonra, tüm görevleri yeniden başlatmanız gerektiği anlamına gelir. Bu yavaş ve savurgan.

Buna benim çözümüm ( Droid-Fu kütüphanesinde uygulandığı gibi ), WeakReferencebileşen adlarından benzersiz uygulama nesnesindeki mevcut örneklerine bir eşleme sağlamaktır . Bir AsyncTask başlatıldığında, çağıran bağlamı bu haritaya kaydeder ve her geri çağrıldığında geçerli bağlam örneğini bu eşlemeden alır. Eğer eski bir bağlam örneğini başvuru asla Bu olmasını sağlar ve orada anlamlı UI işi yapabilir böylece her zaman geri çağrıları geçerli bir içeriğe erişebilir. Ayrıca sızıntı yapmaz, çünkü referanslar zayıftır ve artık belirli bir bileşenin örneği olmadığında temizlenir.

Yine de, karmaşık bir çözümdür ve Droid-Fu kütüphane sınıflarının bazılarını alt sınıflara ayırmayı gerektirir, bu da bunu oldukça müdahaleci bir yaklaşım haline getirir.

Şimdi sadece bilmek istiyorum: Bir şeyi büyük ölçüde özlüyor muyum yoksa AsyncTask gerçekten tamamen kusurlu mu? Deneyimleriniz onunla nasıl çalışıyor? Bu sorunu nasıl çözdün?

Girdiniz için teşekkürler.

Böyle bir şeye ne dersin:

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

Nedeni açıktır: ya görevi yok eden ve görevi tetikleyen bir olay olursa?

El ile ilgili etkinliği ilişkisini AsyncTaskin onDestroy(). Yeni etkinliği AsyncTaskin ile manuel olarak yeniden ilişkilendirin onCreate(). Bu, statik bir iç sınıf veya standart bir Java sınıfı ve ayrıca 10 satır kod gerektirir.

Sadece kavramsal olarak kusurlu olmaktan AsyncTaskbiraz daha fazlası gibi görünüyor . Uyumluluk sorunları nedeniyle de kullanılamaz. Android dokümanları şunları okur:

İlk tanıtıldığında, AsyncTasks tek bir arka plan iş parçacığında seri olarak yürütüldü. DONUT ile başlayarak, bu, birden fazla görevin paralel olarak çalışmasına izin veren bir iş parçacığı havuzuna değiştirildi. HONEYCOMB başlatıldığında, paralel yürütmenin neden olduğu yaygın uygulama hatalarını önlemek için görevler tek bir iş parçacığında yürütülür. Paralel yürütmeyi gerçekten istiyorsanız executeOnExecutor(Executor, Params...) , bu yöntemin sürümünü THREAD_POOL_EXECUTOR ; ancak, kullanımıyla ilgili uyarılar için oradaki açıklamaya bakınız.

Hem executeOnExecutor()ve THREAD_POOL_EXECUTORedilir API düzeyinde 11'de eklendi (Android 3.0.x, PETEK).

Bu, AsyncTaskiki dosyayı indirmek için iki s oluşturursanız , ikinci indirme ilki bitene kadar başlamayacaktır. İki sunucu üzerinden sohbet ediyorsanız ve ilk sunucu kapalıysa, ilk sunucuya bağlantı zaman aşımına uğramadan ikinci sunucuya bağlanamazsınız. (Tabii ki yeni API11 özelliklerini kullanmadığınız sürece, ancak bu kodunuzu 2.x ile uyumsuz hale getirecektir).

Hem 2.x hem de 3.0+ hedeflemek istiyorsanız, işler gerçekten zor olur.

Ayrıca dokümanlar şunları söylüyor:

Dikkat: bir çalışan iş parçacığı kullanırken karşılaşabileceğiniz başka bir sorun (örneğin, kullanıcı ekran yönünü değiştirdiğinde gibi) nedeniyle çalışma zamanı yapılandırma değişikliği etkinlik beklenmedik yeniden başlatılır olduğunu sizin iş parçacığı yok edebilir . Bu yeniden başlatmalardan birinde görevinize nasıl devam edebileceğinizi ve etkinlik yok edildiğinde görevin nasıl düzgün bir şekilde iptal edileceğini görmek için, Shelves örnek uygulamasının kaynak koduna bakın.

Muhtemelen Google dahil tüm, suiistimal AsyncTaskgelen MVC bakış açısından.

Etkinlik bir Denetleyicidir ve denetleyici, Görünümü geçebilecek işlemleri başlatmamalıdır . Yani, AsyncTasks, Modelden , Etkinlik yaşam döngüsüne bağlı olmayan bir sınıftan kullanılmalıdır - Etkinliklerin rotasyon sırasında yok edildiğini unutmayın. ( Görünüm ile ilgili olarak , genellikle android.widget.Button'dan türetilmiş sınıfları programlamazsınız, ancak bunu yapabilirsiniz. Genellikle, Görünüm hakkında yaptığınız tek şey xml'dir.)

Başka bir deyişle, AsyncTask türevlerini Faaliyet yöntemlerine yerleştirmek yanlıştır. OTOH, Faaliyetlerde AsyncTasks kullanmamamız gerekiyorsa, AsyncTask çekiciliğini kaybeder: eskiden hızlı ve kolay bir düzeltme olarak ilan edilirdi.

Bir AsyncTask içeriğinden bir referansla bir bellek sızıntısı riskinin olduğundan emin değilim.

Bunları uygulamanın genel yolu, Faaliyetin yöntemlerinden biri kapsamında yeni bir AsyncTask örneği oluşturmaktır. Etkinlik yok edilirse, AsyncTask tamamlandıktan sonra erişilemez ve ardından çöp toplama için uygun olmaz mı? Bu nedenle, aktiviteye referans önemli değildir çünkü AsyncTask'ın kendisi takılmayacaktır.

Etkinliğiniz için bir WeekReference tutmak daha sağlam olurdu:

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

}

Neden yalnızca onPause()sahiplik etkinliğindeki yöntemi geçersiz kılmayabilir ve AsyncTaskoradan iptal edebilirsiniz ?

Kesinlikle haklısınız - işte bu nedenle, veri getirmek için aktivitelerde zaman uyumsuz görevler / yükleyiciler kullanmaktan uzak bir hareket ivme kazanıyor. Yeni yollardan biri , veriler hazır olduğunda esasen bir geri arama sağlayan bir Volley çerçevesi kullanmaktır - MVC modeliyle çok daha tutarlı. Volley Google I / O 2013'te popülize edildi. Bunun neden daha fazla insanın farkında olmadığından emin değilim.

Şahsen ben sadece Thread uzatmak ve kullanıcı arayüzünü güncellemek için bir geri arama arayüzü kullanın. AsyncTask'ın FC sorunları olmadan düzgün çalışmasını asla sağlayamadım. Ayrıca yürütme havuzunu yönetmek için engelleme olmayan bir kuyruk kullanın.

İptal etmeyi düşündüm ama işe yaramadı.

burada RTFMing hakkında:

"" Görev zaten başlamışsa, mayInterruptIfRunning parametresi, görevi durdurma girişiminde bu görevi yürüten iş parçacığının kesilip kesilmeyeceğini belirler. "

Ancak bu, ipliğin kesilebilir olduğu anlamına gelmez. Bu bir Java işi, AsyncTask değil. "

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

AsyncTask'ı bir Etkinlik, Bağlam, ContextWrapper, vb. İle daha sıkı bir şekilde bağlanmış bir şey olarak düşünmek daha iyi olurdu.

Yaşam döngünüzde bir iptal politikasının bulunduğundan emin olun, böylece sonunda çöp toplanır ve etkinliğinize artık referans olmaz ve çöp de toplanabilir.

Bağlamınızdan uzaklaşırken AsyncTask'ınızı iptal etmeden, bellek sızıntılarına ve NullPointerExceptions ile karşılaşırsınız, eğer basit bir Tost gibi bir geri bildirim sağlamanız gerekiyorsa, Uygulama Bağlamınızın bir tonu NPE sorununu önlemeye yardımcı olacaktır.

AsyncTask hiç de fena değil ama kesinlikle beklenmedik tuzaklara yol açabilecek çok fazla büyü var.

"Onunla çalışan deneyimleri" gelince: o mümkün için öldürme işlemi tüm AsyncTasks birlikte kullanıcı şey söz olmaz ki, Android etkinlik yığınını yeniden yaratacaktır.