Great question! Since you're already using Spring's ThreadPoolTaskExecutor, we can leverage its flexibility to add priority sorting without building a thread pool from scratch. Here's how to do it step by step:

The default Runnable doesn't carry your Notification's timestamp, so we need a wrapper class that implements Comparable—this lets the priority queue know how to order tasks.

public class PriorityNotificationRunnable implements Runnable, Comparable<PriorityNotificationRunnable> {
    private final Runnable delegateTask;
    private final long notificationTimestamp;

    public PriorityNotificationRunnable(Runnable delegateTask, long notificationTimestamp) {
        this.delegateTask = delegateTask;
        this.notificationTimestamp = notificationTimestamp;
    }

    @Override
    public void run() {
        delegateTask.run(); // Delegate to your original processing logic
    }

    @Override
    public int compareTo(PriorityNotificationRunnable other) {
        // Adjust sorting logic here:
        // Use `Long.compare(this.notificationTimestamp, other.notificationTimestamp)` for oldest first
        // Use `Long.compare(other.notificationTimestamp, this.notificationTimestamp)` for newest first
        return Long.compare(other.notificationTimestamp, this.notificationTimestamp);
    }
}

Spring's ThreadPoolTaskExecutor lets you replace its default queue. We'll swap the standard LinkedBlockingQueue with PriorityBlockingQueue—a thread-safe, unbounded queue that respects task priority, which fits your requirements perfectly.

Option A: XML Configuration (matches your existing setup) #

Update your Spring XML to specify the priority queue class:

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="corePoolSize" value="1"/>
    <property name="maxPoolSize" value="1"/>
    <property name="waitForTasksToCompleteOnShutdown" value="true"/>
    <!-- Use PriorityBlockingQueue instead of default LinkedBlockingQueue -->
    <property name="queueClass" value="java.util.concurrent.PriorityBlockingQueue"/>
    <!-- Optional: Set initial queue capacity (default is 11) -->
    <property name="queueCapacity" value="100"/>
</bean>

Option B: Java Configuration (more flexible for future tweaks) #

If you prefer Java-based config (great for complex queue setups):

@Bean
public ThreadPoolTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(1);
    executor.setMaxPoolSize(1);
    executor.setWaitForTasksToCompleteOnShutdown(true);
    // Directly inject the priority queue
    executor.setQueue(new PriorityBlockingQueue<>(100));
    return executor;
}

Wrap your original processing logic in the priority-aware runnable when submitting tasks:

asynchronousService.executeAsynchronously(new PriorityNotificationRunnable(() -> {
    someMethod.processNotification(notification);
}, notification.getTimestamp()));

• Sorting Flexibility: Tweak the compareTo method to match your exact priority needs (oldest first vs newest first).
• Unbounded Queue Compatibility: PriorityBlockingQueue is unbounded, just like the default queue you're using—no risk of task rejection due to queue limits.
• Single Thread Compliance: Your core/max pool size of 1 ensures tasks are processed one at a time in priority order, which aligns with your "no parallel processing" requirement.

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