Question

我有一个程序，可以在其中插入文件路径及其对应的表参数。

在那之后，我有另一个名为do_Scan()的函数扫描表并对其进行一些处理和索引。

但是，我希望此函数do_Scan()以一定的间隔运行，例如每N分钟运行一次，它将调用此函数。 N绝对是可配置的。

我当时在考虑使用计时器类，但不确定如何实现配置。我的想法是创建一个Timer函数，该函数将调用do_Scan方法。

该类应该是这样的：

  public void schedule(TimerTask task,long delay,long period){



    }

我的主要方法：

public static void main(String[] args) throws Exception {




Indexing test= new Indexing();
        java.sql.Timestamp date = new java.sql.Timestamp(new java.util.Date().getTime());
       // Exception e=e.printStackTrace();
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a file path: ");
        System.out.flush();
        String filename = scanner.nextLine();
        File file = new File(filename);
        if(file.exists() && !file.isDirectory()) {
            test.index_request(filename,"Active",date,date,"");
        }else{

            test.index_request(filename,"Error",date,date,"Some errorCode");

        }

 // Call schedule() function 



    }}

如何设置Timer类，使其在特定间隔内无限期运行？

Answer 1

最简单的方法是使用作为标准库一部分的类。

java.util.Timer

以下是使用它的简单示例：

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

class MyTask extends TimerTask 
{ 
   public static int i = 0; 
   public void run() 
   { 
      System.out.println("Hello, I'm timer, running iteration: " + ++i); 
   } 
} 

public class Test 
{ 
   public static void main(String[] args) 
   { 

      Timer timer = new Timer(); 
      TimerTask task = new MyTask(); 

      timer.schedule(task, 2000, 5000);  // 2000 - delay (can set to 0 for immediate execution), 5000 is a frequency.

   } 
}

Answer 2

为此，我建议您使用Java的ScheduledExecutorService，该Java为您提供了一个API以固定速率调度任务（以及其他API）。

您有2种选择可以做到这一点：

在任务中实现Runnable或Callable（或类似内容）并调用schedule()方法：

public class IndexingTask implements Runnable {

    @Override
    public void run() {
        schedule();
    }

    private void schedule() {
        //do something
    }
}



public static void main(String[] args) {
    //do some stuff
    long delay = getDelay();
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
    scheduledThreadPool.scheduleAtFixedRate(new IndexingTask(), 0, delay, TimeUnit.SECONDS);
}

使用Lambda表达式内联：

public static void main（String [] args）{ //做点事长延时= getDelay（）; ScheduledExecutorServicecheduledThreadPool = Executors.newScheduledThreadPool（1）; scheduleThreadPool.scheduleAtFixedRate（（）-> doSomething（），0，delay，TimeUnit.SECONDS）; }

如果您使用的是Spring Framework，则可以简单地使用@Scheduled批注，如下所示：

@Scheduled(fixedRate = 5000)
public void schedule() {
    //do something
}

Answer 3

有很多方法可以解决此问题。我认为最简单的方法是，仅在给定位置使用这种方法，而不使用像Spring这样的外部框架：

private void runWithInterval(long millis) {
    Runnable task = () -> {
        try {
            while (true) {
                Thread.sleep(millis);
                // payload
            }
        } catch(InterruptedException e) {
        }
    };

    Thread thread = new Thread(task);
    thread.setDaemon(true);
    thread.start();
}

要每隔1分钟调用一次：

runWithInterval（TimeUnit.MINUTES.toMillis（1））;

PS

您可以在此处的其他帖子中看到的另一种方式的详细信息：

@Schaduler

Spring注释
使用具有单个线程的线程池：ScheduledExecutorService scheduledThreadPool = Executors.newFixedThreadPool(1)
使用Timer：new Timer().schedule(new Runnable() {}, TimeUnit.MINUTES.toMillis(1))

Answer 4

如果您熟悉ReactiveX，则有一个名为RxJava的Java库，可以用作：

Flowable.interval(1, TimeUnit.SECONDS) // Or any other desired interval
        .subscribe(iteration -> System.out.println("Hello, I'm timer, running iteration: " + iteration));

但是您真的应该阅读有关此方法和库的更多信息

Answer 5

您可以使用public void task(String foo, Integer bar){ // ... }来实现：

假设您有一个任务方法：

ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(2);
executor.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        task(fooParam, barParam);  
    }
}, 0, 60, TimeUnit.SECONDS);

Java 1.8之前的

ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
executor.scheduleAtFixedRate(() -> task(fooParam, barParam), 0, 60, TimeUnit.SECONDS);

Java 1.8 +

questionID = true/false

java-在每个时间间隔调用一个函数

5 个答案: