nuovo Runnable () ma nessun nuovo thread?

Sto cercando di capire il codice qui , in particolare la class anonima

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'articolo dice

  • Forma personalizzata della barra di avanzamento
  • Come rifiutare una chiamata in modo programmato in android
  • project.properties nel progetto android
  • Come get il path di storage di sdcard (secondario) in android?
  • Come aprire un'attività nuova facendo clic su un elemento in listview?
  • JSON su Android - serializzazione
  • Il gestore esegue il codice di aggiornamento come parte del thread principale, evitando il sovraccarico di un secondo thread.

    Non dovrebbe creare una nuova class Runnable fare un nuovo secondo thread? Qual è lo scopo della class Runnable qui oltre ad essere in grado di passare una class Runnable a PostAtTime?

    Grazie

  • il Gestore allarmi persiste anche dopo il riavvio?
  • Come determinare se un servizio Android è in esecuzione in primo piano?
  • AsyncTask non sta cancellando l'operazione a lungo in android
  • L'ID della logging GCM è cambiata
  • Uscire da app quando clicca il button in phonegap android?
  • Integra l'authorization del firebase con gli endpoint dei cloud di motori di Google
  • 7 Solutions collect form web for “nuovo Runnable () ma nessun nuovo thread?”

    Runnable è spesso usato per fornire il codice che un thread deve eseguire, ma il Runnable stesso non ha nulla a che fare con i thread. È solo un object con un metodo run() .

    In Android, la class Handler può essere utilizzata per chiedere al framework di eseguire un codice più tardi sullo stesso thread, piuttosto che su quello diverso. Runnable viene utilizzato per fornire il codice che dovrebbe essere eseguito in seguito.

    Se vuoi creare una nuova Thread … puoi fare qualcosa di simile …

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

    L'interface Runnable è un altro modo in cui è ansible implementare multi-threading oltre ad estendere la class Thread perché il Java consente di estendere una sola class.

    È tuttavia ansible utilizzare il nuovo thread (Runnable runnable) constructor, qualcosa di simile:

     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(); 

    Puoi creare un thread come questo:

      Thread thread = new Thread(new Runnable() { public void run() { } }); thread.start(); 

    Inoltre, è ansible utilizzare Runnable, Asyntask, Timer, TimerTaks e AlarmManager per estrarre Threads.

    Runnable è solo un'interface, che consente di eseguire il metodo. Le discussioni sono implementazioni e utilizzano Runnable per call il metodo run ().

    Il modo migliore e semplice è solo l'argomento pass e creare il metodo di istanza e di chiamata

    Chiamare il thread usando creare un object thread e submit un object di class runnable con parametro o senza parametro e metodo di avvio di object thread.

    Nella mia condizione invio un parametro e userò in modalità di esecuzione.

    nuova discussione (nuovo FCMThreadController ("2", null, "3", "1")) start ();

    O

    nuova discussione (nuovo 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 filo è qualcosa di simile a un branch. Meccanismi multi-ramificati quando ci sono alless due rami. Se i rami sono ridotti, il minimo rimane uno. Questo è anche come i rami rimossi, ma in generale non lo consideriamo branch.

    Allo stesso modo, quando ci sono alless due thread, lo chiamiamo programma multi-filettato. Se i thread sono ridotti, il minimo rimane uno. Il programma Hello è un programma filettato singolo, ma nessuno deve conoscere il multi-threading per scrivere o eseguirlo.

    In parole semplici quando non si dice che un programma abbia fili, significa che il programma non è un programma multifilo, più in senso vero è un singolo programma filettato in cui puoi mettere il codice come se fosse multi -threaded.

    Sotto un codice inutile è dato, ma sarà sufficiente eliminare le tue confusioni su Runnable. Stamperà "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(); } 

    }

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.