java中方法执行的自动化

我有6个功能需要在特定的时间间隔内运行：

public void runFirst() {
    System.out.println("First method");
}

public void runSecond() {
    System.out.println("Second method");
}

public void runThird() {
    System.out.println("Third method");
}

public void runFourth() {
    System.out.println("Fourth method");
}

public void runFifth() {
    System.out.println("Fifth method");
}

public void runSixth() {
    System.out.println("Sixth method");
}

在我使用Thread.sleep时，我需要在单击按钮后立即运行第一个，第二个必须在65秒后运行，第三个必须在第二个之后运行20秒，第四个必须在第三个之后运行15秒，依此类推，但我需要在不使用睡眠的情况下运行

---

最好的方法是什么？有人可以根据我的方法给我举一些例子。

你可以使用石英。单击该按钮时，您可以获取系统当前时间，并添加新的计划作业以在特定日期和时间运行。因此Quartz将处理它，使其按时间运行

另一种方法是创建一个新线程，并在其上定义睡眠时间段，然后让其运行。

为什么不能使用

Thread.sleep

---

然后在不同的线程中运行此代码，整个应用程序将不会在睡眠时停止

也许你想检查这个方法，有超时的方法

引述：

。。。线程处于休眠状态，直到达到指定的实时时间 已经过去了

---

要在一段时间后运行任务，您应该使用，这是线程安排任务以便将来在后台线程中执行的工具

---

它使您从创建自己的线程中解放出来：更不容易出错，也更容易。它可以管理多个计划任务。但是要注意，这些任务应该是短期的，否则它们将阻止计时器用于调度puropose的线程。

为方法创建一个线程类和另一个类

现在：

然后为您的方法初始化：

public class YourClass {

    public void runFirst() {
        System.out.println("First method");
    }

    public void runSecond() {
        System.out.println("Second method");
    }

    public void runThird() {
        System.out.println("Third method");
    }

    public void runFourth() {
        System.out.println("Fourth method");
    }

    public void runFifth() {
        System.out.println("Fifth method");
    }

    public void runSixth() {
        System.out.println("Sixth method");
    }
}

下面是按钮onClick事件的方法：

//on button click

ThreadTest th1 = new ThreadTest(1, 0, obj);//here obj is YourClass
ThreadTest th2 = new ThreadTest(2, 65000, obj);//65 SECONDS
//... keep adding

Thread thread1 = new Thread(th1);
Thread thread2 = new Thread(th2);
//...keep adding

thread1.start();
thread2.start();
//...keep adding

使用执行器服务。基本思路如下：

    // "Global" resource
    final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5); // Adjust threadpool size

    ...
    // inside onclick() processing        
    ScheduledFuture<Void> future1 = executorService.schedule(new Callable<Void>() {
        @Override Void call() {
            try {
                runFirst();
            } finally {
                scheduleFuture2();
            }
        }
    },
    65,
    TimeUnit.SECONDS);
    ...

    void scheduleFuture2() {            
        ScheduledFuture<Void> future2 = executorService.schedule(new Callable<Void>() {
            @Override Void call() {
                try {
                    runSecond();
                } finally {
                    scheduleFuture3();
                }                    
            }
        },
        20,
        TimeUnit.SECONDS);
    }

    ...

    void scheduleFuture3() {            
        ScheduledFuture<Void> future3 = executorService.schedule(new Callable<Void>() {
            @Override Void call() {
                try {
                    runThird();
                } finally {
                    scheduleFuture4();
                }                    
            }
        },
        15,
        TimeUnit.SECONDS);
    }
    ...
    // And so on

一些注意事项：

如果runFirst，runSecond。。。在执行Swing/AWT UI操作时，应该适当地利用这些方法中的 不要忘记在不再使用此机制时调用executorService.shutdown。如果你忘了它，你会漏线程。 大写V以上对Void的引用是有意的：我们使用的是Void类，而不是Void类型 用一把枪

如果由于某种原因无法使用Java 8，请使用，而不是：

---

你想在没有线程的情况下执行此操作。睡眠？是的，如果可能的话。如果否，我如何才能使整个应用程序在睡眠期间不暂停？将其放在单独的线程上。查看。ovonel将需要使其不睡眠。ovonel是，如果可能的话。如果没有，我怎样才能使整个应用程序在睡眠期间不暂停？没关系，我会继续睡眠，但我会把它放在不同的线程上。谢谢大家的帮助。老兄，你真是一颗宝石。。。非常感谢你。我想投票，但我不能：/看起来像是重新发明轮子。。。为什么不使用现有的实用程序，如计时器或ScheduledExecutorService？我已经等了0+65+85+100+110+115=475秒，你的程序运行得非常好！是，等待为0的计划与执行相同。程序将不会等待475秒，对schedule的连续调用将不会在最后一次调用之后对其进行调度，时间从调度时间开始。因此，它将总共等待115秒。在本例中，5:th和6:th之间的时间仅为5秒。谢谢您的通知。我有点困惑。115秒。问题是第三个20秒后的第二个20秒，这与这里发生的情况不完全相同，尤其是如果方法执行一些长操作。要做到完美，每个任务都应该安排下一个任务。没错，如果这很重要，那么第一个任务就必须安排下一个任务。但它并没有说最后一个任务完成后20秒，所以这也是不明确的，它会使任务变得混乱

    // "Global" resource
    final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5); // Adjust threadpool size

    ...
    // inside onclick() processing        
    ScheduledFuture<Void> future1 = executorService.schedule(new Callable<Void>() {
        @Override Void call() {
            try {
                runFirst();
            } finally {
                scheduleFuture2();
            }
        }
    },
    65,
    TimeUnit.SECONDS);
    ...

    void scheduleFuture2() {            
        ScheduledFuture<Void> future2 = executorService.schedule(new Callable<Void>() {
            @Override Void call() {
                try {
                    runSecond();
                } finally {
                    scheduleFuture3();
                }                    
            }
        },
        20,
        TimeUnit.SECONDS);
    }

    ...

    void scheduleFuture3() {            
        ScheduledFuture<Void> future3 = executorService.schedule(new Callable<Void>() {
            @Override Void call() {
                try {
                    runThird();
                } finally {
                    scheduleFuture4();
                }                    
            }
        },
        15,
        TimeUnit.SECONDS);
    }
    ...
    // And so on

{
    ScheduledExecutorService worker = Executors.newScheduledThreadPool(1);
    worker.execute(() -> runFirst());
    worker.schedule(() -> runSecond(), 65, TimeUnit.SECONDS);
    worker.schedule(() -> runThird(), 85, TimeUnit.SECONDS);
    worker.schedule(() -> runFourth(), 100, TimeUnit.SECONDS);
    worker.schedule(() -> runFifth(), 110, TimeUnit.SECONDS);
    worker.schedule(() -> runSixth(), 115, TimeUnit.SECONDS);
    worker.shutdown();
}

// worker.schedule(() -> runSixth(), 115, TimeUnit.SECONDS);
worker.schedule(new Runnable(){
    @Override
    public void run() {
        runSixth();
    }}, 115, TimeUnit.SECONDS);