JIT-оптимизация и слабые ссылки

Я изучаю ваш исходный код и получаю исключение NullPointerException, когда JIT-компилирует мой метод, соответствующий вашему методу «updateOrdering», и во время сортировки происходит GC.

Но я получил NullPointerException, когда Collections.sort независимо от того, с развернутым или без него = null. Возможно, это связано с разницей между исходным кодом моего примера и вашим или с разницей в версии Java. Я проверю, если вы сообщите версию Java.

Я использую java ниже версии.

java version "1.7.0_40"
Java(TM) SE Runtime Environment (build 1.7.0_40-b43)
Java HotSpot(TM) 64-Bit Server VM (build 24.0-b56, mixed mode)

Если вы хотите обмануть компиляцию JIT, приведенный ниже код вместо этого вставит ваш исходный код unwrapped = null (например). Тогда 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.
}

Результат моего обследования ниже.

• If JIT don't optimize my method corresponding to updateOrdering, no NullPointerException occurs.
• If JIT optimize my method, then NullPointerException occurs at some point.
• If JIT optimize my method inserting the above source code cheating JIT compiler, then no NullPointerException occurs.

Итак, я (и вы) предлагаете JIT optimze исключить развернутый код, тогда возникает NullPointerException.

Кстати, если вы хотите показать оптимизацию компилятора JIT, вы вызываете java с помощью -XX:+PrintCompilation.
Если вы хотите показать 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;
        }
    }
}

Начиная с Java 9, правильный способ предотвратить отбрасывание JIT unwrapped — использовать Reference.reachabilityFence:

public void updateOrdering() {
  List<T> unwrapped = unwrap();
  Collections.sort(this.slaves, CMP_IDX_SLV);
  Reference.reachabilityFence(unwrapped);
}

Наличие вызова reachabilityFence приводит к тому, что unwrapped считается сильно достижимым до вызова, предотвращая сбор unwrapped или его элементов до завершения sort. (Странный способ, которым эффекты reachabilityFence, кажется, распространяются назад во времени, заключается в том, что он ведет себя в основном как JIT-директива.) Без reachabilityFence unwrapped можно собрать, как только JIT сможет доказать, что к ней никогда больше не будет доступа, даже если переменная все еще в области.

Ваш вопрос

Если я удалю unwrapped = null; это приводит к NullPointerException при выполнении многих тестов под некоторой нагрузкой.

Насколько я понимаю, я не думаю, что unwrapped = null; имеет какое-либо значение.
Да, я также читал, что создание objects = null иногда увеличивает вероятность того, что объект, на который ссылаются, будет подвергнут сборке мусора, но я не думаю, что здесь это имеет значение, потому что один раз метод заканчивается, область unwrapped заканчивается и подходит для GC'ed, а в вашей функции сортировка Collections.sort(this.slaves, CMP_IDX_SLV); выполняется до unwrapped = null;, поэтому нет смысла получать NPE при их добавлении или удалении.

Я думаю, что это просто совпадение, что вы получаете NPE, я считаю, что если вы снова запустите тест, вы также получите NPE с этим утверждением.

Если вы читали документацию по Java

Слабые ссылочные объекты, которые не препятствуют тому, чтобы их референты были финализированы, финализированы, а затем восстановлены. Слабые ссылки чаще всего используются для реализации канонических отображений.
Предположим, что сборщик мусора определяет в определенный момент времени, что объект слабо достижим. В это время он атомарно удалит все слабые ссылки на этот объект и все слабые ссылки на любые другие слабо достижимые объекты, из которых этот объект доступен через цепочку сильных и мягких ссылок. В то же время он объявит все ранее слабо достижимые объекты финализируемыми. В то же время или позже он поставит в очередь те недавно очищенные слабые ссылки, которые зарегистрированы в очередях ссылок.

Так что вполне возможно, что когда вы создавали List из unwrap(), некоторые объекты могли быть помечены finalized, а пока ваш Collection.sort работает, некоторым WeakRefrence присваивается null. И точка зрения, заявленная Mattias Buelens, совершенно верна, вы всегда будете проиграть в борьбе с компилятором.

Если вы согласны со мной, это ошибка в JIT?

Нет, конечно, я с вами совершенно не согласен.

У меня есть идея изменить comparator, чтобы он разрешал слабые ссылки на null. Что ты об этом думаешь?

Я думаю, что это решит вашу единственную проблему NPE, но ваше требование removes void weak references and ensures that weak references are not voided during subsequent sort не удовлетворено.
Лучше попробуйте еще раз вызвать unwrap, это уменьшит окно для NPE почти до нуля,

List<T> unwrapped = unwrap();
unwrapped = unwrap(); //Again to eliminate the chances for NPE as now we would have 
           //already made strong refrences to all objects which have not been `null`