JIT优化和弱引用

Question

我有以下代码:

private final List<WeakReference<T>> slaves;

public void updateOrdering() {
  // removes void weak references 
  // and ensures that weak references are not voided 
  // during subsequent sort 
  List<T> unwrapped = unwrap();
  assert unwrapped.size() == this.slaves.size();
  // **** could be reimplemented without using unwrap() ****
  Collections.sort(this.slaves, CMP_IDX_SLV);
  unwrapped = null;// without this, ....
}

方法unwrap()只是创建列表T由弱引用中所引用的slaves ,并作为一个副作用消除了弱引用引用null中slaves.然后是依赖每个slaves参考成员的那种T; 否则代码产生一个NullPointerException.

由于unwrapped在每个T中都有一个参考slaves,在排序过程中没有GC消除了T.最后,unwrapped = null取消了对展开的参考,因此再次释放GC.似乎工作得很好.

现在我的问题:

如果我在一些负载下运行许多测试时删除了unwrapped = null;这个结果NullPointerExceptions.我怀疑JIT消除了List<T> unwrapped = unwrap(); ,因此GC T在排序过程中适用于奴隶.

你有其他解释吗？如果您同意我的意见,这是JIT中的错误吗？

我个人认为这unwrapped = null不应该是必要的,因为unwrapped一旦updateOrdering()返回就会从框架中删除.是否存在可以优化和不优化的规范？

或者我是以错误的方式做事的？我有想法修改它允许弱引用的比较器null.你觉得怎么样？

谢谢你的建议.

加入(1)

现在我想添加一些缺少的信息:首先是Java版本:java版本"1.7.0_45"OpenJDK运行时环境(IcedTea 2.4.3)(suse-8.28.3-x86_64)OpenJDK 64位服务器VM(构建) 24.45-b08,混合模式)

然后有人想看方法展开

private synchronized List<T> unwrap() {
List<T> res = new ArrayList<T>();
T cand;
WeakReference<T> slvRef;
Iterator<WeakReference<T>> iter = this.slaves.iterator();
while (iter.hasNext()) {
    slvRef = iter.next();
    cand = slvRef.get();
    if (cand == null) {
    iter.remove();
    continue;
    }
    assert cand != null;
    res.add(cand);
} // while (iter.hasNext())

return res;
}

请注意,在迭代时,将删除void引用.事实上我用这个方法取代了

private synchronized List<T> unwrap() {
List<T> res = new ArrayList<T>();
for (T cand : this) {
    assert cand != null;
    res.add(cand);
}

return res;
}

使用我自己的迭代器,但在功能上这应该是相同的.

然后有人在堆栈跟踪中徘徊.这是一块.

 java.lang.NullPointerException: null
 at WeakSlaveCollection$IdxComparator.compare(WeakSlaveCollection.java:44)
 at WeakSlaveCollection$IdxComparator.compare(WeakSlaveCollection.java:40)
 at java.util.TimSort.countRunAndMakeAscending(TimSort.java:324)
 at java.util.TimSort.sort(TimSort.java:189)
 at java.util.TimSort.sort(TimSort.java:173)
 at java.util.Arrays.sort(Arrays.java:659)
 at java.util.Collections.sort(Collections.java:217)
 at WeakSlaveCollection.updateOrdering(WeakSlaveCollection.java:183)

它指向比较器,返回线.

static class IdxComparator 
    implements Comparator<WeakReference<? extends XSlaveNumber>> {
    public    int compare(WeakReference<? extends XSlaveNumber> slv1, 
              WeakReference<? extends XSlaveNumber> slv2) {
        return slv2.get().index()-slv1.get().index();
    }
} // class IdxComparator 

最后,

 private final static IdxComparator CMP_IDX_SLV = new IdxComparator();

是一个重要的常数.

加入(2)

现在观察到即使在updateOrdering()中存在'unwrapped = null',NPE也会发生.

如果在jit优化之后没有严格的引用,则java运行时可能会删除弱引用.源代码似乎并不重要.

我通过以下方式解决了问题:

public void updateOrdering() {
Collections.sort(this.slaves, CMP_IDX_SLV);
}

没有插入任何装饰以防止奴隶被垃圾收集并且CMP_IDX_SLV中的比较器被启用以处理对null的弱引用:

    public    int compare(WeakReference<? extends XSlaveNumber> slv1, 
              WeakReference<? extends XSlaveNumber> slv2) {
    XSlaveNumber sSlv1 = slv1.get();
    XSlaveNumber sSlv2 = slv2.get();
    if (sSlv1 == null) {
    return sSlv2 == null ? 0 : -1;
    }
    if (sSlv2 == null) {
    return +1;
    }
    assert sSlv1 != null && sSlv2 != null;

    return sSlv2.index()-sSlv1.index();
    }

作为副作用,排序基础列表List> slave; 将void弱引用放在列表的末尾,以后可以在其中收集.

Answer 1

我检查了你的源代码，当 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（例如）。然后，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 optimze 消除未包装的代码，然后发生 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;
        }
    }
}