多线程之任务调度线程池

使用任务调度线程池, 可以使用 java.util.Timer 来实现定时功能.Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个 任务的延迟或异常都将会影响到之后的任务。

1 Timer定时

public static void main(String[] args) {
     Timer timer = new Timer();
     TimerTask task1 = new TimerTask() {
         @Override
         public void run() {
             log.debug("task 1");
             sleep(2);
         }
     };
 TimerTask task2 = new TimerTask() {
     @Override
     public void run() {
         log.debug("task 2");
     }
 };

     timer.schedule(task1, 1000);
     timer.schedule(task2, 1000);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果:

20:46:09.444 c.TestTimer [main] - start... 
20:46:10.447 c.TestTimer [Timer-0] - task 1 
20:46:12.448 c.TestTimer [Timer-0] - task 2 
1
2
3

说明:

1 使用 timer 添加两个任务，希望它们都在 1s 后执行
2 由于 timer 内只有一个线程来顺序执行队列中的任务，因此『任务1』的延时，影响了『任务2』的执行

2 使用ScheduledExecutorService优化

ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
// 添加两个任务，希望它们都在 1s 后执行
executor.schedule(() -> {
     System.out.println("任务1，执行时间：" + new Date());
     try { 
         Thread.sleep(2000); 
         } catch (InterruptedException e) { 
     }
}, 1000, TimeUnit.MILLISECONDS);
executor.schedule(() -> {
     System.out.println("任务2，执行时间：" + new Date());
}, 1000, TimeUnit.MILLISECONDS);
1
2
3
4
5
6
7
8
9
10
11
12

运行结果:

任务1，执行时间：Thu Aug 12 12:45:17 CST 2022
任务2，执行时间：Thu Aug 12 12:45:17 CST 2022
1
2

说明: 使用ScheduledExecutorService执行定时任务,互相没有影响.

3 使用scheduleAtFixedRate

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
log.debug("start...");
pool.scheduleAtFixedRate(() -> {
     log.debug("running...");
}, 1, 1, TimeUnit.SECONDS);
1
2
3
4
5

运行结果:

21:45:43.167 c.TestTimer [main] - start... 
21:45:44.215 c.TestTimer [pool-1-thread-1] - running... 
21:45:45.215 c.TestTimer [pool-1-thread-1] - running... 
21:45:46.215 c.TestTimer [pool-1-thread-1] - running... 
21:45:47.215 c.TestTimer [pool-1-thread-1] - running... 
1
2
3
4
5

添加睡眠改造

多线程任务控制实例代码

zip 0星 超过10%的资源 899.0B

下载

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
log.debug("start...");
pool.scheduleAtFixedRate(() -> {
     log.debug("running...");
     sleep(2);
}, 1, 1, TimeUnit.SECONDS);
1
2
3
4
5
6

运行结果:

21:44:30.311 c.TestTimer [main] - start... 
21:44:31.360 c.TestTimer [pool-1-thread-1] - running... 
21:44:33.361 c.TestTimer [pool-1-thread-1] - running... 
21:44:35.362 c.TestTimer [pool-1-thread-1] - running... 
21:44:37.362 c.TestTimer [pool-1-thread-1] - running... 
1
2
3
4
5

说明: 一开始，延时 1s，接下来，由于任务执行时间 > 间隔时间，间隔被『撑』到了 2s.

4 使用scheduleWithFixedDelay

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
log.debug("start...");
pool.scheduleWithFixedDelay(()-> {
     log.debug("running...");
     sleep(2);
}, 1, 1, TimeUnit.SECONDS);
1
2
3
4
5
6

运行结果:

21:40:55.078 c.TestTimer [main] - start... 
21:40:56.140 c.TestTimer [pool-1-thread-1] - running... 
21:40:59.143 c.TestTimer [pool-1-thread-1] - running... 
21:41:02.145 c.TestTimer [pool-1-thread-1] - running... 
21:41:05.147 c.TestTimer [pool-1-thread-1] - running... 
1
2
3
4
5

说明: 一开始，延时 1s，scheduleWithFixedDelay 的间隔是 上一个任务结束 + 延时 到 下一个任务开始 所以间隔都是 3s

线程数固定，任务数多于线程数时，会放入无界队列排队。任务执行完毕，这些线程也不会被释放。用来执行延迟或反复执行的任务.

C++ 线程池+任务池

zip 0星 超过10%的资源 14KB

下载

5 任务异常处理

1 主动捕捉异常

ExecutorService pool = Executors.newFixedThreadPool(1);
pool.submit(() -> {
 try {
     log.debug("task1");
     int i = 1 / 0;
 } catch (Exception e) {
     log.error("error:", e);
 }
});
1
2
3
4
5
6
7
8
9

运行结果:

21:59:04.558 c.TestTimer [pool-1-thread-1] - task1 
21:59:04.562 c.TestTimer [pool-1-thread-1] - error: 
java.lang.ArithmeticException: / by zero 
 at cn.cf.n8.TestTimer.lambda$main$0(TestTimer.java:28) 
 at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) 
 at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) 
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
 at java.lang.Thread.run(Thread.java:748) 
1
2
3
4
5
6
7
8
9

2 使用Future

ExecutorService pool = Executors.newFixedThreadPool(1);
Future<Boolean> f = pool.submit(() -> {
     log.debug("task1");
     int i = 1 / 0;
     return true;
});
log.debug("result:{}", f.get());
1
2
3
4
5
6
7

运行结果:

21:54:58.208 c.TestTimer [pool-1-thread-1] - task1 
Exception in thread "main" java.util.concurrent.ExecutionException: 
java.lang.ArithmeticException: / by zero 
 at java.util.concurrent.FutureTask.report(FutureTask.java:122) 
 at java.util.concurrent.FutureTask.get(FutureTask.java:192) 
 at cn.cf.n8.TestTimer.main(TestTimer.java:31) 
Caused by: java.lang.ArithmeticException: / by zero 
 at cn.cf.n8.TestTimer.lambda$main$0(TestTimer.java:28) 
 at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) 
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
 at java.lang.Thread.run(Thread.java:748) 

1
2
3
4
5
6
7
8
9
10
11
12
13