java: belirli bir saniye sonra bir işlevi çalıştırır

5 saniye sonra yürütülmesini istediğim belirli bir işlevim var. Java ile nasıl yapabilirim?

Javax.swing.timer buldum, ancak nasıl kullanılacağını gerçekten anlayamıyorum. Görünüşe göre bu sınıfın sağladığı daha basit bir şey arıyorum.

Lütfen basit bir kullanım örneği ekleyin.

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

DÜZENLE:

javadoc diyor ki:

Bir Timer nesnesine son canlı başvuru ortadan kalktıktan ve tüm bekleyen görevler yürütmeyi tamamladıktan sonra, zamanlayıcının görev yürütme iş parçacığı zarif bir şekilde sonlanır (ve çöp toplama işlemine tabi tutulur). Ancak, bu işlemin gelişmesi uzun sürebilir.

Bunun gibi bir şey:

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

ExecutorHavuzda daha fazla iş parçacığı istiyorsanız, bunun yerine kullanabileceğiniz çeşitli diğer fabrika yöntemleri vardır .

Ve unutmayın, işiniz bittiğinde yürütücüyü kapatmanız önemlidir. shutdown()Yöntem son görev tamamlandığında temiz bir şekilde iş parçacığı havuzu kapanacak ve bu gerçekleşene kadar engeller. shutdownNow()iş parçacığı havuzunu derhal sonlandıracaktır.

Kullanım örneği 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!

Bu kod yalnızca bir kez yürütülür ve yürütme 3000 ms'de (3 saniye) gerçekleşir.

Camickr'den bahsedildiği gibi, kısa bir giriş için " Swing Zamanlayıcıları Nasıl Kullanılır " araması yapmalısınız .

Kodum aşağıdaki gibidir:

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

@Tangens cevabının bir çeşidi olarak: çöp toplayıcının iş parçacığını temizlemesini bekleyemiyorsanız, çalıştırma yönteminizin sonunda zamanlayıcıyı iptal edin.

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

Asıl sorunuz "Salınım Zamanlayıcısı" ndan bahsediyor. Aslında sorunuz SWing ile ilgili ise, util.Timer DEĞİL Swing Zamanlayıcı kullanmanız gerekir.

Daha fazla bilgi için " Zamanlayıcıların Kullanımı " konulu Swing eğitimindeki bölümü okuyun .

Thread.Sleep () işlevini kullanabilirsiniz

Thread.sleep(4000);
myfunction();

İşleviniz 4 saniye sonra yürütülecektir. Ancak bu tüm programı duraklatabilir ...

ScheduledThreadPoolExecutor bu yeteneğe sahip, ancak oldukça ağır.

Timer aynı zamanda bu yeteneğe sahiptir ancak sadece bir kez kullanılsa bile birkaç iş parçacığı açar.

İşte bir test ile basit bir uygulama (Android Handler.postDelayed () yakın imzası ):

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

Ölçek:

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

Diğer tüm isteksizlerin kodunuzu yeni bir iş parçacığında çalıştırması gerekir. Bazı basit kullanım durumlarında, biraz beklemek ve aynı iş parçacığı / akışı içinde yürütmeye devam etmek isteyebilirsiniz.

Aşağıdaki kod bu tekniği göstermektedir. Unutmayın bu java.util.Timer kaputun altında ne yapar, ancak daha hafif.

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

Uygulamaya Kadar Gecikme

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