JIT优化和弱引用

我检查了您的源代码，当JIT编译与您的方法“ updateOrdering”相对应的方法时，我得到了NullPointerException，并且在排序期间发生了GC。

但是当Collections.sort无论有无包装= null时，我都收到NullPointerException。这可能发生在我的示例源代码与您的示例源代码之间的差异，或Java版本的差异。我将检查您是否告诉Java版本。

我使用低于版本的Java。

Java版本“ 1.7.0_40”
Java（TM）SE运行时环境（内部版本1.7.0_40-b43）
Java HotSpot（TM）64位服务器VM（内部版本24.0-b56，混合模式）

如果您想欺骗JIT编译，则以下代码插入您的源代码，而不是unwrapped = null（eg）。然后，JIT编译不会消除未包装的代码。

long value = unwrapped.size() * unwrapped.size();
if(value * value % 3 == 1) {
  //Because value * value % 3 always is 1 or 0, this code can't reach. 
  //Insert into this the source code that use unwrapped array, for example, show unwrapped array.
}

我的考试结果如下。

• 如果JIT没有优化与updateOrdering相对应的方法，则不会发生NullPointerException。
• 如果JIT优化了我的方法，则NullPointerException会在某个时刻发生。
• 如果JIT优化我的方法，插入上述源代码作弊的JIT编译器，则不会发生NullPointerException。

因此，我（和您）建议JIT优化消除消除未包装的代码，然后发生NullPointerException。

顺便说一句，如果要显示JIT编译器优化，请使用-XX：+ PrintCompilation调用Java。
如果要显示GC，请使用-verbose：gc。

仅供参考，下面是我的示例源代码。

public class WeakSampleMain {
    private static List<WeakReference<Integer>> weakList = new LinkedList<>();
    private static long sum = 0;
    public static void main(String[] args) {
        System.out.println("start");
        int size = 1_000_000;
        for(int i = 0; i < size; i++) {
            Integer value = Integer.valueOf(i);
            weakList.add(new WeakReference<Integer>(value));
        }
        for(int i = 0; i < 10; i++) {
            jitSort();
        }
        GcTask gcTask = new GcTask();
        Thread thread = new Thread(gcTask);
        thread.start();
        for(int i = 0; i < 100000; i++) {
            jitSort();
        }
        thread.interrupt();
        System.out.println(sum);
    }

    public static void jitSort() {
        List<Integer> unwrappedList = unwrapped();
        removeNull();
        Collections.sort(weakList, 
                new Comparator<WeakReference<Integer>>() {

                    @Override
                    public int compare(WeakReference<Integer> o1,
                            WeakReference<Integer> o2) {
                        return Integer.compare(o1.get(), o2.get());
                    }
        }
                );
        for(int i = 0; i < Math.min(weakList.size(), 1000); i++) {
            sum += weakList.get(i).get();
        }
        unwrappedList = null;
//          long value = (sum + unwrappedList.size());
//          if((value * value) % 3 == 2) {
//              for(int i = 0; i < unwrappedList.size(); i++) {
//                  System.out.println(unwrappedList.get(i));
//              }
//          }
    }

    public static List<Integer> unwrapped() {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(WeakReference<Integer> ref : weakList) {
            Integer i = ref.get();
            if(i != null) {
                list.add(i);
            }
        }
        return list;
    }

    public static void removeNull() {
        Iterator<WeakReference<Integer>> itr = weakList.iterator();
        while(itr.hasNext()) {
            WeakReference<Integer> ref = itr.next();
            if(ref.get() == null) {
                itr.remove();
            }
        }
    }

    public static class GcTask implements Runnable {
        private volatile int result = 0;
        private List<Integer> stockList = new ArrayList<Integer>();
        public void run() {
            while(true) {
                if(Thread.interrupted()) {
                    break;
                }
                int size = 1000000;
                stockList = new ArrayList<Integer>(size);
                for(int i = 0; i < size; i++) {
                    stockList.add(new Integer(i));
                }
                if(System.currentTimeMillis() % 1000 == 0) {
                    System.out.println("size : " + stockList.size());
                }
            }
        }

        public int getResult() {
            return result;
        }
    }
}