Cara menggunakan multi-threading tugas berjadual @Scheduled dalam SpringBoot

1 Pengenalan kepada @Scheduled anotation

@Scheduled ialah anotasi dalam rangka Spring Ia boleh digunakan untuk mengkonfigurasi tugas berjadual supaya kaedah boleh digunakan seperti yang dinyatakan Dilaksanakan secara tetap pada selang waktu. Apabila menggunakan anotasi ini, kita boleh menentukan masa pelaksanaan, tempoh kitaran, bilangan konkurensi dan parameter lain tugasan untuk merealisasikan fungsi tugasan yang dijadualkan. Dalam Spring Boot, anotasi @Scheduled boleh digunakan terus pada kaedah.

2. Mekanisme berbilang benang @Scheduled

Dalam Spring Boot, anotasi @Scheduled dilaksanakan berdasarkan ThreadPoolExecutor dan ScheduledThreadPoolExecutor Java. Apabila kami mengkonfigurasi tugasan yang dijadualkan, Spring Boot akan mula-mula mencipta kumpulan benang ScheduledThreadPoolExecutor dan menambah tugasan yang dijadualkan pada kumpulan benang untuk menunggu pelaksanaan. Kemudian, selepas masa yang ditentukan tiba, kumpulan benang akan memperuntukkan benang untuk melaksanakan tugas yang dijadualkan. Jika tugasan yang dijadualkan masih belum dilaksanakan, kumpulan benang akan memperuntukkan benang kepada tugas itu semula apabila kitaran seterusnya tiba. Dengan cara ini, @Scheduled boleh dengan mudah melaksanakan tugas berjadual berkala yang dilaksanakan oleh ThreadPoolExecutor dan ScheduledThreadPoolExecutor Java. Apabila kami mengkonfigurasi tugasan yang dijadualkan, Spring Boot akan mula-mula mencipta kumpulan benang ScheduledThreadPoolExecutor dan menambah tugasan yang dijadualkan pada kumpulan benang untuk menunggu pelaksanaan. Kemudian, selepas masa yang ditentukan tiba, kumpulan benang akan memperuntukkan benang untuk melaksanakan tugas yang dijadualkan. Jika tugasan yang dijadualkan masih belum dilaksanakan, kumpulan benang akan memperuntukkan benang kepada tugas itu semula apabila kitaran seterusnya tiba. Dengan cara ini, @Scheduled boleh melaksanakan tugas berjadual berkala dengan mudah.

3. Isu berbilang benang @Scheduled

Walaupun anotasi @Scheduled sangat mudah, ia juga mempunyai beberapa isu berbilang benang, terutamanya ditunjukkan dalam dua aspek berikut:

1. Apabila tugasan yang dijadualkan tidak selesai, tugasan berikutnya mungkin terjejas

Apabila menggunakan anotasi @Scheduled, adalah mudah untuk kita mengabaikan masalah: jika tugasan yang dijadualkan sedang dilaksanakan, tugas kitaran seterusnya telah pun tiba, maka tugasan seterusnya mungkin terjejas. Sebagai contoh, kami mentakrifkan tugas A yang dijadualkan dengan selang 5 saat, yang memulakan pelaksanaan pada saat pertama dan mengambil masa 10 saat untuk dilaksanakan. Pada saat ke-6, tugasan yang dijadualkan A masih belum berakhir Pada masa ini, tugasan B dalam kitaran seterusnya telah mula menunggu untuk dilaksanakan. Jika tidak terdapat benang melahu yang mencukupi dalam kumpulan benang pada masa ini, tugas B yang dijadualkan akan disekat dan tidak boleh dilaksanakan.

2. Pelaksanaan serentak berbilang tugasan berjadual boleh menyebabkan persaingan sumber

Dalam sesetengah kes, kami mungkin perlu menulis berbilang tugas berjadual dan tugas berjadual ini mungkin melibatkan sumber yang dikongsi, seperti pangkalan data Sambungan, objek cache, dsb. Apabila berbilang tugas berjadual dilaksanakan pada masa yang sama, akan terdapat masalah persaingan sumber, yang boleh menyebabkan ralat data atau ranap sistem.

4. @Scheduled menyertai kumpulan benang untuk memproses tugasan yang dijadualkan

Untuk mengelakkan masalah di atas, tugasan @Scheduled boleh diserahkan kepada kumpulan benang untuk diproses. Dalam Spring Boot, anda boleh menambah @Scheduled tasks pada thread pool dalam dua cara berikut:

1 Gunakan @EnableScheduling + @Configuration untuk mengkonfigurasi ThreadPoolTaskScheduler

@Configuration
@EnableScheduling
public class TaskSchedulerConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10);
        scheduler.initialize();
        return scheduler;
    }
}

Dalam kod di atas, kami. lulus Konfigurasikan ThreadPoolTaskScheduler untuk mencipta kumpulan benang dan gunakan anotasi @EnableScheduling untuk mendayakan tugas yang dijadualkan. Antaranya, kaedah setPoolSize boleh menetapkan saiz kumpulan benang, yang lalai kepada 1.

2. Gunakan ThreadPoolTaskExecutor

@Configuration
@EnableScheduling
public class TaskExecutorConfig {
    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(1000);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("task-executor-");
        return executor;
    }
}

Dalam kod di atas, kami mencipta kumpulan benang dengan mengkonfigurasi ThreadPoolTaskExecutor dan menggunakan anotasi @EnableScheduling untuk menghidupkan tugas yang dijadualkan. Antaranya, setCorePoolSize, setMaxPoolSize, setQueueCapacity, setKeepAliveSeconds dan kaedah lain boleh digunakan untuk mengkonfigurasi parameter seperti saiz kumpulan benang dan baris gilir tugas.

5. Analisis terperinci tentang @Scheduled

Dalam Spring Boot, anotasi @Scheduled dilaksanakan berdasarkan Java's ThreadPoolExecutor dan ScheduledThreadPoolExecutor. Apabila kami mengkonfigurasi tugasan yang dijadualkan, Spring Boot akan mula-mula mencipta kumpulan benang ScheduledThreadPoolExecutor dan menambah tugasan yang dijadualkan pada kumpulan benang untuk menunggu pelaksanaan. Kemudian, selepas masa yang ditentukan tiba, kumpulan benang akan memperuntukkan benang untuk melaksanakan tugas yang dijadualkan. Jika tugasan yang dijadualkan belum dilaksanakan lagi, apabila kitaran seterusnya tiba, kumpulan benang akan memperuntukkan benang kepada tugas itu sekali lagi untuk dilaksanakan. Dengan cara ini, @Scheduled boleh melaksanakan tugas berjadual berkala dengan mudah.

Walaupun anotasi @Scheduled sangat mudah, ia juga mempunyai beberapa masalah berbilang benang, terutamanya ditunjukkan dalam dua aspek berikut:

1. 定时任务未执行完毕时，后续任务可能会受到影响

在使用@Scheduled注解时，我们很容易忽略一个问题：如果定时任务在执行时，下一个周期的任务已经到了，那么后续任务可能会受到影响。例如，我们定义了一个间隔时间为5秒的定时任务A，在第1秒时开始执行，需要执行10秒钟。在第6秒时，定时任务A还没有结束，此时下一个周期的任务B已经开始等待执行。如果此时线程池中没有足够的空闲线程，那么定时任务B就会被阻塞，无法执行。

解决方案：

针对上述问题，我们可以采用以下两种方案来解决：

方案一：修改线程池大小

为了避免因为线程池中线程数量不足引起的问题，我们可以对线程池进行配置，提高线程池的大小，从而确保有足够的空闲线程来处理定时任务。

例如，我们可以在application.properties或application.yml或者使用@EnableScheduling + @Configuration来配置线程池大小：

spring.task.scheduling.pool.size=20

2. 多个定时任务并发执行可能导致资源竞争

在某些情况下，我们可能需要编写多个定时任务，这些定时任务可能涉及到共享资源，例如数据库连接、缓存对象等。当多个定时任务同时执行时，就会存在资源竞争的问题，可能会导致数据错误或者系统崩溃。

解决方案：

为了避免由于多个定时任务并发执行导致的资源竞争问题，我们可以采用以下两种方案来解决：

方案一：使用锁机制

锁机制是一种常见的解决多线程并发访问共享资源的方式。在Java中，我们可以使用synchronized关键字或者Lock接口来实现锁机制。

例如，下面是一个使用synchronized关键字实现锁机制的示例：

private static Object lockObj = new Object();

@Scheduled(fixedDelay = 1000)
public void doSomething(){
    synchronized(lockObj){
        // 定时任务要执行的内容
    }
}

在上述代码中，我们定义了一个静态对象lockObj，用来保护共享资源。在定时任务执行时，我们使用synchronized关键字对lockObj进行加锁，从而确保多个定时任务不能同时访问共享资源。

方案二：使用分布式锁

除了使用传统的锁机制外，还可以使用分布式锁来解决资源竞争问题。分布式锁是一种基于分布式系统的锁机制，它可以不依赖于单个JVM实例，从而能够保证多个定时任务之间的资源访问不会冲突。

在Java开发中，我们可以使用ZooKeeper、Redis等分布式系统来实现分布式锁机制。例如，使用Redis实现分布式锁的示例代码如下：

@Autowired
private RedisTemplate redisTemplate;

@Scheduled(fixedDelay = 1000)
public void doSomething(){
    String lockKey = "lock:key";
    String value = UUID.randomUUID().toString();
    Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, value, 5L, TimeUnit.SECONDS);
    if(result){
        try{
            // 定时任务要执行的内容
        }finally{
            redisTemplate.delete(lockKey);
        }
    }
}

在上述代码中，我们使用Redis实现了分布式锁机制。具体而言，我们在定时任务执行时，首先向Redis中写入一个键值对，然后检查是否成功写入。如果成功写入，则表示当前定时任务获得了锁，可以执行接下来的操作。在定时任务执行完毕后，我们再从Redis中删除该键值对，释放锁资源。

Atas ialah kandungan terperinci Cara menggunakan multi-threading tugas berjadual @Scheduled dalam SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!