Когда использовать AsyncTask и когда использовать Thread на Android

Ответ 1

Помогите вам:

Для длительных задач мы используем потоки Java и собственный AsyncTask для Android.

В основном использовать AsyncTask для:

• Простые сетевые операции, которые не требуют загрузки большого количества данных.
• Задачи, связанные с диском, которые могут занимать более нескольких миллисекунд

И использовать потоки Java для:

• Сетевые операции, которые включают в себя данные с умеренными или большими объемами (загрузка или загрузка)
• Задачи с высоким процессором, которые нужно запускать в фоновом режиме
• Любая задача, в которой вы хотите контролировать использование ЦП относительно потока GUI

Для получения дополнительной информации обратитесь Ответ Мохита Нажмите здесь

Изменить:

Сервис похож на Activity, но не имеет интерфейса. Вероятно, если вы хотите получить прогноз погоды, например, вы не создадите для него пустую деятельность, для этого вы будете использовать Сервис. Служба - это доступ к объекту Context, который имеет независимый жизненный цикл. Это позволяет повторно использовать общий код во многих действиях и, в случае публичных или открытых сервисов во многих приложениях....

A Thread - это Thread, возможно, вы уже знаете его с другой стороны. Вам нужно знать, что вы не можете обновлять пользовательский интерфейс из потока. Вам нужно использовать Handler для этого, и иногда прекращается поток. Нить - это механизм для работы без блокировки другой работы...

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

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

Ответ 2

AsyncTask - это просто "вспомогательный" класс, оснащенный Android SDK, чтобы упростить переход к потоку пользовательского интерфейса после завершения фоновой задачи. Он построен поверх стандартного API потоков Java. Он не дает комментариев, которые не могут быть выполнены только с помощью Threads. В нем рассматривается общий сценарий переключения между фоновым потоком коротких задач и потоком пользовательского интерфейса.

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

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

EDIT:

Некоторые другие ответы здесь показывают, что использование AsyncTask должно ограничиваться короткими задачами. Предположительно потому, что он использует общий пул. Однако это уже не так, поскольку API Level 11 (так, довольно долгое время). Вы можете использовать executeOnExecutor вместо execute для выполнения AsyncTask в выделенном пуле потоков. См. http://developer.android.com/reference/android/os/AsyncTask.html#executeOnExecutor%28java.util.concurrent.Executor,%20Params...%29

Поскольку примеры обычно более коммуникативны, посмотрите на пример ниже.

Предположим, что у нас есть статическая функция для выполнения какой-то тяжелой задачи и TextView, которую мы хотим отобразить как прогресс и окончательный статус задачи, объявленной ниже:

static Object doHeavyTask(String string) throws Exception;

TextView progressInfo;

Выполнение задачи в фоновом потоке с использованием async-задачи будет выглядеть так:

new AsyncTask<String, Integer, Exception>() {

    @Override
    protected Exception doInBackground(String... params) {
        for (int i = 0; i < params.length; i++) {
            try {
                doHeavyTask(params[i]);
            } catch (Exception e) {
                return e;
            }
            publishProgress(i, params.length);
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        progressInfo.setText("Executed " + values[0] + 
            " of " + values[1] + " tasks.");
    }

    @Override
    protected void onPostExecute(Exception result) {
        if (result == null) {
            progressInfo.setText("Heavy background job done successfully!");
        }
        else {
            progressInfo.setText("Heavy background job failed!" + 
                "Exception message: " + result.getMessage());
        }
    }
}.execute("input1", "input2", "input3");

Точно так же может быть достигнуто с помощью Thread:

final Handler handler = new Handler(Looper.getMainLooper());
final String[] params = { "input1", "input2", "input3" };
new Thread() {

    @Override
    public void run() {
        for (int i = 0; i < params.length; i++) {
            try {
                doHeavyTask(params[i]);
            } catch (final Exception e) {
                handler.post(new Runnable() {

                    @Override
                    public void run() {
                        progressInfo.setText("Heavy background job failed!" +
                            "Exception message: " + e.getMessage());
                    }
                });
                return;
            }

            final int currentIndex = i;
            handler.post(new Runnable() {

                @Override
                public void run() {
                    progressInfo.setText("Executed " + currentIndex +
                            " of " + params.length + " tasks.");
                }
            });
        }

        handler.post(new Runnable() {

            @Override
            public void run() {
                progressInfo.setText(
                    "Heavy background job done successfully!");
            }
        });
    }
}.start();

Как вы видите выше, использование AsyncTask просто немного более удобно. Но нет другого преимущества, просто это удобство:). Если вы подготовили свою собственную задачу, инкапсулирующую Thread (и обработчик, чтобы перейти к потоку пользовательского интерфейса), возможно, ваш класс будет более эффективен/удобен для вас. Это все:).

Ответ 3

Вы можете запускать несколько потоков одновременно. Но asynctask находится в очереди, то есть она запускает одну задачу за раз.