最近使用者報告了一個crash，錯誤堆疊如下：

java.lang.IllegalArgumentException: Comparison method violates its general contract!
	at java.util.TimSort.mergeHi(TimSort.java:864)
	at java.util.TimSort.mergeAt(TimSort.java:481)
	at java.util.TimSort.mergeForceCollapse(TimSort.java:422)
	at java.util.TimSort.sort(TimSort.java:219)
	at java.util.TimSort.sort(TimSort.java:169)
	at java.util.Arrays.sort(Arrays.java:2010)
	at java.util.Collections.sort(Collections.java:1883)
	at com.xxx.model.c.a(Unknown Source)
	at com.xxx.view.de.doInBackground(Unknown Source)
	at android.os.AsyncTask$2.call(AsyncTask.java:288)
	at java.util.concurrent.FutureTask.run(FutureTask.java:237)
	at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:231)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1112)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:587)
	at java.lang.Thread.run(Thread.java:841)
 

這個app運行了一年多還是第一次碰到這個crash。TimSort又是什麼鬼？

簡單的講TimSort是一個優化後的merge sort，比原來的merge sort更穩定、更快。

兩大特點：

1. 對已接近排序和倒序的陣列排序速度異常快。

2. 最差情況仍是O(n*log(n))

JDK7的排序演算法實現改為TimSort。java.util.TimSort的類註釋。

/**
 * A stable, adaptive, iterative mergesort that requires far fewer than
 * n lg(n) comparisons when running on partially sorted arrays, while
 * offering performance comparable to a traditional mergesort when run
 * on random arrays.  Like all proper mergesorts, this sort is stable and
 * runs O(n log n) time (worst case).  In the worst case, this sort requires
 * temporary storage space for n/2 object references; in the best case,
 * it requires only a small constant amount of space.
 *
 * This implementation was adapted from Tim Peters's list sort for
 * Python, which is described in detail here:
 *
 *   http://svn.python.org/projects/python/trunk/Objects/listsort.txt
 *
 * Tim's C code may be found here:
 *
 *   http://svn.python.org/projects/python/trunk/Objects/listobject.c
 *
 * The underlying techniques are described in this paper (and may have
 * even earlier origins):
 *
 *  "Optimistic Sorting and Information Theoretic Complexity"
 *  Peter McIlroy
 *  SODA (Fourth Annual ACM-SIAM Symposium on Discrete Algorithms),
 *  pp 467-474, Austin, Texas, 25-27 January 1993.
 *
 * While the API to this class consists solely of static methods, it is
 * (privately) instantiable; a TimSort instance holds the state of an ongoing
 * sort, assuming the input array is large enough to warrant the full-blown
 * TimSort. Small arrays are sorted in place, using a binary insertion sort.
 *
 * @author Josh Bloch
 */
 

具體演算法原理這裡不做細究，有興趣的可以研究一下上面註釋中的連結或者論文。

解決方法為在實現Comparator<T>介面時，必須嚴格遵循實現約束，否則會導致執行時異常。 

具體約束為：

1. sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. 
2. ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.
3. compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.

錯誤示例：（JDK6下執行正常，JDK7下會crash）

public class XXXComparator implements Comparator<SomeModel> {

    // 當lhs==rhs時，compare(lhs,rhs)== -1, compare(rhs, lhs)==-1 違背約束1
    @Override
public int compare(SomeModel lhs, SomeModel rhs) {
        if (rhs.value < lhs.value) {
            return 1;
        } else {
            return -1;
        }
    }

}

參考: