Handler vs AsyncTask vs Thread

Jeśli spojrzysz na kod źródłowy AsyncTask i Handler, zobaczysz, że ich kod jest napisany wyłącznie w Javie. (Oczywiście są pewne wyjątki, ale to nie jest ważny punkt.)

Więc nie ma magii w AsyncTask Ani Handler. Ułatwiają Ci pracę jako programista.

Na przykład: jeśli Program a wywołuje metodę a (), metoda a () może działać w innym wątku z programem A. możesz łatwo ją zweryfikować używając:

Thread t = Thread.currentThread();    
int id = t.getId();

Dlaczego warto używać nowego wątku? Możesz google dla niego. Wiele, wiele powodów.

Więc jaka jest różnica między Thread, AsyncTask, i Handler?

AsyncTask i Handler są napisane w Javie (wewnętrznie używają Thread), więc wszystko, co możesz zrobić z Handler lub AsyncTask, możesz osiągnąć również za pomocą Thread.

W czym Handler i AsyncTask naprawdę ci pomogą?

Najbardziej oczywistym powodem jest komunikacja między wątkiem wywołującym a wątkiem roboczym. ( wątek wywołujący : wątek wywołujący pracownika Wątek do wykonania jakiegoś zadania. Wątek wywołujący niekoniecznie musi być wątkiem interfejsu użytkownika). Oczywiście można komunikować się między dwoma wątkami na inne sposoby, ale istnieje wiele wad (i zagrożeń) ze względu na problemy z bezpieczeństwem wątku.

Dlatego należy używać Handler i AsyncTask. Wykonują większość pracy za ciebie, musisz tylko wiedzieć, jakie metody zastąpić.

Różnica między Handler A AsyncTask wynosi: użyj AsyncTask, gdy wątek wywołujący jest UI Wątek . Oto, co mówi dokument Androida:

AsyncTask umożliwia prawidłowe i łatwe korzystanie z wątku interfejsu użytkownika. Ta klasa umożliwia wykonywanie operacji w tle i publikowanie wyników w interfejsie użytkownika wątek bez konieczności manipulowania wątkami i / lub manipulatorami

Chcę podkreślić dwa punkty:

1) Łatwe korzystanie z wątku interfejsu użytkownika (tak więc, użyj, gdy wątek wywołujący jest wątkiem interfejsu użytkownika).

2) nie trzeba manipulować manipulatorami. (znaczy: możesz użyć Handlera zamiast AsyncTask, ale AsyncTask jest łatwiejszą opcją).

W tym poście jest wiele rzeczy, których jeszcze nie powiedziałem, na przykład: co to jest wątek UI lub dlaczego jest łatwiejszy. Musisz znać jakąś metodę za każdym rodzajem i używać jej, całkowicie zrozumiesz dlaczego..

@: Po przeczytaniu dokumentu z Androidem zobaczysz:

Handler pozwala na wysyłanie i przetwarzanie wiadomości i obiektów uruchamianych powiązane z wiadomością wątku

Mogą się wydawać na początku dziwne. Po prostu zrozum, że każdy wątek ma każdą kolejkę wiadomości (jak Lista do zrobienia), a wątek weźmie każdą wiadomość i zrobi to, dopóki kolejka nie będzie pusta (tak jak skończysz pracę i pójdziesz spać). Kiedy Handler się komunikuje, wysyła wiadomość do wątku wywołującego i będzie czekać na przetworzenie. Skomplikowane? Pamiętaj tylko, że {[2] } może komunikować się z wątkiem wywołującym w bezpieczny sposób.

Po dogłębnym spojrzeniu, jest prosto do przodu.

AsyncTask:

Jest to prosty sposób na użycie wątku bez wiedzy o java thread model. AsyncTask daje różne wywołania zwrotne odpowiednio do wątku roboczego i głównego wątku.

Użyj do małych operacji oczekujących, takich jak:

1. pobieranie niektórych danych z usług internetowych i wyświetlanie nad układem.
2. zapytanie do bazy danych.
3. kiedy zdasz sobie sprawę, że prowadzenie operacji nigdy, przenigdy nie zagnieżdżą się.

Handler:

Kiedy instalujemy aplikację na Androidzie, tworzy ona wątek dla tej aplikacji o nazwie MAIN UI Thread. Wszystkie działania przebiegają wewnątrz tego wątku. Zgodnie z regułą android single thread model, nie możemy uzyskać dostępu do elementów UI (bitmapy, textview itp..) bezpośrednio dla innego wątku zdefiniowanego wewnątrz tej aktywności.

Obsługa pozwala komunikować się z powrotem z wątku interfejsu użytkownika z innego wątku tła. Jest to przydatne w Androidzie, ponieważ android nie pozwala innym wątkom komunikować się bezpośrednio z wątkiem interfejsu użytkownika. Handler może wysyłać i przetwarzać wiadomości i Obiekty Runnable związane z Komunikatem w wątku. Każda instancja obsługi jest powiązana z pojedynczym wątkiem i kolejką wiadomości tego wątku. Po utworzeniu nowej funkcji obsługi jest ona powiązana z kolejką wątków/wiadomości wątku, który ją tworzy.

Najlepiej pasuje do:

1. pozwala na kolejkowanie wiadomości.
2. wiadomość planowanie.

Thread:

Teraz nadszedł czas, aby porozmawiać o wątku.

Wątek jest rodzicem AsyncTask i Handler. Oba używają wewnętrznie wątku, co oznacza, że można również utworzyć własny model wątku Jak AsyncTask i Handler, ale wymaga to dobrej znajomości wielowątkowej implementacji Javy .

An AsyncTask jest używany do wykonywania obliczeń w tle i publikowania wyników w wątku interfejsu użytkownika(z opcjonalnymi aktualizacjami postępu). Ponieważ nie interesuje Cię interfejs użytkownika, to Handler lub Thread wydaje się bardziej odpowiednie.

Możesz wywołać tło Thread i przekazać wiadomości z powrotem do głównego wątku za pomocą metody Handler ' s post.

Wątek

Android obsługuje standardowe wątki Java . Możesz użyć standardowych wątków i narzędzi z pakietu "java.util.concurrent", aby umieścić akcje w tle. Jedynym ograniczeniem jest to, że nie można bezpośrednio zaktualizować interfejsu użytkownika z procesu w tle.

Jeśli chcesz zaktualizować interfejs użytkownika z zadania w tle, musisz użyć niektórych klas specyficznych dla Androida. Możesz użyć klasy "android.os.Handler " do tego lub klasy "AsyncTask"

Handler

Klasa "Handler " może zaktualizować interfejs użytkownika. Uchwyt dostarcza metody do odbierania wiadomości i do runnables. Aby użyć funkcji obsługi, musisz ją podklasować i nadpisać handleMessage(), aby przetwarzać wiadomości. Aby przetworzyć Runable, możesz użyć metody post(); potrzebujesz tylko jednej instancji obsługi w swojej aktywności.

Możesz wysyłać wiadomości za pomocą metody sendMessage(Message msg) lub sendEmptyMessage.

AsyncTask

Jeśli masz Activity które wymaga pobrania zawartości lub wykonania operacji, które można wykonać w tle AsyncTask pozwala na utrzymanie responsywnego interfejsu użytkownika i publikowanie postępów w tych operacjach użytkownikowi.

Aby uzyskać więcej informacji, możesz spojrzeć na te linki.

Http://mobisys.in/blog/2012/01/android-threads-handlers-and-asynctask-tutorial/

Http://www.slideshare.net/HoangNgoBuu/android-thread-handler-and-asynctask

Moim zdaniem wątki nie są najskuteczniejszym sposobem wykonywania połączeń z gniazdami, ale zapewniają największą funkcjonalność pod względem uruchomionych wątków. Mówię tak, ponieważ z doświadczenia wynika, że uruchamianie wątków przez długi czas powoduje, że urządzenia są bardzo gorące i zasobochłonne. Nawet prosty while(true) ogrzeje telefon w kilka minut. Jeśli mówisz, że interakcja z UI nie jest ważna, być może AsyncTask jest dobra, ponieważ są one przeznaczone do długotrwałych procesów. To tylko moje zdanie na temat to.

UPDATE

Proszę zignorować moją powyższą odpowiedź! odpowiedziałem na to pytanie w 2011 roku, kiedy byłem znacznie mniej doświadczony w Androidzie niż teraz. Moja odpowiedź powyżej jest myląca i jest uważana za błędną. Zostawiam go tam, ponieważ wiele osób komentowało go poniżej, poprawiając mnie i dostałem nauczkę.

Są o wiele lepsze inne odpowiedzi w tym wątku, ale przynajmniej Dam mi bardziej właściwą odpowiedź. Nie ma nic złego w używaniu zwykła Java Thread; jednak powinieneś naprawdę uważać na to, jak ją zaimplementujesz, ponieważ robienie tego źle może być bardzo intensywne dla procesora(najbardziej zauważalnym objawem może być nagrzewanie się urządzenia). AsyncTasks są całkiem idealne dla większości zadań, które chcesz uruchomić w tle (typowe przykłady to Wejścia/Wyjścia dyskowe, połączenia sieciowe i połączenia z bazami danych). Jednak AsyncTask s nie powinny być używane do szczególnie długich procesów, które mogą wymagać kontynuacji po zamknięciu aplikacji przez użytkownika lub włączeniu urządzenia w stan gotowości. Powiedziałbym, że w większości przypadków wszystko, co nie należy do wątku UI, może być załatwione w AsyncTask.

Thread:

Możesz używać new Thread do długotrwałych zadań w tle bez wpływu na wątek interfejsu. W wątku java nie można zaktualizować wątku interfejsu użytkownika.

Ponieważ zwykły wątek nie jest zbyt przydatny dla architektury Androida, wprowadzono klasy pomocnicze dla wątków.

Możesz znaleźć odpowiedzi na swoje pytania na stronie dokumentacji threading performance.

:

A Handler pozwala na wysyłanie i przetwarzanie Wiadomości i Runnable obiekty związane z MessageQueue wątku. Każda instancja Handler jest powiązana z pojedynczym wątkiem i kolejką wiadomości tego wątku.

Istnieją dwa główne zastosowania dla Handler:

1. Aby zaplanować wiadomości i pliki uruchomieniowe do wykonania jako jakiś punkt w przyszłości;

2. Aby zapytać o działanie, które ma być wykonane na innym wątku niż twój własny.

AsyncTask :

AsyncTask umożliwia prawidłowe i łatwe użytkowanie wątku UI. Ta klasa pozwala na wykonywanie operacji w tle i publikowanie wyników w wątku interfejsu użytkownika bez konieczności manipulowania wątkami i / lub programami obsługi.

Wady:

1. Domyślnie aplikacja wypycha wszystkie obiekty AsyncTask, które tworzy, do jednego wątku. Dlatego też wykonują one w trybie szeregowym i-podobnie jak w głównym wątku-szczególnie długi pakiet roboczy może zablokować kolejkę. Z tego powodu użyj AsyncTask do krótszej obsługi elementów roboczych niż 5ms w czasie trwania.

2. AsyncTask obiekty są również najczęstszymi przestępcami w przypadku problemów implicit-reference. AsyncTask obiekty stwarzają również ryzyko związane z wyraźnymi odniesieniami.

HandlerThread :

Możesz potrzebować bardziej tradycyjnego podejścia do wykonywania bloku pracy na dłuższym wątku ( w przeciwieństwie do AsyncTask, który powinien być używany do obciążenia 5ms ), i pewnej zdolności do ręcznego zarządzania tym przepływem pracy. A wątek obsługi jest efektywnie długotrwałym wątkiem, który chwyta pracę z kolejki i na niej operuje.

ThreadPoolExecutor :

Ta klasa zarządza tworzeniem grupy wątków, ustala ich priorytety i zarządza dystrybucją pracy między tymi wątkami. Gdy obciążenie zwiększa się lub zmniejsza, Klasa obraca się lub niszczy więcej wątków, aby dostosować się do obciążenia.

Jeśli obciążenie jest większe, a pojedyncze HandlerThread nie wystarczy, możesz wybrać ThreadPoolExecutor

Jednak chciałbym, aby połączenie z gniazdem działało w usłudze. Czy powinno to być uruchamiane w module obsługi lub wątku, a nawet w Asynctasku? Interakcja z interfejsem użytkownika nie jest wcale konieczna. Czy to robi różnicę pod względem wydajności, z której korzystam?

Ponieważ interakcja z interfejsem użytkownika nie jest wymagana, nie możesz wybrać AsyncTask. Normalne wątki nie są zbyt użyteczne i dlatego {[14] } jest najlepszą opcją. Ponieważ musisz utrzymywać połączenie z gniazdem, obsługa w głównym wątku nie jest przydatna w wszystkie. Utwórz HandlerThread i uzyskaj Handler z loopera z HandlerThread.

 HandlerThread handlerThread = new HandlerThread("SocketOperation");
 handlerThread.start();
 Handler requestHandler = new Handler(handlerThread.getLooper());
 requestHandler.post(myRunnable); // where myRunnable is your Runnable object. 

Jeśli chcesz komunikować się z powrotem do wątku UI, możesz użyć jeszcze jednego narzędzia do przetworzenia odpowiedzi.

final Handler responseHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            //txtView.setText((String) msg.obj);
            Toast.makeText(MainActivity.this,
                    "Foreground task is completed:"+(String)msg.obj,
                    Toast.LENGTH_LONG)
                    .show();
        }
    };

W Twoim Runnable możesz dodać

responseHandler.sendMessage(msg);

Więcej szczegółów na temat implementacji można znaleźć tutaj:

Android: Toast w wątku

AsyncTask jest przeznaczony do wykonywania nie więcej niż kilku sekund operacji, które mają być wykonane w tle(nie zaleca się dla megabajtów pobierania plików z serwera lub obliczenia intensywne cpu zadania, takie jak operacje IO plików). Jeśli musisz wykonać długotrwałą operację, zdecydowanie zaleca się używanie natywnych wątków Javy. Java daje Ci różne klasy związane z wątkiem, aby zrobić to, czego potrzebujesz. Użyj Handler, aby zaktualizować wątek interfejsu użytkownika.

pozwól, że spróbuję odpowiedzieć na pytanie tutaj z przykładem:) - MyImageSearch [proszę odnieść się do obrazka głównego ekranu aktywności-zawierającego edytowany tekst / przycisk wyszukiwania / Widok siatki]

Opis MyImageSearch - Gdy użytkownik wprowadzi szczegóły w polu Edytuj tekst i kliknie przycisk Szukaj, będziemy wyszukiwać obrazy w Internecie za pośrednictwem usług internetowych udostępnianych przez flickr (wystarczy się tam zarejestrować, aby uzyskać klucz / tajemnicę token) - do wyszukiwania wysyłamy żądanie HTTP i otrzymujemy dane JSON z powrotem w odpowiedzi zawierające adresy URL poszczególnych obrazów, które następnie użyjemy do załadowania widoku siatki.

Moja realizacja - w głównym ćwiczeniu zdefiniuję wewnętrzną klasę, która rozszerza AsyncTask, aby wysłać żądanie HTTP w metodzie DOINBACKGROUND i pobrać odpowiedź JSON i zaktualizować moją lokalną ArrayList FlickrItems, które mam zamiar użyć do aktualizacji mojego GridView poprzez FlickrAdapter (rozszerza BaseAdapter) i wywołać adapter.notifyDataSetChanged() in the onPostExecute () of AsyncTask to reload the grid view. Zauważ, że tutaj żądanie HTTP jest wywołaniem blokującym, z powodu którego zrobiłem to za pomocą AsyncTask. I mogę buforować elementy w adapterze, aby zwiększyć wydajność lub przechowywać je na karcie SD. Siatka, którą będę pompował w Flickradapterze zawiera w mojej implementacji pasek postępu i widok obrazu. Poniżej znajdziesz kod dla mainActivity, który używany.

Odpowiedź na pytanie teraz - Więc kiedy mamy dane JSON do pobierania pojedynczych obrazów, możemy zaimplementować logikę uzyskiwania obrazów w tle za pomocą programów obsługi lub wątków lub AsyncTask. Należy tutaj zauważyć, że ponieważ moje obrazy po pobraniu muszą być wyświetlane w UI / głównym wątku,nie możemy po prostu używać wątków, ponieważ nie mają one dostępu do kontekstu. W Flickradapterze wybory, które mogłem wymyślić:

• wybór 1: Utwórz LooperThread [ rozszerza wątek] - i tak dalej pobieranie obrazów sekwencyjnie w jednym wątku, zachowując ten wątek otwórz [looper.loop ()]
• wybór 2: Użyj puli wątków i opublikuj runnable przez myHandler, który zawiera odniesienie do mojego ImageView, ale ponieważ widoki w widoku siatki są poddawane recyklingowi, ponownie może pojawić się problem, gdy obraz w indeksie 4 jest wyświetlane w indeksie 9 [pobieranie może zająć więcej czasu]
• Wybór 3 [użyłem tego]: skorzystaj z puli wątków i wyślij wiadomość do myHandler, która zawiera dane związane z indeksem ImageView i Samego ImageView, więc wykonując handleMessage() zaktualizujemy ImageView tylko wtedy, gdy currentIndex pasuje do indeksu obrazu we próbowałem ściągnąć.
• wybór 4: Użyj AsyncTask, aby pobrać obrazy w tle, ale tutaj nie będę miał dostępu do ilości wątków, które chcę w Pula wątków i różni się w zależności od wersji Androida, ale w Choice 3 mogę podjąć świadomą decyzję o wielkość puli wątków w zależności od używanej konfiguracji urządzenia.

Tutaj kod źródłowy:

public class MainActivity extends ActionBarActivity {

    GridView imageGridView;
    ArrayList<FlickrItem> items = new ArrayList<FlickrItem>();
    FlickrAdapter adapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        imageGridView = (GridView) findViewById(R.id.gridView1);
        adapter = new FlickrAdapter(this, items);
        imageGridView.setAdapter(adapter);
    }

    // To avoid a memory leak on configuration change making it a inner class
    class FlickrDownloader extends AsyncTask<Void, Void, Void> {



        @Override
        protected Void doInBackground(Void... params) {
            FlickrGetter getter = new FlickrGetter();

            ArrayList<FlickrItem> newItems = getter.fetchItems();

            // clear the existing array
            items.clear();

            // add the new items to the array
            items.addAll(newItems);

            // is this correct ? - Wrong rebuilding the list view and should not be done in background
            //adapter.notifyDataSetChanged();

            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);

            adapter.notifyDataSetChanged();
        }

    }

    public void search(View view) {
        // get the flickr data
        FlickrDownloader downloader = new FlickrDownloader();
        downloader.execute();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

Mam nadzieję, że moja odpowiedź choć długo pomoże w zrozumieniu niektórych drobniejszych szczegółów.

public class RequestHandler {

    public String sendPostRequest(String requestURL,
                                  HashMap<String, String> postDataParams) {

        URL url;

        StringBuilder sb = new StringBuilder();
        try {
            url = new URL(requestURL);

            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(15000);
            conn.setConnectTimeout(15000);
            conn.setRequestMethod("POST");
            conn.setDoInput(true);
            conn.setDoOutput(true);


            OutputStream os = conn.getOutputStream();
            BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(os, "UTF-8"));
            writer.write(getPostDataString(postDataParams));

            writer.flush();
            writer.close();
            os.close();
            int responseCode = conn.getResponseCode();

            if (responseCode == HttpsURLConnection.HTTP_OK) {
                BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                sb = new StringBuilder();
                String response;
                while ((response = br.readLine()) != null){
                    sb.append(response);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    private String getPostDataString(HashMap<String, String> params) throws UnsupportedEncodingException {
        StringBuilder result = new StringBuilder();
        boolean first = true;
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (first)
                first = false;
            else
                result.append("&");

            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }

        return result.toString();
    }

}

Handler - jest medium komunikacyjnym między wątkami. W Androidzie jest używany głównie do komunikacji z głównym wątkiem poprzez tworzenie i wysyłanie wiadomości za pomocą funkcji obsługi

AsyncTask - jest używany do wykonywania długotrwałych aplikacji w wątku tła. Za pomocą N AsyncTask możesz wykonać operację w wątku tła i uzyskać wynik w głównym wątku aplikacji.

Thread - jest to proces lekki, w celu osiągnięcia współbieżności i maksymalnego wykorzystania procesora. W Androidzie możesz używać wątek do wykonywania czynności, które nie dotykają interfejsu aplikacji

Wątek

Po uruchomieniu aplikacji tworzony jest proces do wykonania kodu. Aby efektywnie wykorzystywać zasoby obliczeniowe, wątki mogą być uruchamiane w procesie, dzięki czemu można wykonywać wiele zadań w tym samym czasie. Tak więc wątki pozwalają na tworzenie wydajnych aplikacji poprzez efektywne wykorzystanie procesora bez przestojów.

W Androidzie wszystkie komponenty uruchamiają się na jednym, zwanym głównym wątku. System Android kolejkuj zadania i wykonuj je jeden po drugim w głównym wątku. Podczas długiego biegu zadania są wykonywane, aplikacja przestaje odpowiadać.

Aby temu zapobiec, można tworzyć wątki robocze i uruchamiać zadania w tle lub długotrwałe.

Handler

Ponieważ android używa modelu pojedynczego wątku, komponenty interfejsu użytkownika są tworzone bez wątku, co oznacza, że tylko utworzony wątek powinien mieć do nich dostęp, co oznacza, że komponent interfejsu powinien być aktualizowany tylko w głównym wątku. Ponieważ komponent UI działa w głównym wątku, zadania uruchamiane w wątkach roboczych nie mogą modyfikować komponentów UI. To jest gdzie Handler pojawia się w obrazie. Handler za pomocą loopera może połączyć się z nowym lub istniejącym wątkiem i uruchomić kod, który zawiera na podłączonym wątku.

Handler umożliwia komunikację między wątkami. Używając funkcji obsługi, wątek w tle może wysyłać do niego wyniki, a funkcja obsługi, która jest podłączona do głównego wątku, może aktualizować komponenty interfejsu użytkownika w głównym wątku.

AsyncTask

AsyncTask dostarczany przez Androida używa zarówno wątku, jak i obsługi, aby uruchamianie prostych zadań w tle i aktualizowanie wyników z wątku w tle do głównego wątku łatwe.

Zobacz Android thread, handler, asynctask i thread pools dla przykładów.