部署Spring Cloud Task遇异常：报"Deadlock found when trying to get lock"，需限制单处理器并发任务数

Hey there! Let's break down your Spring Cloud Task issues and fix them step by step:

This error usually pops up due to conflicts in Spring Cloud Task's default database-based locking mechanism, which is designed to prevent duplicate task executions. Here are the most common fixes to try:

• Check Transaction Boundaries: If your task logic runs inside a long-running @Transactional method, it might hold the database lock longer than necessary, leading to deadlocks with other competing tasks. Try refactoring your code to keep transactions as short as possible, or move non-transactional logic outside the transaction scope.

• Verify Lock Table Configuration: Spring Cloud Task uses the TASK_LOCK table to manage execution locks. Make sure this table has proper indexes (e.g., on task_name and lock_time columns) to avoid slow lock acquisition. Also, check your database's isolation level—using SERIALIZABLE is overkill here; switching to READ COMMITTED will significantly reduce deadlock chances.

• Prevent Duplicate Task Triggers: If multiple schedulers (like Quartz or Spring Cloud Scheduler) are triggering the same task simultaneously, they’ll compete for the same lock and cause deadlocks. Ensure your scheduler uses distributed locking to avoid duplicate triggers, or add a small delay between task launches if possible.

Spring Cloud Task doesn’t have built-in concurrency limits, but you can implement this with a few practical approaches:

Option 1: Custom TaskExecutor #

Configure a thread pool executor to control how many tasks run in parallel on a single processor:

@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(2); // Minimum concurrent tasks to keep alive
    executor.setMaxPoolSize(4); // Maximum concurrent tasks allowed
    executor.setQueueCapacity(8); // Queue size for pending tasks
    executor.setThreadNamePrefix("task-worker-");
    executor.initialize();
    return executor;
}

Spring Cloud Task will automatically use this executor to run task instances once you register it in your configuration.

Option 2: Database-Based Concurrency Check #

Create a custom TaskExecutionListener to validate running task counts before launching a new one:

@Component
public class ConcurrencyLimitListener implements TaskExecutionListener {

    private static final int MAX_CONCURRENT_TASKS = 3;
    private final TaskRepository taskRepository;

    public ConcurrencyLimitListener(TaskRepository taskRepository) {
        this.taskRepository = taskRepository;
    }

    @Override
    public void beforeTaskExecution(TaskExecution taskExecution) {
        // Count tasks that are still active (exit code is null)
        long activeTaskCount = taskRepository.countByExitCodeIsNull();
        if (activeTaskCount >= MAX_CONCURRENT_TASKS) {
            throw new TaskExecutionException("Cannot start new task: Concurrent task limit reached (" + MAX_CONCURRENT_TASKS + ")");
        }
    }

    @Override
    public void afterTaskExecution(TaskExecution taskExecution) {
        // Optional: Add cleanup logic if needed
    }
}

Register the listener to activate it:

@Bean
public TaskListener concurrencyLimitListener(TaskRepository taskRepository) {
    return new ConcurrencyLimitListener(taskRepository);
}

Note: Ensure your tasks properly update the exit_code in the TASK_EXECUTION table when they finish—otherwise, the active task count will be inaccurate.

Option 3: Using Spring Cloud Data Flow (if applicable) #

If you’re using Spring Cloud Data Flow to deploy tasks, you can set the deployer.<task-name>.count property during deployment to limit concurrent instances per processor:

dataflow:>task deploy --name my-task --properties deployer.my-task.count=2

内容的提问来源于stack exchange，提问作者Bhuvnesh