Обработчик против AsyncTask против потока

Handler - это средство связи между потоками. В Android он в основном используется для связи с основным потоком, создавая и отправляя сообщения через обработчик

AsyncTask - используется для выполнения долго работающих приложений в фоновом потоке. С помощью n AsyncTask вы можете выполнить операцию в фоновом потоке и получить результат в основном потоке приложения.

Thread - это процесс с малым весом, обеспечивающий параллелизм и максимальное использование процессора. В Android вы можете использовать поток для выполнения действий, которые не касаются пользовательского интерфейса приложения

Если мы посмотрим на исходный код, то увидим, что AsyncTask и Handler написаны исключительно на Java. (Однако есть некоторые исключения. Но это не важный момент).

Так что в AsyncTask или Handler нет магии. Эти классы облегчают нашу жизнь как разработчика.

Например: если программа A вызывает метод A (), метод A () может выполняться в другом потоке с программой A. Мы можем легко проверить с помощью следующего кода:

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

Почему мы должны использовать новый поток для некоторых задач? Вы можете Google для этого. Много много причин, например: тяжелые подъемы, длительные работы.

Итак, каковы различия между Thread, AsyncTask и Handler?

AsyncTask и Handler написаны на Java (внутренне они используют Thread), так что все, что мы можем сделать с Handler или AsyncTask, мы можем достичь с помощью Thread.

Чем действительно могут помочь Handler и AsyncTask?

Наиболее очевидной причиной является связь между потоком вызывающего и рабочим потоком. ( Поток вызывающих : Поток, который вызывает рабочий поток для выполнения некоторых задач. Поток вызывающих не обязательно должен быть потоком пользовательского интерфейса). Конечно, мы можем общаться между двумя потоками другими способами, но есть много недостатков (и опасностей) из-за безопасности потоков.

Вот почему мы должны использовать Handler и AsyncTask. Эти классы выполняют большую часть работы за нас, нам нужно только знать, какие методы переопределить.

Разница между Handler и AsyncTask заключается в следующем: Используйте AsyncTask, когда Поток вызывающего абонента является Поток пользовательского интерфейса . Вот что говорится в документе Android:

AsyncTask позволяет правильно и легко использовать поток пользовательского интерфейса. Этот класс позволяет выполнять фоновые операции и публиковать результаты в потоке пользовательского интерфейса без необходимости манипулировать потоками и / или обработчиками.

Я хочу подчеркнуть два момента:

1) Простое использование поток пользовательского интерфейса (поэтому используйте, когда потоком вызывающего является поток пользовательского интерфейса).

2) Нет необходимости манипулировать обработчиками. (означает: вы можете использовать Handler вместо AsyncTask, но AsyncTask - более простой вариант).

В этом посте есть много вещей, которые я еще не сказал, например: что такое поток пользовательского интерфейса или почему это проще. Вы должны знать некоторые методы каждого класса и использовать его, вы полностью поймете причину.

@: когда вы читаете документ Android, вы увидите:

Обработчик позволяет отправлять и обрабатывать объекты Message и Runnable, связанные с MessageQueue потока

Поначалу это описание может показаться странным. Нам нужно только понять, что у каждого потока есть каждая очередь сообщений (например, список дел), и поток будет принимать каждое сообщение и делать это до тех пор, пока очередь сообщений не станет пустой (точно так же, как мы завершим нашу работу и ложимся спать). Таким образом, когда Handler связывается, он просто выдает сообщение вызывающему потоку и ожидает обработки.

Сложно? Просто помните, что Handler может безопасно общаться с потоком вызывающего.

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

}

AsyncTask предназначен для выполнения не более нескольких секунд операции, выполняемой в фоновом режиме (не рекомендуется для загрузки файлов с сервера в мегабайтах или для выполнения ресурсоемких задач, таких как операции ввода-вывода файла). Если вам нужно выполнить длительную операцию, вам настоятельно рекомендуется использовать нативные потоки Java. Java предоставляет вам различные связанные с потоками классы, чтобы делать то, что вам нужно. Используйте Handler для обновления пользовательского интерфейса.

Thread:

Вы можете использовать новый Thread для длительных фоновых задач без влияния на поток пользовательского интерфейса. В ветке Java вы не можете обновить ветку пользовательского интерфейса.

Поскольку обычный поток не очень полезен для архитектуры Android, были введены вспомогательные классы для потоков.

Вы можете найти ответы на свои вопросы на странице документации по производительности потоков .

Обработчик :

A Handler позволяет отправлять и обрабатывать объекты Message и Runnable, связанные с MessageQueue потока. Каждый экземпляр Handler связан с одним потоком и очередью сообщений этого потока.

Существует два основных варианта использования Handler:

1. Для планирования сообщений и исполняемых файлов, которые будут выполняться как-то в будущем;

2. Поставить в очередь действие, которое будет выполнено в потоке, отличном от вашего.

AsyncTask :

AsyncTask обеспечивает правильное и простое использование потока пользовательского интерфейса. Этот класс позволяет выполнять фоновые операции и публиковать результаты в потоке пользовательского интерфейса без необходимости манипулировать потоками и / или обработчиками.

Недостатки:

1. По умолчанию приложение помещает все объекты AsyncTask, которые оно создает, в один поток. Поэтому они выполняются последовательно и, как и в случае основного потока, особенно длинный рабочий пакет может блокировать очередь. По этой причине используйте AsyncTask для обработки рабочих элементов, длина которых меньше 5 мс .

2. AsyncTask объекты также являются наиболее распространенными нарушителями для неявных ссылок. AsyncTask объекты представляют риски, связанные с явными ссылками, а также.

HandlerThread :

Вам может потребоваться более традиционный подход к выполнению блока работы над более длинным потоком ( в отличие от AsyncTask, который следует использовать для Рабочая нагрузка 5 мс ) и некоторая возможность управлять этим рабочим процессом вручную. Поток-обработчик, по сути, является долго выполняющимся потоком, который захватывает работу из очереди и обрабатывает ее.

ThreadPoolExecutor :

Этот класс управляет созданием группы потоков, устанавливает их приоритеты и управляет распределением работы между этими потоками. Когда рабочая нагрузка увеличивается или уменьшается, класс раскручивается или уничтожает больше потоков, чтобы приспособиться к рабочей нагрузке.

Если рабочая нагрузка больше, а одного HandlerThread недостаточно, вы можете перейти к ThreadPoolExecutor

Однако я хотел бы, чтобы соединение сокетов выполнялось в службе. Должно ли это выполняться в обработчике или потоке, или даже в AsyncTask? Взаимодействие с интерфейсом вообще не нужно. Имеет ли это значение с точки зрения производительности, которую я использую?

Поскольку взаимодействие с пользовательским интерфейсом не требуется, вы не можете пойти на AsyncTask. Обычные потоки не очень полезны и, следовательно, HandlerThread - лучший вариант. Поскольку вы должны поддерживать сокетное соединение, обработчик в главном потоке вообще бесполезен. Создайте HandlerThread и получите Handler от петлителя HandlerThread.

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

Если вы хотите связаться с потоком пользовательского интерфейса, вы можете использовать еще один обработчик для обработки ответа.

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

в вашем Runnable вы можете добавить

responseHandler.sendMessage(msg);

Более подробную информацию о реализации можно найти здесь:

Android: Toast in a нить [тысяча сто двадцать-восемь] [тысяча сто шестьдесят-одны]

Позвольте мне попытаться ответить на вопрос здесь с примером :) - MyImageSearch [Пожалуйста, посмотрите изображение здесь на главном экране активности - содержащее текст редактирования / кнопку поиска / вид сетки]

Описание MyImageSearch - Как только пользователь введет детали в поле для редактирования текста и нажмет на кнопку поиска, мы будем искать изображения на Интернет через веб-сервисы, предоставляемые flickr (вам нужно только зарегистрироваться там, чтобы получить ключ / секретный токен) - для поиска мы отправляем HTTP-запрос и ПОЛУЧАЕМ JSON-данные обратно в ответ, содержащие URL-адреса отдельных изображений, которые мы затем будем использовать загрузить вид сетки.

Моя реализация - В основном задании я определю внутренний класс, который расширяет AsyncTask для отправки HTTP-запроса в метод doInBackGround, извлечения ответа JSON и обновления моего локального ArrayList из FlickrItems, который Я собираюсь использовать для обновления моего GridView через FlickrAdapter (расширяет BaseAdapter) и вызывать adaptor.notifyDataSetChanged () в onPostExecute () AsyncTask для перезагрузки вида сетки. Обратите внимание, что здесь HTTP-запрос является блокирующим вызовом, из-за которого я сделал это через AsyncTask. И я могу кэшировать элементы в адаптере, чтобы увеличить производительность или сохранить их на SDCard. Сетка, которую я буду раздувать в FlickrAdapter, содержит в моей реализации индикатор выполнения и представление изображения. Ниже вы можете найти код для mainActivity, который я использовал.

Ответ на вопрос сейчас - Таким образом, когда у нас есть данные JSON для выборки отдельных изображений, мы можем реализовать логику получения изображений в фоновом режиме с помощью обработчиков или потоков или AsyncTask. Здесь следует отметить, что, поскольку мои загруженные изображения должны отображаться в пользовательском интерфейсе / главном потоке, мы не можем просто использовать потоки в том виде, как они есть, поскольку они не имеют доступа к контексту. В FlickrAdapter я мог придумать варианты:

• Вариант 1: Создать LooperThread [расширяет поток] - и продолжать загружать изображения последовательно в одном потоке, сохраняя этот поток открытым [looper.loop ( )]
• Вариант 2: Используйте пул потоков и опубликуйте исполняемый файл через myHandler, который содержит ссылку на мой ImageView, но поскольку представления в сеточном представлении перерабатываются, снова может возникнуть проблема, когда изображение с индексом 4 отображается в индексе 9 [загрузка может занять больше времени]
• Вариант 3 [Я использовал это]: использовать пул потоков и отправить сообщение myHandler, который содержит данные, относящиеся к индексу ImageView и Сам ImageView, поэтому при выполнении handleMessage () мы будем обновлять ImageView только в том случае, если currentIndex соответствует индексу изображения, которое мы пытались загрузить.
• Вариант 4: используйте AsyncTask для загрузки изображений в фоновом режиме, но здесь у меня не будет доступа к количеству потоков, которое я хочу в пуле потоков, и оно зависит от версии Android, но в Варианте 3 я могу сделать сознательного решения о размере пула потоков в зависимости от используемой конфигурации устройства.

Вот исходный код:

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

Я надеюсь, что мой ответ, хотя долго, поможет в понимании некоторых из более мелких деталей.

Тема

Android поддерживает стандартные потоки Java . Вы можете использовать стандартные потоки и инструменты из пакета «java.util.concurrent», чтобы поместить действия в фоновый режим. Единственным ограничением является то, что вы не можете напрямую обновлять пользовательский интерфейс из фонового процесса.

Если вам нужно обновить пользовательский интерфейс из фоновой задачи, вам нужно использовать некоторые классы для Android. Для этого вы можете использовать класс «android.os.Handler» или класс «AsyncTask»

Обработчик

Класс «Handler» может обновлять пользовательский интерфейс. , Дескриптор предоставляет методы для получения сообщений и для запуска. Чтобы использовать обработчик, вы должны создать его подкласс и переопределить handleMessage() для обработки сообщений. Для обработки Runable вы можете использовать метод post();. В вашей активности вам нужен только один экземпляр обработчика.

Вы можете отправлять сообщения с помощью метода sendMessage(Message msg) или sendEmptyMessage.

AsyncTask

Если у вас есть Activity, который должен загружать контент или выполнять операции, которые можно выполнять в фоновом режиме AsyncTask, позволяет поддерживать отзывчивый пользовательский интерфейс и публиковать ход выполнения этих операций для пользователя.

Для получения дополнительной информации вы можете посмотреть по этим ссылкам.

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

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

AsyncTask используется для выполнения некоторых фоновых вычислений и публикации результата в потоке пользовательского интерфейса (с необязательными обновлениями прогресса). Поскольку вас не интересует пользовательский интерфейс, тогда Handler или Thread кажется более подходящим.

Вы можете создавать фон Thread и передавать сообщения обратно в основной поток, используя метод Handler post.

Посмотрев вглубь, он прямо вперед.

AsyncTask:

Это простой способ использовать поток , ничего не зная о модели потока Java . AsyncTask дает различные обратные вызовы, относящиеся к рабочему потоку и основному потоку.

Используйте для небольших операций ожидания, таких как:

1. Извлечение некоторых данных из веб-сервисов и отображение поверх макета.
2. Запрос к базе данных.
3. Когда вы понимаете, что запущенная операция никогда не будет вложенной.

Handler:

Когда мы устанавливаем приложение в Android, оно создает поток для этого приложения с именем MAIN UI Thread. Все действия выполняются в этой ветке. По правилу однопоточной модели android мы не можем получить доступ к элементам пользовательского интерфейса (растровое изображение, текстовое представление и т. Д.) Напрямую для другого потока, определенного внутри этого действия.

Обработчик позволяет вам общаться с потоком пользовательского интерфейса из другого фонового потока. Это полезно в Android, так как Android не позволяет другим потокам напрямую взаимодействовать с потоком пользовательского интерфейса. Обработчик может отправлять и обрабатывать объекты Message и Runnable, связанные с MessageQueue потока. Каждый экземпляр обработчика связан с одним потоком и очередью сообщений этого потока. Когда создается новый обработчик, он привязывается к потоку / очереди сообщений потока, который его создает.

Лучше всего подходит для:

1. Позволяет создавать очереди сообщений.
2. Планирование сообщений.

Thread:

Теперь пришло время поговорить о теме.

Thread является родителем как AsyncTask, так и Handler. Они оба внутренне используют поток, что означает , что вы также можете создать свою собственную модель потока , такую ​​как AsyncTask и Handler, но для этого требуется хорошее знание реализации многопоточности Java .

Тема

Когда вы запускаете приложение, создается процесс для выполнения кода. Чтобы эффективно использовать вычислительный ресурс, потоки могут быть запущены внутри процесса, чтобы одновременно можно было выполнить несколько задач. Таким образом, потоки позволяют создавать эффективные приложения, эффективно используя процессор без простоев.

В Android все компоненты выполняются в одном основном потоке. Задачи очереди Android и выполняйте их одну за другой в главном потоке. Когда долго выполняющиеся задачи выполняются, приложение перестает отвечать на запросы.

Чтобы предотвратить это, вы можете создавать рабочие потоки и запускать фоновые или долго выполняющиеся задачи.

Обработчик

Поскольку android использует однопоточную модель, компоненты пользовательского интерфейса создаются не поточно-безопасными, то есть доступ к ним должен иметь только созданный им поток, то есть компонент пользовательского интерфейса должен обновляться в основном потоке. только. Поскольку компонент пользовательского интерфейса выполняется в основном потоке, задачи, выполняемые в рабочих потоках, не могут изменять компоненты пользовательского интерфейса. Это где Handler входит в картину. Обработчик с помощью Looper может подключиться к новому потоку или существующему потоку и запустить код, который он содержит в подключенном потоке.

Обработчик делает возможным взаимодействие между потоками. Используя Handler, фоновый поток может отправлять ему результаты, а обработчик, подключенный к основному потоку, может обновлять компоненты пользовательского интерфейса в основном потоке.

AsyncTask

AsyncTask, предоставляемый android, использует как поток, так и обработчик для упрощения выполнения простых задач в фоновом режиме и обновления результатов из фонового потока в основной поток.

См. android thread, handler, asynctask и пулы потоков для примеров.

По моему мнению, потоки - не самый эффективный способ выполнения соединений с сокетами, но они обеспечивают большую функциональность с точки зрения запуска потоков. Я говорю это потому, что из-за опыта, длительный запуск потоков приводит к тому, что устройства становятся очень горячими и ресурсоемкими. Даже простой while(true) разогреет телефон за считанные минуты. Если вы говорите, что взаимодействие с пользовательским интерфейсом не важно, возможно, AsyncTask хорошо, потому что они предназначены для долгосрочных процессов. Это всего лишь мое мнение по этому поводу.

ОБНОВЛЕНИЕ

Пожалуйста, не обращайте внимания на мой ответ выше! Я ответил на этот вопрос еще в 2011 году, когда у меня было гораздо меньше опыта в Android, чем сейчас. Мой ответ выше вводит в заблуждение и считается неправильным. Я оставляю это там, потому что многие люди прокомментировали это ниже, исправляя меня, и я усвоил свой урок.

В этой теме есть гораздо лучшие ответы, но я, по крайней мере, дам более правильный ответ. Нет ничего плохого в использовании обычной Java Thread; тем не менее, вы должны быть очень осторожны с реализацией этого, потому что неправильное выполнение может быть очень ресурсоемким (наиболее заметным симптомом может быть нагрев вашего устройства). AsyncTask довольно идеальны для большинства задач, которые вы хотите запускать в фоновом режиме (типичными примерами являются дисковый ввод-вывод, сетевые вызовы и вызовы базы данных). Тем не менее, AsyncTask не следует использовать для особенно длительных процессов, которые, возможно, потребуется продолжить после того, как пользователь закрыл ваше приложение или перевел свое устройство в режим ожидания. Я бы сказал, что в большинстве случаев обо всем, что не относится к потоку пользовательского интерфейса, можно позаботиться в AsyncTask.

Это зависит, какой к выбрал, основан на Обработчике требований

, главным образом используется для переключения от другого потока до основного потока, Обработчик присоединен к выполняющему мертвую петлю летчику, на котором это отправляет свою выполнимую задачу в очереди. Таким образом, Если Вы уже находитесь в другом потоке и переключаетесь на основной поток затем, Вам нужен дескриптор вместо асинхронной задачи или другого потока

, Если Обработчик создал в кроме основного потока, который не является выполняющим мертвую петлю летчиком, не даст ошибку, поскольку дескриптор создается поток, тот поток должен быть сделан, lopper

AsyncTask используется для выполнения кода в течение нескольких секунд, которые работают на фоновом потоке, и дает его результат основному потоку ** *AsyncTask Ограничения 1. Асинхронная Задача не присоединена к жизненному циклу действия, и это сохраняет выполненным, даже если его действие уничтожило, тогда как загрузчик не имеет этого ограничения 2. Все Асинхронные Задачи совместно используют тот же фоновый поток для выполнения, которые также влияют на производительность приложения

, Поток используется в приложении для фоновой работы также, но это не имеет, любой перезванивает на основном потоке. Если требование удовлетворяет некоторым потокам вместо одного потока и который должен дать задачу много раз затем, исполнитель пула потоков является более оптимальным вариантом. Например, Требование Изображения, загружающегося от нескольких URL как скольжение.