new Runnable () mais pas de nouveau thread?
J'essaie de comprendre le code ici , en particulier 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));
}
};
L'article dit
Le gestionnaire exécute le code de mise à jour en tant que partie de votre thread principal, évitant ainsi le temps système d'un second thread.
La création d'une nouvelle classe Runnable ne devrait-elle pas créer un nouveau second thread? Quel est le but de la classe Runnable ici à part de pouvoir passer une classe Runnable à postAtTime?
Merci
Runnable est souvent utilisé pour fournir le code qu'un thread devrait exécuter, mais Runnable n'a rien à voir avec les threads. C'est juste un objet avec une méthode run().
Sous Android, la classe Handler peut être utilisée pour demander au framework d’exécuter du code ultérieurement sur le même thread, plutôt que sur un autre. Runnable est utilisé pour fournir le code qui devrait être exécuté plus tard.
Si vous voulez créer une nouvelle Thread... vous pouvez faire quelque chose comme ça ...
Thread t = new Thread(new Runnable() { public void run() {
// your code goes here...
}});
L'interface Runnable est un autre moyen d'implémenter le multi-threading en plus d'étendre la classe Thread en raison du fait que Java vous permet d'étendre une seule classe.
Vous pouvez cependant utiliser le nouveau Thread (constructeur runnable) 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 fil juste comme ceci:
Thread thread = new Thread(new Runnable() {
public void run() {
}
});
thread.start();
En outre, vous pouvez utiliser Runnable, Asynctask, Timer, TimerTask et AlarmManager pour exécuter des threads.
Runnable est simplement une interface fournissant la méthode run . Les threads sont des implémentations et utilisent Runnable pour appeler la méthode run ().
La création d'une nouvelle classe Runnable ne devrait-elle pas créer un nouveau second thread?
New new Runnable ne crée pas la deuxième Thread.
Quel est le but de la classe Runnable ici à part de pouvoir passer une classe Runnable à postAtTime?
Runnable est posté sur Handler. Cette tâche est exécutée dans le thread associé à Handler.
Si Handler est associé à un thread d'interface utilisateur, Runnable s'exécute dans un thread d'interface utilisateur.
Si Handler est associé à une autre HandlerThread, Runnable s'exécute dans HandlerThread
Pour associer explicitement Handler à votre MainThread (thread d'interface utilisateur), écrivez ci-dessous le code.
Handler mHandler = new Handler(Looper.getMainLooper();
Si vous écrivez comme ci-dessous, il utilise HandlerThread Looper.
HandlerThread handlerThread = new HandlerThread("HandlerThread");
handlerThread.start();
Handler requestHandler = new Handler(handlerThread.getLooper());
Le meilleur et le plus simple consiste à passer un argument, à créer une instance et à appeler méthode du fil
Appelez thread en utilisant créer un objet thread et envoyez un objet de classe exécutable avec paramètre ou sans paramètre et méthode de démarrage de l'objet thread.
Dans ma condition, j'envoie un paramètre et je vais l'utiliser dans la méthode d'exécution.
new Thread (nouveau FCMThreadController ("2", null, "3", "1")). start ();
OR
new Thread (nouveau 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
}
}
Un fil est quelque chose comme une branche. Multi-ramifié signifie quand il y a au moins deux branches. Si les branches sont réduites, le minimum reste égal à un. Celui-ci ressemble aux branches supprimées, mais en général, nous ne le considérons pas comme une branche.
De même, quand il y a au moins deux threads, nous l'appelons programme multi-threadé. Si les threads sont réduits, le minimum reste un. Hello programme est un programme à un seul thread, mais personne n'a besoin de connaître le multi-threading pour l'écrire ou l'exécuter.
En termes simples, quand un programme n’est pas dit avoir des threads, cela signifie que le programme n’est pas un programme multi-threadé, mais plutôt un programme à un seul thread, dans lequel VOUS POUVEZ mettre votre code multi-threaded.
Ci-dessous, un code inutile est donné, mais il suffira d’éliminer vos confusions sur Runnable. Il va imprimer "Bonjour le monde".
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();
}
}