new Runnable () mais pas de nouveau thread?

J'essaie de comprendre le code ici , plus précisément de la classe anonyme

private Runnable mUpdateTimeTask = new Runnable() {
public void run() {
   final long start = mStartTime;
   long millis = SystemClock.uptimeMillis() - start;
   int seconds = (int) (millis / 1000);
   int minutes = seconds / 60;
   seconds     = seconds % 60;

   if (seconds < 10) {
       mTimeLabel.setText("" + minutes + ":0" + seconds);
   } else {
       mTimeLabel.setText("" + minutes + ":" + seconds);            
   }

   mHandler.postAtTime(this,
           start + (((minutes * 60) + seconds + 1) * 1000));
   }
};

Le dit l'article

Le Gestionnaire exécute la mise à jour du code en tant que partie de votre thread principal, en évitant la surcharge d'un deuxième thread..

Ne devrait pas créer une nouvelle classe Runnable faire un nouveau thread? Quel est le but de la classe Runnable ici, en plus d'être en mesure de passer à une classe Runnable à postAtTime?

Grâce

source d'informationauteur sgarg

41

Runnable est souvent utilisé pour donner le code qu'un thread doit s'exécuter, mais Runnable lui-même n'a rien à voir avec les threads. C'est juste un objet avec un run() méthode.

Dans Android, la Handler classe peut être utilisée pour poser le cadre d'exécuter du code plus tard sur le même fil, plutôt que sur une autre. Runnable est utilisé pour fournir le code qui doit s'exécuter plus tard.

Si vous souhaitez créer un nouveau Thread...vous pouvez faire quelque chose comme ça...

Thread t = new Thread(new Runnable() { public void run() { 
  //your code goes here... 
}});

La Runnable interface est une autre façon dont vous pouvez mettre en place le multi-threading autre que l'extension de la Thread classe en raison du fait que Java permet de prolonger d'une seule classe.

Toutefois, vous pouvez utiliser le nouveau Thread(Runnable exécutables) constructeur, quelque chose comme ceci:

private Thread thread = new Thread(new Runnable() {
public void run() {
   final long start = mStartTime;
   long millis = SystemClock.uptimeMillis() - start;
   int seconds = (int) (millis / 1000);
   int minutes = seconds / 60;
   seconds     = seconds % 60;

   if (seconds < 10) {
       mTimeLabel.setText("" + minutes + ":0" + seconds);
   } else {
       mTimeLabel.setText("" + minutes + ":" + seconds);            
   }

   mHandler.postAtTime(this,
           start + (((minutes * 60) + seconds + 1) * 1000));
   }
});

thread.start();

Vous pouvez créer un thread comme cela:

 Thread thread = new Thread(new Runnable() {
                    public void run() {

                       }
                    });
                thread.start();

Aussi, vous pouvez utiliser l'Exécutable, Asyntask, Minuterie, TimerTaks et AlarmManager d'exécution des Threads.

6

Exécutable est juste une interface, qui fournit la méthode run.
Les Threads sont des implémentations et l'utilisation Praticable pour appeler la méthode run().
1

Ne devrait pas créer une nouvelle classe Runnable faire un nouveau thread?

Pas. nouveau Runnable ne crée pas de deuxième Thread.

Quel est le but de la classe Runnable ici, en plus d'être en mesure de passer à une classe Runnable à postAtTime?

Runnable est affiché à Handler. Cette tâche s'exécute dans le thread, qui est associé avec Handler.

Si Handler est associé avec le Thread de l'INTERFACE utilisateur, Runnable s'exécute dans le Thread de l'INTERFACE utilisateur.

Si Handler est associée à d'autres HandlerThreadExécutable s'exécute dans HandlerThread

Explicitement associé Gestionnaire de votre MainThread ( Thread d'INTERFACE utilisateur), écrire ci-dessous de code.
```
Handler  mHandler = new Handler(Looper.getMainLooper();
```
Si vous écrivez est comme ci-dessous, il utilise HandlerThread Looper.
```
HandlerThread handlerThread = new HandlerThread("HandlerThread");
handlerThread.start();
Handler requestHandler = new Handler(handlerThread.getLooper());
```

Meilleure et la plus simple est juste de passage d'argument et de créer d'instance et d'appel
méthode de fil

Appel thread à l'aide de créer un objet thread et envoyer un exécutable objet de classe avec le paramètre ou sans paramètre et de commencer la méthode de l'objet thread.

Dans mon état je suis de l'envoi de paramètre et je vais l'utiliser dans la méthode run.

new Thread(new FCMThreadController("2", null, "3", "1")).start();

new Thread(new FCMThreadController()).start();

public class FCMThreadController implements Runnable {
private String type;
private List<UserDeviceModel> devices;
private String message;
private String id;


    public FCMThreadController(String type, List<UserDeviceModel> devices, String message, String id) {

        this.type = type;
        this.devices = devices;
        this.message = message;
        this.id = id;
    }



    public FCMThreadController( ) {

    }

    @Override
    public void run() {
        //TODO Auto-generated method stub

    }



}

0

Un thread est quelque chose comme une des branches. Rameuse veut dire quand il y a au moins deux branches. Si les branches sont réduits, alors que le minimum reste un. C'est bien que comme les branches supprimées, mais en général, nous ne considérons pas la direction générale de l'informatique.

De même lorsqu'il existe au moins deux fils nous l'appelons programme multi-threadé. Si les filets sont réduits, le minimum reste un. Bonjour, le programme est un simple programme multi-threadé, mais il n'est pas besoin de connaître le multi-threading d'écrire ou de l'exécuter.

En d'autres termes, lorsqu'un programme n'est pas dit que d'avoir des threads, cela signifie que le programme n'est pas un programme multi-threadé, plus de plus dans le vrai sens il s'agit d'un programme multi-threadé, dans lequel VOUS POUVEZ mettre votre code comme si il est multi-thread.

Ci-dessous une inutile de code est donné, mais il suffira à faire disparaître vos quelques confusions sur Runnable. Il va print "Hello World".
```
class NamedRunnable implements Runnable {

    public void run() { //The run method prints a message to standard output.
        System.out.println("Hello World");
    }

    public static void main(String[]arg){ 
        NamedRunnable namedRunnable = new NamedRunnable( );
        namedRunnable.run();
    } 
}
```

Vous devez vous connecter pour publier un commentaire.