java: exécuter une fonction après un certain nombre de secondes

J'ai une fonction spécifique que je souhaite exécuter après 5 secondes. Comment puis-je faire cela en Java?

J'ai trouvé javax.swing.timer, mais je ne comprends pas vraiment comment l'utiliser. Il semble que je cherche quelque chose de plus simple que ce que cette classe fournit.

Veuillez ajouter un exemple d'utilisation simple.

new java.util.Timer().schedule( 
        new java.util.TimerTask() {
            @Override
            public void run() {
                // your code here
            }
        }, 
        5000 
);

ÉDITER:

javadoc dit:

Une fois que la dernière référence en direct à un objet Timer a disparu et que toutes les tâches en attente ont été exécutées, le thread d'exécution de la tâche du minuteur se termine correctement (et devient soumis au garbage collection). Cependant, cela peut prendre un temps arbitraire à se produire.

Quelque chose comme ça:

// When your program starts up
ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();

// then, when you want to schedule a task
Runnable task = ....    
executor.schedule(task, 5, TimeUnit.SECONDS);

// and finally, when your program wants to exit
executor.shutdown();

Il existe diverses autres méthodes d'usine sur Executorlesquelles vous pouvez utiliser à la place, si vous voulez plus de threads dans le pool.

Et rappelez-vous, il est important d'arrêter l'exécuteur testamentaire lorsque vous avez terminé. La shutdown()méthode arrête proprement le pool de threads lorsque la dernière tâche est terminée et se bloque jusqu'à ce que cela se produise. shutdownNow()mettra fin au pool de threads immédiatement.

Exemple d'utilisation javax.swing.Timer

Timer timer = new Timer(3000, new ActionListener() {
  @Override
  public void actionPerformed(ActionEvent arg0) {
    // Code to be executed
  }
});
timer.setRepeats(false); // Only execute once
timer.start(); // Go go go!

Ce code ne sera exécuté qu'une seule fois, et l'exécution se produira dans 3000 ms (3 secondes).

Comme le mentionne camickr, vous devriez chercher " Comment utiliser les minuteries de swing " pour une brève introduction.

Mon code est le suivant:

new java.util.Timer().schedule(

    new java.util.TimerTask() {
        @Override
        public void run() {
            // your code here, and if you have to refresh UI put this code: 
           runOnUiThread(new   Runnable() {
                  public void run() {
                            //your code

                        }
                   });
        }
    }, 
    5000 
);

Comme variante de la réponse @tangens: si vous ne pouvez pas attendre que le garbage collector nettoie votre thread, annulez le minuteur à la fin de votre méthode d'exécution.

Timer t = new java.util.Timer();
t.schedule( 
        new java.util.TimerTask() {
            @Override
            public void run() {
                // your code here
                // close the thread
                t.cancel();
            }
        }, 
        5000 
);

Votre question initiale mentionne le "Swing Timer". Si en fait votre question est liée à SWing, alors vous devriez utiliser le Swing Timer et PAS l'util.Timer.

Lisez la section du didacticiel Swing sur « Comment utiliser les minuteries » pour plus d'informations.

vous pouvez utiliser la fonction Thread.Sleep ()

Thread.sleep(4000);
myfunction();

Votre fonction s'exécutera après 4 secondes. Cependant, cela pourrait mettre en pause tout le programme ...

ScheduledThreadPoolExecutor a cette capacité, mais c'est assez lourd.

Timer a également cette capacité mais ouvre plusieurs threads même s'il n'est utilisé qu'une seule fois.

Voici une implémentation simple avec un test (signature proche de Handler.postDelayed () ) d'Android :

public class JavaUtil {
    public static void postDelayed(final Runnable runnable, final long delayMillis) {
        final long requested = System.currentTimeMillis();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // The while is just to ignore interruption.
                while (true) {
                    try {
                        long leftToSleep = requested + delayMillis - System.currentTimeMillis();
                        if (leftToSleep > 0) {
                            Thread.sleep(leftToSleep);
                        }
                        break;
                    } catch (InterruptedException ignored) {
                    }
                }
                runnable.run();
            }
        }).start();
    }
}

Tester:

@Test
public void testRunsOnlyOnce() throws InterruptedException {
    long delay = 100;
    int num = 0;
    final AtomicInteger numAtomic = new AtomicInteger(num);
    JavaUtil.postDelayed(new Runnable() {
        @Override
        public void run() {
            numAtomic.incrementAndGet();
        }
    }, delay);
    Assert.assertEquals(num, numAtomic.get());
    Thread.sleep(delay + 10);
    Assert.assertEquals(num + 1, numAtomic.get());
    Thread.sleep(delay * 2);
    Assert.assertEquals(num + 1, numAtomic.get());
}

Tous les autres unswers nécessitent d'exécuter votre code dans un nouveau thread. Dans certains cas d'utilisation simples, vous pouvez simplement attendre un peu et continuer l'exécution dans le même thread / flux.

Le code ci-dessous illustre cette technique. Gardez à l'esprit que cela est similaire à ce que java.util.Timer fait sous le capot mais plus léger.

import java.util.concurrent.TimeUnit;
public class DelaySample {
    public static void main(String[] args) {
       DelayUtil d = new DelayUtil();
       System.out.println("started:"+ new Date());
       d.delay(500);
       System.out.println("half second after:"+ new Date());
       d.delay(1, TimeUnit.MINUTES); 
       System.out.println("1 minute after:"+ new Date());
    }
}

Implémentation DelayUtil

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class DelayUtil {
    /** 
    *  Delays the current thread execution. 
    *  The thread loses ownership of any monitors. 
    *  Quits immediately if the thread is interrupted
    *  
    * @param duration the time duration in milliseconds
    */
   public void delay(final long durationInMillis) {
      delay(durationInMillis, TimeUnit.MILLISECONDS);
   }

   /** 
    * @param duration the time duration in the given {@code sourceUnit}
    * @param unit
    */
    public void delay(final long duration, final TimeUnit unit) {
        long currentTime = System.currentTimeMillis();
        long deadline = currentTime+unit.toMillis(duration);
        ReentrantLock lock = new ReentrantLock();
        Condition waitCondition = lock.newCondition();

        while ((deadline-currentTime)>0) {
            try {
                lock.lockInterruptibly();    
                waitCondition.await(deadline-currentTime, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            } finally {
                lock.unlock();
            }
            currentTime = System.currentTimeMillis();
        }
    }
}

public static Timer t;

public synchronized void startPollingTimer() {
        if (t == null) {
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                   //Do your work
                }
            };

            t = new Timer();
            t.scheduleAtFixedRate(task, 0, 1000);
        }
    }