Quelle est la différence entre le Gestionnaire, Praticable, et les Threads?

1. Pourquoi praticable ?

Exécutable est juste une interface, vous devez instancier un thread pour le contenir. Alors que le thread contient déjà la possibilité de lancer un thread.Si vous étendez Fil, vous ne pouvez pas prolonger rien d'autre (Java ne supporte pas l'héritage multiple). Vous pouvez avoir plusieurs interfaces sur une classe, par conséquent, vous pourriez avoir Praticable.

Aussi, Lorsque vous étend la classe Thread, chaque thread crée unique de l'objet et de s'associer avec elle. Lorsque vous implements Runnable, il partage le même objet de plusieurs threads.

2. Pourquoi Utiliser de gestionnaire et quel est-il ?

Gestionnaire est écrit en Java (en interne, l'utilisation d'un Thread), donc tout ce que vous pouvez faire avec le Gestionnaire, vous pouvez réaliser à l'aide d'un Fil trop.

Alors, pourquoi devriez-vous utiliser Gestionnaire? La raison est comme ci-dessous

• Gestionnaire vous permet d'envoyer et de traiter le Message et Praticable objets
  associé à un thread MessageQueue. Pour mettre en termes simples,
  gestionnaire rend votre travail plus facile.

• Android a deux règles principales pour la manipulation de threads:

• Ne pas bloquer le thread d'INTERFACE utilisateur

• De ne pas accéder à l'INTERFACE utilisateur Android toolkit de l'extérieur de la thread de l'INTERFACE utilisateur

De se lier par les 2 règles énoncées ci-dessus, Dans android, nous avons 3 méthodes qui peuvent gérer la situation lorsque l'une de vos classes d'Activité sont exécutés sur ou appelé à partir d'un autre thread.

Nous pouvez ensuite planifier les mises à jour de l'INTERFACE utilisateur à exécuter sur le thread de l'INTERFACE utilisateur avec ces trois méthodes ci-dessous. L'Activité ou de la Vue fonctionne alors comme un gestionnaire (en savoir plus sur les gestionnaires ci-dessous) et horaires de votre exécutable pour le thread d'INTERFACE utilisateur:

1. Activité.runOnUiThread(Runnable)
   
   1. Vue.de poste(Runnable)
   2. Vue.postDelayed(Runnable, long) //(long = temps de planification)

3. Qu'est-ce que Thread d'INTERFACE utilisateur ?

Thread d'INTERFACE utilisateur est le thread principal dans lequel les éléments de l'INTERFACE utilisateur, comme la Vue et l'Activité sont rendus. De tout temps les opérations ne devrait pas arriver dans le Thread de l'INTERFACE utilisateur. L'application par défaut s'exécute dans le Thread de l'INTERFACE utilisateur. Vous n'avez rien de spécial à utiliser le Thread d'INTERFACE utilisateur.

- Je utiliser les Threads pour l'exécuter. Habituellement je voudrais écrire une classe qui étend la classe Thread et de mettre en œuvre la méthode run.

1.Quel est le point de Praticable si on peut écrire le fond de code dans la méthode run du Thread?

À l'aide de Exécutables, et la création d'un Thread de Praticable la pratique générale.

À partir d'oracle tutoriel sur la la simultanéité concernant Runnable Vs Thread utilisation :

L'objet praticable, est plus général, parce que l'objet Praticable peut sous-classe d'une classe autre que de Fil.

2.Comment est-Gestionnaire utilisé à l'intérieur de thread et pourquoi avons-nous besoin de l'utiliser.

C'est un vaste sujet à expliquer. En termes plus simples, à partir de la documentation officielle du site:

1. Gestionnaire vous permet d'envoyer et de processus Message et Runnable objets associés à un thread MessageQueue. Chaque Handler instance est associée à un seul thread et que le fil de la file d'attente de messages.

2. Lorsque vous créez un nouveau Handler, il est lié à l'thread /message de la file d'attente du thread qui est de la création d'il -- à partir de ce moment, il va livrer des messages et runnables pour que la file d'attente de messages et de les exécuter comme ils sortent de la file d'attente de messages.

3. Il y a deux utilisations principales pour un Handler: (1) à l'annexe messages et runnables pour être exécuté comme un certain moment dans l'avenir; et (2) pour mettre en file d'attente d'une action à effectuer sur un thread différent de celui de votre propre

4. Lorsqu'un processus est créé pour votre application, son thread principal est dédié à l'exécution d'un message de la file d'attente qui s'occupe de gérer le haut-niveau les objets de l'application (activités, récepteurs de radiodiffusion, etc) et toutes les fenêtres qu'ils créent. Vous pouvez créer votre propre fils, et communiquer avec le thread principal de l'application par l'intermédiaire d'un Gestionnaire. Cela se fait en appelant le même poste ou sendMessage méthodes comme avant, mais à partir de votre nouveau thread. Le Runnable ou Message va être programmée dans le Gestionnaire de file d'attente de messages et traitées le cas échéant.

Cette photo de blog.mindorks.com article par Anishar Ali explique clairement des concepts.

3.Android a une autre chose appel runOnUiThread, Comment pouvons-nous l'utiliser? Je sais qu'il est utilisé pour la mise à jour de l'INTERFACE utilisateur.

Vous pouvez trouver plus de détails en se regardant dans la mise en œuvre de runOnUiThread

/**
     * Runs the specified action on the UI thread. If the current thread is the UI
     * thread, then the action is executed immediately. If the current thread is
     * not the UI thread, the action is posted to the event queue of the UI thread.
     *
     * @param action the action to run on the UI thread
     */
    public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

Consulter ci-dessous post par exemple, le code de Handler utilisation.

Android: grillé dans un thread

Interface Runnable est parent de la Classe Thread et run() est une méthode de l'Interface Runnable
Donc, normalement, nous devrions préférer l'interface Runnable sur l'extension de classe thread parce que nous ne voulons pas changer le comportement de la classe et nous pouvons également étendre une autre classe .Il a également aider dans la réalisation de couplage ainsi que nous avons un avantage de changer l'Interface Utilisateur à partir d'une autre classe.

Nous Pouvons changer l'Interface utilisateur en 4 façons

1.By à l'aide de Gestionnaire d'exemple

public class MainActivity extends AppCompatActivity {    
private Handler mainHandler=new Handler();
class ExampleRunnable implements Runnable {
        int seconds;

        public ExampleRunnable(int seconds) {
            this.seconds = seconds;
        }

        @Override
        public void run() {
            for (int i = 0; i < seconds; i++) {
 mainHandler.post(new Runnable() {
                        @Override
                        public void run() {
                        button.setText("50% process completed");
                        }
                    });

2.By à l'Aide de runOnUIThread (), nous devons nous attacher runOnUIThread avec la poste, il peut être facilement compris avec l'exemple

class ExampleRunnable implements Runnable {
        int seconds;



 public ExampleRunnable(int seconds) {
        this.seconds = seconds;
    }

    @Override
    public void run() {runOnUIThread.post(new Runnable() {
                    @Override
                    public void run() {
                        button.setText(" Runnable");
                    }
                });
            }

3.By à l'aide de n'importe quelle Vue, nous pouvons l'appeler par n'importe quel point de vue ici, j'ai appelé avec interrupteur

public class MainActivity extends AppCompatActivity {
 private Switch aSwitch;
@Override
    protected void onCreate(Bundle savedInstanceState) {
 aSwitch=findViewById(R.id.switch1);
class ExampleRunnable implements Runnable {
            int seconds;



     public ExampleRunnable(int seconds) {
            this.seconds = seconds;
        }

        @Override
        public void run() { aSwitch.post(new Runnable() {
                        @Override
                        public void run() {
                            button.setText(" Runnable");
                        }
                    });
                }

4.By prise de Gestionnaire dans un autre Thread, nous devons définir un Looper, car par défaut, il nous joindre à notre fil boucleur

Handler threadHandler=new Handler(Looper.getMainLooper());
threadHandler.post(new Runnable()
{
                            @Override
                            public void run() {
                                button.setText(" Runnable");
                            }
                        });
                    }

Ce sont 4 manières de mettre en œuvre donc, je pense que vous pouvez maintenant quelque chose à propos de runnable fil et runOnUIThread() et le Gestionnaire est écrit par une autre personne à merveille.