Java中设置时间间隔有哪些方法与技巧？如何高效实现定时任务？

在Java中设置时间间隔通常可以通过以下几种方式实现：

使用Thread.sleep()

这是最简单也是最直接的方式,通过调用Thread.sleep()方法可以让当前线程暂停执行指定的毫秒数。

public class SleepExample {
    public static void main(String[] args) {
        try {
            // 暂停当前线程2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

注意：当使用Thread.sleep()时，如果当前线程被中断，则会抛出InterruptedException。

使用ScheduledExecutorService

ScheduledExecutorService提供了计划执行任务的能力,可以通过scheduleAtFixedRate()或scheduleWithFixedDelay()方法设置时间间隔。

1 scheduleAtFixedRate()

该方法会以固定的频率执行任务,忽略任务的执行时间。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduleAtFixedRateExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(() > {
            System.out.println("执行任务");
            try {
                // 假设任务需要3秒完成
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);
    }
}

2 scheduleWithFixedDelay()

该方法也会以固定的频率执行任务,但会等待任务的执行时间结束后再开始下一次执行。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduleWithFixedDelayExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleWithFixedDelay(() > {
            System.out.println("执行任务");
            try {
                // 假设任务需要3秒完成
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);
    }
}

使用CountDownLatch

CountDownLatch可以用来协调多个线程的执行,通过设置时间间隔，可以让主线程等待一定时间后继续执行。

import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        new Thread(() > {
            try {
                // 模拟任务执行需要2秒
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务执行完毕");
            latch.countDown();
        }).start();
        System.out.println("等待任务执行完毕");
        latch.await();
    }
}

使用CyclicBarrier

CyclicBarrier可以用来协调多个线程的执行,它允许一组线程等待彼此到达某个点，然后同时执行。

import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
    public static void main(String[] args) {
        int numThreads = 3;
        CyclicBarrier barrier = new CyclicBarrier(numThreads, () > {
            System.out.println("所有线程到达屏障");
        });
        for (int i = 0; i < numThreads; i++) {
            new Thread(() > {
                try {
                    // 模拟任务执行需要2秒
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程 " + Thread.currentThread().getName() + " 到达屏障");
                try {
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

表格对比

FAQs

Q1：为什么使用Thread.sleep()时，如果当前线程被中断，则会抛出InterruptedException？

A1：Thread.sleep()方法是一个静态方法，当调用它时，如果当前线程被中断，则会抛出InterruptedException，这是因为Thread.sleep()方法会尝试让当前线程暂停执行，如果此时线程被中断，则需要通知线程它已经被中断，因此抛出InterruptedException。

Q2：ScheduledExecutorService与Timer相比，有哪些优点？

A2：与Timer相比，ScheduledExecutorService提供了更强大的功能，包括但不限于以下几点：

• 线程池管理：ScheduledExecutorService允许你创建一个线程池来管理线程，而Timer不提供线程池的功能。
• 灵活的调度策略：ScheduledExecutorService提供了多种调度策略，如固定延迟执行、固定频率执行等，而Timer只提供固定延迟执行。
• 更好的性能：由于ScheduledExecutorService使用了线程池，因此可以更好地利用系统资源，提高性能。