我的比较器方法如何违反了它的一般契约？

Question

import java.util.Collections;
import java.util.Comparator;
import org.joda.time.DateTime;

public static Comparator<Task> TASK_PRIORITY = new Comparator<Task>() {
    public int compare(Task task1, Task task2) {
        if (task1 == null && task2 == null) return 0;
        if (task1 == null) return +1; //null last
        if (task2 == null) return -1; //null last

        // Only consider retries after a task is retried 5+ times
        if (task1.getRetries() >= 5 || task2.getRetries() >= 5) {
            // Primary sort: retry count (ascending)
            int retriesCompare = Integer.compare(task1.getRetries(), task2.getRetries());
            if (retriesCompare != 0) return retriesCompare;
        }

        // Secondary sort: creation time (ascending, null first)
        int creationCompare = compareTimeNullFirst(task1.getCreationTime(), task2.getCreationTime());
        if (creationCompare != 0) return creationCompare;

        // Tertiary sort: load time (ascending, null last)
        int loadCompare = compareTimeNullLast(task1.getLoadTime(), task2.getLoadTime());
        if (loadCompare != 0) return loadCompare;

        return 0;
    }
};

private static int compareTimeNullLast(DateTime time1, DateTime time2) {
    if (time1 == null && time2 == null) return 0;
    if (time1 == null) return +1;
    if (time2 == null) return -1;
    if (time1.isBefore(time2) return -1;
    if (time1.isAfter(time2)) return +1;
    return 0;
}

private static int compareTimeNullFirst(DateTime time1, DateTime time2) {
    if (time1 == null && time2 == null) return 0;
    if (time1 == null) return -1;
    if (time2 == null) return +1;
    if (time1.isBefore(time2) return -1;
    if (time1.isAfter(time2)) return +1;
    return 0;
}

//tasks is a List<Task>
Collections.sort(tasks, TASK_PRIORITY);

我有时会得到一个 IllegalArgumentException for Compare 方法违反其一般合同！我可以始终如一地抛出此异常，实时数据运行足够长的时间，但我不确定如何解决问题的实际原因。

我的比较仪有什么问题？(具体来说，我违反了合同的哪一部分？)如何在不掩盖异常的情况下修复它？

• 我使用的是 Java 7，如果不进行重大重写就无法升级。
• 我可以通过将java.util.Arrays.useLegacyMergeSort设置为true来掩盖异常，但这不是一个理想的解决方案。
• 我尝试创建测试来随机生成数据并验证每个合同条件。我无法抛出异常。
• 我尝试删除重试比较周围的条件，但最终仍然得到了异常。
• 此行引发异常：Collections.sort（tasks， TASK_PRIORITY）;

Answer 1

让我们从头开始。我对您的代码的解读是，您的比较器的逻辑是合理的。（我本可以避免使用null任务和DateTime值，但这与您的问题无关。）

另一个可能导致此异常的原因是compare方法给出的结果不一致，因为任务对象正在更改。事实上，看起来（至少）改变重试计数在语义上是有意义的。如果有另一个线程正在更改任务，则在当前线程进行排序时可能会影响排序的字段…，这可能会导致IllegalArgumentException。

（比较契约的一部分是，在对集合进行排序时，成对排序不会改变。）

然后你会这样说：

我使用＜code＞ImmutableSet。copyOf在排序之前复制列表，我在java.util.concurrent.locks.ReadWriteLock中的读锁下执行此操作。

复制集合不会复制集合的元素。这是一个浅拷贝。因此，您最终会得到两个包含相同对象的集合。如果另一个线程改变了任何对象（例如通过增加重试次数），这可能会改变对象的顺序。

锁定确保您有一致的副本，但这不是问题所在。

解决办法是什么？我可以想到几个：

>

您可以在复制和排序时锁定某些对象以阻止对集合和元素对象的所有更新。

你可以深度复制收藏；i、 e.创建一个包含原始集合元素副本的新集合。

您可以创建包含与排序相关的Task对象的字段快照的轻量级对象；例如

public class Key implements Comparable<Key> {
    private int retries;
    private DateTime creation;
    private DateTime load;
    private Task task;

    public Key(Task task) {
        this.task = task;
        this.retries = task.getRetryCount();
        ...
    }

    public int compareTo(Key other) {
        // compare using retries, creation, load
    }
}

这具有潜在的优势，即您复制的信息更少，并且您可以从Key对象的排序集合转到原始的任务对象。

请注意，所有这些备选方案都比您当前所做的慢。我认为没有办法避免这种情况。