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

  • Errore (-19,0) Mediaplayer
  • Imansible submit MMS utilizzando SmsManager
  • SYSTEM_ALERT_WINDOW - Come get questa authorization automaticamente su Android 6.0 e targetSdkVersion 23
  • Come eseguire il command terminal nell'applicazione Android?
  • Retrofit: previsto BEGIN_OBJECT ma era BEGIN_ARRAY
  • Utilizzo del recyclerview con un database
  • 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

  • L'allarme non sveglia il mio servizio
  • Chiarire le connessioni Firebase
  • non è ansible combinare titoli personalizzati con altre funzioni del titolo
  • Android: sta utilizzando setContentView più volte cattivo mentre cambia layout?
  • Errore durante la creazione di MediaPlayer con Uri o file nell'attivo
  • Ottenere il tag NFC con l'applicazione di logging Android Application (AAR) di NDEF
  • 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.