Je veux pouvoir appeler la méthode suivante après un délai spécifié. Dans l'objectif c, il y avait quelque chose comme:

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

Existe-t-il un équivalent de cette méthode dans Android avec Java? Par exemple, je dois pouvoir appeler une méthode après 5 secondes.

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

Je n'ai pu utiliser aucune des autres réponses dans mon cas. J'ai plutôt utilisé le minuteur Java natif.

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

Remarque: Cette réponse a été donnée lorsque la question ne spécifiait pas Android comme contexte. Pour une réponse spécifique au fil d'AU Android, regardez ici.

Il semble que l'API Mac OS laisse le thread actuel continuer et planifie l'exécution de la tâche de manière asynchrone. En Java, la fonction équivalente est fournie par le java.util.concurrentpackage. Je ne sais pas quelles limitations Android pourrait imposer.

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

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

Pour exécuter quelque chose dans le thread d'interface utilisateur après 5 secondes:

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

vous pouvez utiliser Handler dans UIThread:

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

    }
});

Merci pour toutes les bonnes réponses, j'ai trouvé une solution qui correspond le mieux à mes besoins.

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
    }
}

KotlinEt de Javanombreuses façons

1. Utilisation Handler

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

2. Utilisation de TimerTask

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

Ou encore plus court

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

Ou le plus court serait

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

3. Utilisation Executors

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

En Java

1. Utilisation Handler

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

2. Utilisation Timer

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

3. Utilisation ScheduledExecutorService

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

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

Voir cette démo:

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?");
     }
}

Si vous devez utiliser le gestionnaire, mais que vous êtes dans un autre thread, vous pouvez utiliser runonuithreadpour exécuter le gestionnaire dans le thread d'interface utilisateur. Cela vous évitera des exceptions levées demandant d'appelerLooper.Prepare()

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

Semble assez désordonné, mais c'est l'un des moyens.

Je préfère utiliser la View.postDelayed()méthode, le code simple ci-dessous:

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

Voici ma solution la plus courte:

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

Si vous utilisez Android Studio 3.0 et supérieur, vous pouvez utiliser des expressions lambda. La méthode callMyMethod()est appelée après 2 secondes:

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

Au cas où vous auriez besoin d'annuler le runnable retardé, utilisez ceci:

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

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

Je suggère la minuterie , il vous permet de programmer une méthode à appeler sur un intervalle très précis. Cela ne bloquera pas votre interface utilisateur et gardera votre application sensible pendant l'exécution de la méthode.

L'autre option est l' attente (); , cela bloquera le thread en cours pendant la durée spécifiée. Cela entraînera votre interface utilisateur cesser de répondre si vous le faites sur le thread d'interface utilisateur.

Pour un délai de traitement de ligne simple, vous pouvez procéder comme suit:

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

J'espère que ça aide

Vous pouvez l'utiliser pour la solution la plus simple:

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

Sinon, ci-dessous peut être une autre solution utile propre:

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

Vous pouvez le rendre beaucoup plus propre en utilisant les expressions lambda nouvellement introduites:

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

Il y a donc quelques éléments à considérer ici car il y a tellement de façons de dépouiller ce chat. Bien que toutes les réponses aient déjà été données sélectionnées et choisies. Je pense qu'il est important que cela soit revisité avec des directives de codage appropriées pour éviter que quiconque aille dans la mauvaise direction simplement à cause de la "réponse simple choisie par la majorité".

Alors d'abord, discutons de la réponse simple Post Delayed qui est la réponse sélectionnée par le gagnant dans l'ensemble de ce fil.

Quelques points à considérer. Après le délai de post-traitement, vous pouvez rencontrer des fuites de mémoire, des objets morts, des cycles de vie qui ont disparu, etc. Il est donc également important de le manipuler correctement. Vous pouvez le faire de deux manières.

Par souci de développement moderne, je fournirai en KOTLIN

Voici un exemple simple d'utilisation du thread d'interface utilisateur sur un rappel et de confirmation que votre activité est toujours bien vivante lorsque vous appuyez sur votre rappel.

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

Cependant, ce n'est toujours pas parfait car il n'y a aucune raison de frapper votre rappel si l'activité a disparu. donc une meilleure façon serait de garder une référence et de supprimer ses rappels comme celui-ci.

    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)
        }
    }

et bien sûr gérer le nettoyage sur le onPause afin qu'il ne frappe pas le rappel.

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

Maintenant que nous avons parlé de l'évidence, parlons d'une option plus propre avec les coroutines modernes et la kotlin :). Si vous ne les utilisez pas encore, vous en manquez vraiment.

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

ou si vous voulez toujours faire un lancement d'interface utilisateur sur cette méthode, vous pouvez simplement faire:

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

Bien sûr, tout comme le PostDelayed, vous devez vous assurer de gérer l'annulation afin de pouvoir effectuer les vérifications d'activité après l'appel différé ou vous pouvez l'annuler dans la onPause, tout comme l'autre itinéraire.

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}")
            }
        }
   }
}

// gérer le nettoyage

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
   }
}

Si vous placez le lancement (UI) dans la signature de méthode, le travail peut être attribué dans la ligne de code appelante.

La morale de l'histoire est donc d'être en sécurité avec vos actions retardées, assurez-vous de supprimer vos rappels ou d'annuler vos travaux et bien sûr de confirmer que vous avez le bon cycle de vie pour toucher les éléments de votre rappel différé. Les Coroutines proposent également des actions annulables.

Il convient également de noter que vous devez généralement gérer les diverses exceptions qui peuvent accompagner les coroutines. Par exemple, une annulation, une exception, un délai d'expiration, tout ce que vous décidez d'utiliser. Voici un exemple plus avancé si vous décidez de vraiment commencer à utiliser des coroutines.

   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}")
            }
        }

J'ai créé une méthode plus simple pour appeler cela.

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

Pour l'utiliser, il suffit d'appeler: .CallWithDelay(5000, this, "DoSomething");

Ci-dessous on travaille quand vous obtenez,

java.lang.RuntimeException: impossible de créer un gestionnaire dans le thread qui n'a pas appelé Looper.prepare ()

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

En utilisant Kotlin, nous pouvons y parvenir en procédant comme suit

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

C'est très simple d'utiliser le CountDownTimer. Pour plus de détails 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();

Si vous utilisez RxAndroid, la gestion des threads et des erreurs devient beaucoup plus facile. Le code suivant s'exécute après un délai

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

tout le monde semble oublier de nettoyer le gestionnaire avant de poster un nouveau runnable ou un message dessus. Sinon, ils pourraient potentiellement s'accumuler et provoquer un mauvais comportement.

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.

Voici un autre moyen délicat: il ne lèvera pas d'exception lorsque le runnable change les éléments de l'interface utilisateur.

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) {

    }
}

Vous pouvez appeler l'animation comme ceci:

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

L'animation peut être attachée à n'importe quelle vue.

Voici la réponse dans Kotlin vous les gens paresseux, paresseux:

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

J'aime les choses plus propres: voici mon implémentation, du code en ligne à utiliser dans votre méthode

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

Une solution adaptée dans 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
        }
    }

Solution similaire mais beaucoup plus propre à utiliser

Écrivez cette fonction en dehors de la classe

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

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

}

Usage:

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

Sous Android, nous pouvons écrire ci-dessous du code kotlin pour retarder l'exécution de n'importe quelle fonction

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