Début AsyncTask à partir d'un autre AsyncTask doInBackground()

Selon le post ci-dessous, vous pouvez faire Activité.runOnUiThread() pour exécuter un Exécutable sur-le-main-Fil (à partir d'un autre thread).

• Code en cours d'exécution dans le thread principal à partir d'un autre thread

Donc, théoriquement, vous pourriez faire ceci:

• Exécuter la Tâche Asynchrone
• ne Activité.runOnUiThread(Praticable) à l'intérieur de votre AsyncTask et de commencer une nouvelle AsyncTask de l'intérieur de cette praticable

Comme son nom l'indique de l'Activité.runOnUiThread() exécute la exécutables sur-le-main-fil

Mais c'est le genre de hacky.

Code devrait ressembler à quelque chose comme ceci: (pas de test)

//first task
    (new AsyncTask<String, String, String>() {

        @Override
        protected String doInBackground(String... params) {
            ParentActitity.this.runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    //second async stared within a asynctask but on the main thread
                    (new AsyncTask<String, String, String>() {

                        @Override
                        protected String doInBackground(String... params) {
                            //TODO Auto-generated method stub
                            return null;
                        }

                    }).execute();

                }
            });
            return null;
        }

    }).execute();

Ce imbriquée exemple n'est pas un bon style à utiliser dans la production, parce que (à mon humble avis) de ses illisible.

Remarques Supplémentaires:

Activité.runOnUiThread(Runnable) est pas statique! C'est pourquoi mon exemple utilise ParentActivity(.c').runOnUiThread(Runnable).

OriginalL'auteur Langusten Gustel

Vous ne pouvez pas faire dans doInBackground() mais vous pouvez à partir de onProgressUpdate() par exemple puisqu'il s'exécute sur le thread d'INTERFACE utilisateur. Il suffit de garder à l'esprit que, après 3,0 ils seront placés sur la même file d'attente et ne sera pas s'exécuter en parallèle, voir executeOnExecutor

OriginalL'auteur Dan Pena

Essentiellement de l'échantillon que j'ai écrit;

public class MainActivity extends Activity {

View view;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    view = new View(this);
    setContentView(view);

    view.setBackgroundColor(Color.RED);

    new FirstTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null);
}

private class FirstTask extends AsyncTask<Void, Void, Void>
{
    @Override
    protected Void doInBackground(Void... params) {

        new SecondTask().execute();
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
        Log.e("task","first");
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        view.setBackgroundColor(Color.GREEN);   
    }

}

private class SecondTask extends AsyncTask<Void, Void, Void>
{
    @Override
    protected Void doInBackground(Void... params) {
        Log.e("task","second");
        return null;
    }
}

}

OriginalL'auteur nurisezgin

c'est pas mieux de prendre ces quelques inet actions et de les impliquer en démarrer un Thread séparé qui va gérer cette partie de la gestion des données ?
google mettre partout c'est des modèles qui, si u regarder de plus près, elles sont toutes dérivées de simples classes... cette API permet android, comme une toile d'araignée de rappel impliquant de rappel... Essayer de comprendre les bases de java et il ne sera pas difficile d'écrire un morceau de code de qualité. Services/contenus résolveurs/récepteurs/chargeurs sont limitées en quelque sorte... Threads sont presque en mesure de réaliser tout ce que tu souhaite...

La plupart d'entre vous utilise le code sans réfléchir et ne pas même essayer de comprendre comment il fonctionne, et comprendre ce qui est la clé de programmation. J'essaie de ne pas utiliser de code dont les bases, je ne sais pas. Et si j'en ai besoin j'ai étudié à fond. J'ai utilisé Java pour la magie noire maintenant, je pense que c'est le FLUX de DONNÉES A-> B-> C, etc .. bonne circulation est essentiel.

EDIT:

oui, j'ai écrit la solution pour youre problème

il y a de nombreuses façons de réaliser que ce que tu veux mais c'est pas de ma réponse à l'écrivain de code pour vous

• vous pouvez utiliser IntentService classe à laquelle il est intégré dans la file d'attente --- il suffit d'utiliser distinct startService() appelle pour chaque transfert.

• vous pouvez utiliser Thread - ma préférée façon

• vous pouvez utiliser le Service de

• vous pouvez utiliser AsyncTaskLoader

• mais ne pas utiliser de ASYNC TASK si u besoin de tirer plus de DEUX liés les uns avec les autres à la FOIS ils sont tous sur les TÉLÉPHONES MODERNES s'EXÉCUTE en tant que la FILE d'attente sur un seul thread (ps. vous pouvez les exécuter sur EXECUOR comme une solution de contournement)

Depuis JAVA 1.5 tâches sont séparées de threads
- il a été ajouté

quoi faire du veux dire par la coutume fil

THREAD (comme nous en parler) n'est pas un THREAD OBJET de CLASSE mais c'est une TÂCHE définie dans la méthode run() de la CLASSE THREAD, donc toute CLASSE DÉRIVÉE de THREAD COMMENCE TOUJOURS THREAD (aka TÂCHE)

    public synchronized void start() {
        checkNotStarted();

        hasBeenStarted = true;
        /** 
         * look at this line i'ts rerouting run() code of youre thread class  
         * to native method from there thread is created in pure C code 
         */
        nativeCreate(this, stackSize, daemon);
    }

comme ceci par exemple dans POSIX :

int  pthread_create(pthread_t  *  thread, pthread_attr_t * attr, void *
   (*start_routine)(void *), void * arg);

à partir de ce point, nous pouvons parler de MULTITÂCHE lors de l'OS est de l'exécution de plusieurs tâches sur une certaine période de temps en exécutant simultanément

depuis JAVA 1.5 ther est une Exécuteur interface qui fournit un moyen de découplage de la tâche de mémoire de la mécanique de la façon dont chaque tâche doit être exécutée, y compris les détails de fil de l'utilisation, de la planification, etc. L'exécuteur testamentaire est normalement utilisé à la place explicitement la création de threads. Vous avez beaucoup d'exécuteurs testamentaires de l'un d'eux est: ThreadPerTaskExecutor

class ThreadPerTaskExecutor implements Executor {
      public void execute(Runnable r) {
          new Thread(r).start();
      }
  }

Ce exécuteur génère un nouveau thread pour chaque tâche.

pour en revenir à AsyncTask:

AsyncTaskM<P, P, R>.executeOnExecutor(Executor,P);

permettre à de multiples tâches à exécuter en parallèle sur un pool de threads gérés par AsyncTask, cependant, vous pouvez également utiliser votre propre interprète pour l'custombehavior.

et oui si vous ne Vous sentez pas à la hauteur et de ne pas en savoir assez beeter à quelqu'un d'autre de le faire 🙂

J'espère que cet ajout de changer votre esprit au sujet de votre vote.

OriginalL'auteur ceph3us