Ejecute AsyncTask varias veces

En mi Actividad, uso una clase que se extiende desde AsyncTask y un parámetro que es una instancia de ese AsyncTask. Cuando llamo mInstanceOfAT.execute("")todo está bien. Pero la aplicación se bloquea cuando presiono un botón de actualización que vuelve a llamar a AsyncTask (en caso de que el trabajo de red no funcione). Porque luego aparece una excepción que dice

No se puede ejecutar la tarea: la tarea ya se ha ejecutado (una tarea se puede ejecutar solo una vez)

He intentado llamar a cancel (true) para la instancia de Asyctask, pero tampoco funciona. La única solución hasta ahora es crear nuevas instancias de Asyntask. ¿Es esa la forma correcta?

Gracias.

AsyncTask las instancias solo se pueden usar una vez.

En cambio, simplemente llame a su tarea como new MyAsyncTask().execute("");

De los documentos de la API AsyncTask:

Reglas de enhebrado

Hay algunas reglas de subprocesos que se deben seguir para que esta clase funcione correctamente:

• La instancia de la tarea debe crearse en el subproceso de la interfaz de usuario.
• execute (Params ...) debe invocarse en el hilo de la interfaz de usuario.
• No llame a onPreExecute (), onPostExecute (Result), doInBackground (Params ...), onProgressUpdate (Progress ...) manualmente.
• La tarea se puede ejecutar solo una vez (se lanzará una excepción si se intenta una segunda ejecución).

Las razones de las instancias de disparo y olvido de ASyncTask se detallan bastante bien en la respuesta de Steve Prentice. Sin embargo, aunque tiene restricciones sobre cuántas veces ejecuta ASyncTask, puede hacer lo que quiera mientras el hilo se está ejecutando. .

Coloque su código ejecutable dentro de un bucle dentro de doInBackground () y use un bloqueo concurrente para activar cada ejecución. Puede recuperar los resultados con PubliveProgress () / onProgressUpdate () .

Ejemplo:

class GetDataFromServerTask extends AsyncTask<Input, Result, Void> {

    private final ReentrantLock lock = new ReentrantLock();
    private final Condition tryAgain = lock.newCondition();
    private volatile boolean finished = false;

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

        lock.lockInterruptibly();

        do { 
            // This is the bulk of our task, request the data, and put in "result"
            Result result = ....

            // Return it to the activity thread using publishProgress()
            publishProgress(result);

            // At the end, we acquire a lock that will delay
            // the next execution until runAgain() is called..
            tryAgain.await();

        } while(!finished);

        lock.unlock();
    }

    @Override
    protected void onProgressUpdate(Result... result) 
    {
        // Treat this like onPostExecute(), do something with result

        // This is an example...
        if (result != whatWeWant && userWantsToTryAgain()) {
            runAgain();
        }
    }

    public void runAgain() {
        // Call this to request data from the server again
        tryAgain.signal();
    }

    public void terminateTask() {
        // The task will only finish when we call this method
        finished = true;
        lock.unlock();
    }

    @Override
    protected void onCancelled() {
        // Make sure we clean up if the task is killed
        terminateTask();
    }
}

Por supuesto, esto es un poco más complicado que el uso tradicional de ASyncTask, y abandonas el uso de PubliveProgress () para los informes de progreso reales. Pero si le preocupa la memoria, este enfoque garantizará que solo quede un ASyncTask en el montón en tiempo de ejecución.

Tuve el mismo problema. En mi caso, tengo una tarea que quiero hacer dentro onCreate()y fuera onResume(). Así que hice mi Asynctask estática y obtuve la instancia de ella. Ahora todavía tenemos el mismo problema.

Entonces, lo que hice en onPostExecute () es esto:

instance = null;

Teniendo en cuenta que compruebo en el método getInstance estático que mi instancia no es nula, de lo contrario la creo:

if (instance == null){
    instance = new Task();
}
return instance;

El método en postExecute vaciará la instancia y la recreará. Por supuesto, esto se puede hacer fuera de la clase.

He hecho que mis tareas de rotación sean estáticas, lo que me ayudó a adjuntarlas, separarlas y volver a conectarlas a los hilos de la interfaz de usuario en los cambios de rotación. Pero para volver a su pregunta, lo que hago es crear una bandera para ver si el hilo se está ejecutando. Cuando desee reiniciar el hilo, verifico si la tarea de rotación se está ejecutando, si es, brindo una advertencia. Si no es así, lo hago nulo y luego creo uno nuevo, que evitará el error que está viendo. Además, al completar con éxito, anulo la tarea de reconocimiento de rotación completada para que esté lista para continuar nuevamente.

Sí, es cierto, el documento dice que solo se puede ejecutar un Asyntask.

Cada vez que necesite usarlo debe tener una instancia:

// Any time if you need to call her
final FirmwareDownload fDownload = new FirmwareDownload();
fDownload.execute("your parameter");

static class FirmwareDownload extends AsyncTask<String, String, String> {
}