深入探索Java并发编程：ConcurrentSkipListSet的高效使用与实现原理

import java.util.concurrent.ConcurrentSkipListSet;

// 任务类，实现Comparable接口以便排序
class Task implements Comparable<Task> {
    private final int priority; // 优先级
    private final String description; // 任务描述

    public Task(int priority, String description) {
        this.priority = priority;
        this.description = description;
    }

    public int getPriority() {
        return priority;
    }

    public String getDescription() {
        return description;
    }

    // 根据优先级进行排序，优先级高的任务排在前面
    @Override
    public int compareTo(Task other) {
        // 注意这里我们使用Integer.compare进行比较，以避免整数溢出问题
        return Integer.compare(other.priority, this.priority);
    }

    @Override
    public String toString() {
        return "Task{" + "priority=" + priority + ", description='" + description + '\'' + '}';
    }
}

// 任务调度器类
class TaskScheduler {
    private final ConcurrentSkipListSet<Task> taskSet; // 使用ConcurrentSkipListSet存储任务

    public TaskScheduler() {
        taskSet = new ConcurrentSkipListSet<>();
    }

    // 添加任务
    public void addTask(Task task) {
        taskSet.add(task);
        System.out.println("添加任务: " + task);
    }

    // 取消任务
    public void cancelTask(Task task) {
        taskSet.remove(task);
        System.out.println("取消任务: " + task);
    }

    // 显示当前所有任务（按优先级排序）
    public void showTasks() {
        System.out.println("当前任务列表（按优先级排序）:");
        for (Task task : taskSet) {
            System.out.println(task);
        }
    }

    // 执行最高优先级的任务（如果有的话）
    public void executeHighestPriorityTask() {
        // 由于ConcurrentSkipListSet是有序的，第一个元素就是最高优先级的任务
        Task highestPriorityTask = taskSet.first();
        if (highestPriorityTask != null) {
            System.out.println("执行最高优先级的任务: " + highestPriorityTask);
            // 这里只是模拟执行任务，实际上应该有一个线程池来执行任务，并从集合中移除它
            // 但由于ConcurrentSkipListSet不支持在遍历过程中直接移除元素，我们需要额外的逻辑来处理这个任务移除的问题。
            // 为了简单起见，这里我们只打印任务信息而不实际移除它。
            // 在真实场景中，你可能需要使用一个额外的数据结构（如队列）来处理任务执行和移除的逻辑。
        } else {
            System.out.println("当前没有任务可执行。");
        }
    }
}

// 测试类
public class TaskSchedulerTest {
    public static void main(String[] args) throws InterruptedException {
        TaskScheduler scheduler = new TaskScheduler();

        // 创建并添加一些任务
        scheduler.addTask(new Task(3, "编写文档"));
        scheduler.addTask(new Task(5, "修复bug"));
        scheduler.addTask(new Task(1, "回复邮件"));

        // 显示当前任务列表
        scheduler.showTasks();

        // 执行最高优先级的任务（应该是“修复bug”）
        scheduler.executeHighestPriorityTask();

        // 取消一个任务
        Task taskToCancel = new Task(3, "编写文档"); // 注意：这里我们创建了一个新的Task对象来尝试取消任务，这实际上是不正确的做法。
        // 在真实场景中，你应该保存对原始Task对象的引用，并使用该引用来取消任务。因为Task的equals和hashCode方法没有被重写，所以这里无法正确取消任务。
        // 为了演示目的，我们假设这里能够正确取消任务（但在实际代码中这是不会发生的）。
        // 正确的做法是在添加任务时保存Task对象的引用，并在需要时使用该引用来取消任务。或者重写Task类的equals和hashCode方法以支持按值比较。
        // 但由于这个案例的重点是展示ConcurrentSkipListSet的使用，所以我们不在这里深入讨论这个问题。
        scheduler.cancelTask(taskToCancel); // 注意：这里实际上并没有取消任何任务，因为taskToCancel并不是集合中的一个元素（它们是不同的对象实例）。正确的做法是使用原始Task对象的引用来取消任务。

        // 再次显示当前任务列表（应该不包含已取消的任务）
        scheduler.showTasks(); // 注意：由于上面的取消操作没有成功，所以这里的任务列表仍然包含原始的所有任务。如果取消操作成功的话，这里应该只显示剩下的任务。
    }
}