Java并发编程: 任务调度和执行的多种方式示例

原创系统管理员 2024-09-11 22:06 53阅读 0赞

在Java并发编程中，任务调度和执行有多种方式，下面列举几个常见的示例：

1. **线程池**：
```java
// 创建一个固定大小的线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务到线程池
executor.submit(() -> {
    // 这里是你要执行的任务代码
})); // 提交任务

// 关闭线程池
executor.shutdown();

// 确保所有任务已完成（这可能需要一些时间）
while (!executor.isTerminated()) {
    // 等待
}

// 执行完成，关闭资源
executor.shutdownNow();
```

2. **定时器**：
```java
import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    private Timer timer;

public void scheduleTask(int delay, Runnable task) {
        if (timer == null) {
            timer = new Timer();
        }

// 创建并提交定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                // 这里是你要执行的任务代码（task.call()）
                task.run();
            }
        }, delay, TimeUnit.SECONDS);
    }

public static void main(String[] args) {
        TimerExample example = new TimerExample();

// 示例：1秒后调用Runnable任务
        example.scheduleTask(1000, () -> {
            System.out.println("Timer task executed at " + System.currentTimeMillis());
        }));
    }
}
```

3. **Future和ExecutorService**：
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

public class FutureExample {
    private ExecutorService executor;

public void scheduleTask(int delay, Runnable task) {
        if (executor == null) {
            executor = Executors.newFixedThreadPool(1);
        }

// 创建并提交Future任务
        Future<?> future = executor.submit(() -> {
            try {
                // 这里是你要执行的任务代码（task.call()）
                task.run();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));

// 等待Future任务完成
        future.get();

// 关闭资源
        executor.shutdownNow();
    }

public static void main(String[] args) {
        FutureExample example = new FutureExample();

// 示例：1秒后调用Runnable任务
        example.scheduleTask(1000, () -> {
            System.out.println("Future task executed at " + System.currentTimeMillis());
        }));
    }
}
```

以上示例展示了Java并发编程中任务调度和执行的几种常见方式，包括线程池、定时器以及使用Future与ExecutorService。