Ich möchte die folgende Methode nach einer bestimmten Verzögerung aufrufen können. In Ziel c gab es so etwas wie:

[self performSelector:@selector(DoSomething) withObject:nil afterDelay:5];

Gibt es ein Äquivalent dieser Methode in Android mit Java? Zum Beispiel muss ich in der Lage sein, nach 5 Sekunden eine Methode aufzurufen.

public void DoSomething()
{
     //do something here
}

Kotlin

Handler().postDelayed({
  //Do something after 100ms
}, 100)

Java

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Ich konnte keine der anderen Antworten in meinem Fall verwenden. Ich habe stattdessen den nativen Java-Timer verwendet.

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // this code will be executed after 2 seconds       
    }
}, 2000);

Hinweis: Diese Antwort wurde gegeben, als in der Frage Android nicht als Kontext angegeben wurde. Eine Antwort speziell für den Android-UI-Thread finden Sie hier.

Es sieht so aus, als ob die Mac OS-API den aktuellen Thread fortsetzen lässt und die asynchrone Ausführung der Aufgabe plant. In Java wird die entsprechende Funktion vom java.util.concurrentPaket bereitgestellt. Ich bin mir nicht sicher, welche Einschränkungen Android auferlegen könnte.

private static final ScheduledExecutorService worker = 
  Executors.newSingleThreadScheduledExecutor();

void someMethod() {
  ⋮
  Runnable task = new Runnable() {
    public void run() {
      /* Do something… */
    }
  };
  worker.schedule(task, 5, TimeUnit.SECONDS);
  ⋮
}

Für die Ausführung von etwas im UI-Thread nach 5 Sekunden:

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something here
    }
}, 5000);

Sie können Handler in UIThread verwenden:

runOnUiThread(new Runnable() {

    @Override
    public void run() {
         final Handler handler = new Handler();
         handler.postDelayed(new Runnable() {
           @Override
           public void run() {
               //add your code here
           }
         }, 1000);

    }
});

Vielen Dank für all die tollen Antworten. Ich habe eine Lösung gefunden, die meinen Anforderungen am besten entspricht.

Handler myHandler = new DoSomething();
Message m = new Message();
m.obj = c;//passing a parameter here
myHandler.sendMessageDelayed(m, 1000);

class DoSomething extends Handler {
    @Override
    public void handleMessage(Message msg) {
      MyObject o = (MyObject) msg.obj;
      //do something here
    }
}

Kotlin& JavaViele Möglichkeiten

1. Verwenden von Handler

Handler().postDelayed({
    TODO("Do something")
    }, 2000)

2. Verwenden von TimerTask

Timer().schedule(object : TimerTask() {
    override fun run() {
        TODO("Do something")
    }
}, 2000)

Oder noch kürzer

Timer().schedule(timerTask {
    TODO("Do something")
}, 2000)

Oder am kürzesten wäre

Timer().schedule(2000) {
    TODO("Do something")
}

3. Verwenden von Executors

Executors.newSingleThreadScheduledExecutor().schedule({
    TODO("Do something")
}, 2, TimeUnit.SECONDS)

In Java

1. Verwenden von Handler

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something
    }
}, 2000);

2. Verwenden von Timer

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // Do something
    }
}, 2000);

3. Verwenden von ScheduledExecutorService

private static final ScheduledExecutorService worker = Executors.newSingleThreadScheduledExecutor();

Runnable runnable = new Runnable() {
  public void run() {
      // Do something
  }
  };
worker.schedule(runnable, 2, TimeUnit.SECONDS);

Sehen Sie diese Demo:

import java.util.Timer;
import java.util.TimerTask;

class Test {
     public static void main( String [] args ) {
          int delay = 5000;// in ms 

          Timer timer = new Timer();

          timer.schedule( new TimerTask(){
             public void run() { 
                 System.out.println("Wait, what..:");
              }
           }, delay);

           System.out.println("Would it run?");
     }
}

Wenn Sie den Handler verwenden müssen, sich aber in einem anderen Thread befinden, können Sie runonuithreadden Handler im UI-Thread ausführen. Dies erspart Ihnen Ausnahmen, die beim Anruf ausgelöst werdenLooper.Prepare()

runOnUiThread(new Runnable() {
    @Override
    public void run() {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //Do something after 1 second
            }
        }, 1000);
    }
});

Sieht ziemlich chaotisch aus, aber das ist einer der Wege.

Ich bevorzuge die View.postDelayed()Methode, einfachen Code unten:

mView.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 1000 ms
    }
}, 1000);

Hier ist meine kürzeste Lösung:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something after 100ms
    }
}, 100);

final Handler handler = new Handler(); 
Timer t = new Timer(); 
t.schedule(new TimerTask() { 
    public void run() { 
        handler.post(new Runnable() { 
            public void run() { 
                //DO SOME ACTIONS HERE , THIS ACTIONS WILL WILL EXECUTE AFTER 5 SECONDS...
            }
        }); 
    } 
}, 5000); 

Wenn Sie Android Studio 3.0 und höher verwenden, können Sie Lambda-Ausdrücke verwenden. Die Methode callMyMethod()wird nach 2 Sekunden aufgerufen:

new Handler().postDelayed(() -> callMyMethod(), 2000);

Falls Sie die verzögerte Ausführung abbrechen müssen, verwenden Sie Folgendes:

Handler handler = new Handler();
handler.postDelayed(() -> callMyMethod(), 2000);

// When you need to cancel all your posted runnables just use:
handler.removeCallbacksAndMessages(null);

Ich schlage den Timer vor , mit dem Sie eine Methode planen können, die in einem bestimmten Intervall aufgerufen werden soll. Dadurch wird Ihre Benutzeroberfläche nicht blockiert und Ihre App bleibt während der Ausführung der Methode reaktionsfähig.

Die andere Option ist wait (); Methode blockiert dies den aktuellen Thread für die angegebene Zeitdauer. Dies führt dazu, dass Ihre Benutzeroberfläche nicht mehr reagiert, wenn Sie dies im UI-Thread tun.

Für eine Verzögerung bei der einfachen Zeilenbehandlung können Sie wie folgt vorgehen:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do someting
    }
}, 3000);

ich hoffe das hilft

Sie können dies für die einfachste Lösung verwenden:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Write your code here
    }
}, 5000); //Timer is in ms here.

Andernfalls kann unten eine andere saubere nützliche Lösung sein:

new Handler().postDelayed(() -> 
{/*Do something here*/}, 
5000); //time in ms

Sie können es viel sauberer machen, indem Sie die neu eingeführten Lambda-Ausdrücke verwenden:

new Handler().postDelayed(() -> {/*your code here*/}, time);

Es gibt also ein paar Dinge zu beachten, da es so viele Möglichkeiten gibt, diese Katze zu häuten. Obwohl alle Antworten bereits ausgewählt und ausgewählt wurden. Ich denke, es ist wichtig, dass dies mit den richtigen Codierungsrichtlinien überprüft wird, um zu vermeiden, dass jemand in die falsche Richtung geht, nur weil "die Mehrheit die einfache Antwort ausgewählt hat".

Lassen Sie uns zunächst die einfache Antwort "Post Delayed" diskutieren, bei der es sich insgesamt um die vom Gewinner ausgewählte Antwort in diesem Thread handelt.

Ein paar Dinge zu beachten. Nach der Nachverzögerung können Speicherlecks, tote Objekte, verschwundene Lebenszyklen und mehr auftreten. Daher ist es auch wichtig, richtig damit umzugehen. Sie können dies auf verschiedene Arten tun.

Für die moderne Entwicklung werde ich in KOTLIN liefern

Hier ist ein einfaches Beispiel für die Verwendung des UI-Threads bei einem Rückruf und die Bestätigung, dass Ihre Aktivität noch aktiv ist, wenn Sie Ihren Rückruf ausführen.

  Handler(Looper.getMainLooper()).postDelayed({
            if(activity != null && activity?.isFinishing == false){
                txtNewInfo.visibility = View.GONE
            }
        }, NEW_INFO_SHOW_TIMEOUT_MS)

Dies ist jedoch immer noch nicht perfekt, da es keinen Grund gibt, Ihren Rückruf zu tätigen, wenn die Aktivität abgebrochen wurde. Ein besserer Weg wäre es, einen Verweis darauf zu behalten und die Rückrufe wie diesen zu entfernen.

    private fun showFacebookStylePlus1NewsFeedOnPushReceived(){
        A35Log.v(TAG, "showFacebookStylePlus1NewsFeedOnPushReceived")
        if(activity != null && activity?.isFinishing == false){
            txtNewInfo.visibility = View.VISIBLE
            mHandler.postDelayed({
                if(activity != null && activity?.isFinishing == false){
                    txtNewInfo.visibility = View.GONE
                }
            }, NEW_INFO_SHOW_TIMEOUT_MS)
        }
    }

und natürlich die Bereinigung in der onPause durchführen, damit der Rückruf nicht getroffen wird.

    override fun onPause() {
        super.onPause()
        mHandler.removeCallbacks(null)
    }

Nachdem wir das Offensichtliche besprochen haben, sprechen wir über eine sauberere Option mit modernen Coroutinen und Kotlin :). Wenn Sie diese noch nicht verwenden, verpassen Sie sie wirklich.

   fun doActionAfterDelay() 
        launch(UI) {
            delay(MS_TO_DELAY)           
            actionToTake()
        }
    }

oder wenn Sie mit dieser Methode immer einen UI-Start durchführen möchten, können Sie einfach Folgendes tun:

  fun doActionAfterDelay() = launch(UI){ 
      delay(MS_TO_DELAY)           
      actionToTake()
  }

Natürlich müssen Sie genau wie beim PostDelayed sicherstellen, dass Sie mit dem Abbrechen umgehen, damit Sie entweder die Aktivitätsprüfungen nach dem Verspätungsaufruf durchführen oder sie in der onPause wie auf der anderen Route abbrechen können.

var mDelayedJob: Job? = null
fun doActionAfterDelay() 
   mDelayedJob = launch(UI) {
            try {
               delay(MS_TO_DELAY)           
               actionToTake()
            }catch(ex: JobCancellationException){
                showFancyToast("Delayed Job canceled", true, FancyToast.ERROR, "Delayed Job canceled: ${ex.message}")
            }
        }
   }
}

// Bereinigung behandeln

override fun onPause() {
   super.onPause()
   if(mDelayedJob != null && mDelayedJob!!.isActive) {
      A35Log.v(mClassTag, "canceling delayed job")
      mDelayedJob?.cancel() //this should throw CancelationException in coroutine, you can catch and handle appropriately
   }
}

Wenn Sie den Start (UI) in die Methodensignatur einfügen, kann der Job in der aufrufenden Codezeile zugewiesen werden.

Die Moral der Geschichte ist es also, mit Ihren verspäteten Aktionen sicher zu sein, sicherzustellen, dass Sie Ihre Rückrufe entfernen oder Ihre Jobs stornieren, und natürlich zu bestätigen, dass Sie den richtigen Lebenszyklus haben, um Elemente Ihres verspäteten Rückrufs vollständig zu berühren. Die Coroutinen bieten auch stornierbare Aktionen an.

Es ist auch erwähnenswert, dass Sie normalerweise die verschiedenen Ausnahmen behandeln sollten, die mit Coroutinen einhergehen können. Zum Beispiel eine Stornierung, eine Ausnahme, eine Zeitüberschreitung, was auch immer Sie verwenden möchten. Hier ist ein fortgeschritteneres Beispiel, wenn Sie sich entscheiden, Coroutinen wirklich zu verwenden.

   mLoadJob = launch(UI){
            try {
                //Applies timeout
                withTimeout(4000) {
                    //Moves to background thread
                    withContext(DefaultDispatcher) {
                        mDeviceModelList.addArrayList(SSDBHelper.getAllDevices())
                    }
                }

                //Continues after async with context above
                showFancyToast("Loading complete", true, FancyToast.SUCCESS)
            }catch(ex: JobCancellationException){
                showFancyToast("Save canceled", true, FancyToast.ERROR, "Save canceled: ${ex.message}")
            }catch (ex: TimeoutCancellationException) {
                showFancyToast("Timed out saving, please try again or press back", true, FancyToast.ERROR, "Timed out saving to database: ${ex.message}")
            }catch(ex: Exception){
                showFancyToast("Error saving to database, please try again or press back", true, FancyToast.ERROR, "Error saving to database: ${ex.message}")
            }
        }

Ich habe eine einfachere Methode erstellt, um dies aufzurufen.

public static void CallWithDelay(long miliseconds, final Activity activity, final String methodName)
    {
        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                try {
                    Method method =  activity.getClass().getMethod(methodName);
                    method.invoke(activity);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }, miliseconds);
    }

Um es zu benutzen, rufen Sie einfach an: .CallWithDelay(5000, this, "DoSomething");

Unten funktioniert man, wenn man bekommt,

java.lang.RuntimeException: Handler in Thread, der nicht Looper.prepare () aufgerufen hat, kann nicht erstellt werden

final Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Mit Kotlin können wir Folgendes erreichen

Handler().postDelayed({
    // do something after 1000ms 
}, 1000)

Es ist sehr einfach mit dem CountDownTimer. Weitere Informationen finden Sie unter https://developer.android.com/reference/android/os/CountDownTimer.html

import android.os.CountDownTimer;

// calls onTick every second, finishes after 3 seconds
new CountDownTimer(3000, 1000) { 

   public void onTick(long millisUntilFinished) {
      Log.d("log", millisUntilFinished / 1000);
   }

   public void onFinish() {
      // called after count down is finished
   } 
}.start();

Wenn Sie RxAndroid verwenden, wird die Behandlung von Threads und Fehlern viel einfacher. Der folgende Code wird nach einer Verzögerung ausgeführt

   Observable.timer(delay, TimeUnit.SECONDS)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(aLong -> {
           // Execute code here
        }, Throwable::printStackTrace);

Jeder scheint zu vergessen, den Handler zu bereinigen, bevor er eine neue ausführbare Datei oder Nachricht darauf veröffentlicht. Andernfalls könnten sie sich möglicherweise ansammeln und schlechtes Verhalten verursachen.

handler.removeMessages(int what);
// Remove any pending posts of messages with code 'what' that are in the message queue.

handler.removeCallbacks(Runnable r)
// Remove any pending posts of Runnable r that are in the message queue.

Hier ist ein weiterer kniffliger Weg: Es wird keine Ausnahme ausgelöst, wenn die ausführbaren Elemente der Benutzeroberfläche geändert werden.

public class SimpleDelayAnimation extends Animation implements Animation.AnimationListener {

    Runnable callBack;

    public SimpleDelayAnimation(Runnable runnable, int delayTimeMilli) {
        setDuration(delayTimeMilli);
        callBack = runnable;
        setAnimationListener(this);
    }

    @Override
    public void onAnimationStart(Animation animation) {

    }

    @Override
    public void onAnimationEnd(Animation animation) {
        callBack.run();
    }

    @Override
    public void onAnimationRepeat(Animation animation) {

    }
}

Sie können die Animation folgendermaßen aufrufen:

view.startAnimation(new SimpleDelayAnimation(delayRunnable, 500));

Die Animation kann an jede Ansicht angehängt werden.

Hier ist die Antwort in Kotlin, ihr faulen, faulen Leute:

Handler().postDelayed({
//doSomethingHere()
}, 1000)

Ich mag Dinge sauberer: Hier ist meine Implementierung, Inline-Code, der in Ihrer Methode verwendet werden kann

new Handler().postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Eine geeignete Lösung für Android:

private static long SLEEP_TIME = 2 // for 2 second
.
.
MyLauncher launcher = new MyLauncher();
            launcher.start();
.
.
private class MyLauncher extends Thread {
        @Override
        /**
         * Sleep for 2 seconds as you can also change SLEEP_TIME 2 to any. 
         */
        public void run() {
            try {
                // Sleeping
                Thread.sleep(SLEEP_TIME * 1000);
            } catch (Exception e) {
                Log.e(TAG, e.getMessage());
            }
            //do something you want to do
           //And your code will be executed after 2 second
        }
    }

Ähnliche Lösung, aber viel sauberer zu verwenden

Schreiben Sie diese Funktion außerhalb der Klasse

fun delay(duration: Long, `do`: () -> Unit) {

    Handler().postDelayed(`do`, duration)

}

Verwendungszweck:

delay(5000) {
    //Do your work here
}

In Android können wir unten Kotlin-Code schreiben, um die Ausführung einer Funktion zu verzögern

class MainActivity : AppCompatActivity() {

private lateinit var handler: Handler

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    handler= Handler()
    handler.postDelayed({
        doSomething()
    },2000)
}

private fun doSomething() {
    Toast.makeText(this,"Hi! I am Toast Message",Toast.LENGTH_SHORT).show()
}
}