Java并发编程：线程池和定时任务的实战案例

原创亦凉 2024-12-08 02:15 4阅读 0赞

Java并发编程中，线程池和定时任务是两种常用的资源管理和调度方式。下面我们将通过一个实战案例来详细解析这两部分。

**1. 线程池实战**

```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {

public static void main(String[] args) {
        // 创建线程池，大小为3个线程
        ExecutorService executor = Executors.newFixedThreadPool(3);

// 提交任务到线程池，每个任务是一个独立的Runnable对象
        for (int i = 0; i < 10; i++) {
            Runnable task = new Task("Task " + i));
            executor.execute(task);
        }

// 关闭线程池，释放资源
        executor.shutdown();
        while (!executor.isTerminated())) {
            System.out.println("Remaining threads: " + executorremainingThreadCount());
            try {
                Thread.sleep(1000); // 每秒检查一次
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 线程池已经彻底关闭，剩余任务也已全部完成
        System.out.println("ThreadPool shut down.");
    }

static class Task implements Runnable {

private String name;

public Task(String name) {
            this.name = name;
        }

@Override
        public void run() {
            System.out.println("Executing task: " + name);
            try {
                Thread.sleep(5000); // 模拟任务执行时间，实际上无需这么长
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task " + name + " executed successfully.");
        }

}
}
```

这个案例中，我们创建了一个固定大小的线程池，然后通过`ExecutorService`提交了一系列任务到线程池。每个任务都是一个独立的Runnable对象。

**2. 定时任务实战**

Java提供了一种基于Timer和TimerTask的定时任务解决方案。下面以Java 8为例进行解释：

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

public class TimerTaskExample {

public static void main(String[] args) {
        // 创建一个定时器，时间为5秒（5000毫秒）
        Timer timer = new Timer();
        timer.schedule(new MyTimerTask(), 5000); // 5000毫秒等于5秒

try {
            // 主程序等待定时任务执行完毕后结束
            while (!timer.isTerminated())) {
                System.out.println("Remaining timer tasks: " + timer.getPendingTasks()));
                try {
                    Thread.sleep(1000); // 每秒检查一次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            System.out.println("Timer task executed successfully. Timer shut down.");
            if (!timer.isTerminated())) {
                timer.shutdown(); // 如果定时器中还有任务未执行，需要调用shutdown方法使所有任务完成
            }
        }
    }

static class MyTimerTask extends TimerTask {

@Override
        public void run() {
            System.out.println("Executing timer task.");
            try {
                Thread.sleep(2000); // 模拟耗时操作，实际上无需这么长
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Timer task executed successfully.");
        }

}

}
```

在这个例子中，我们创建了一个定时器，并在5秒后执行一个自定义的定时任务。这个任务只是一个模拟耗时操作的例子。

**总结：**

通过以上两个实战案例，我们可以更好地理解和掌握Java并发编程中的线程池和定时任务的使用方法。