我有以下代码:

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，混合模式)

然后有人想看方法 unwrap

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;
}

请注意，在迭代时，无效引用将被删除。 事实上，我用

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。

弱引用可能会被 java 运行时删除 如果 在 jit 优化之后 没有严格的引用。 源代码似乎一点也不重要。

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

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> slaves 进行排序； 将 void weak references 放在列表的末尾，以便稍后收集。

最佳答案

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

但是当 Collections.sort 有或没有 unwrapped = null 时，我得到了 NullPointerException。 这可能是我的示例源代码与您的示例源代码之间存在差异，或者 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)

If you want to cheat on JIT compilation, the below code insert your source code instead unwrapped = null(e.g.). Then, JIT compilation doesn't eliminates unwrapped code.

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;
        }
    }
}

关于java - JIT 优化和弱引用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20814607/