java – ArrayList-Speicherzuordnung, generationsübergreifendes Referenz-GC-Problem

Question

Wie hoch ist die Speicherzuordnung von ArrayList in JVM?

假设List<BigObject> list = new ArrayList<>(); 

private static class BigObject{
        private byte[] foo;

        BigObject(){
            foo = new byte[20 * 1024];
        }
    }

Fügen Sie BigObject kontinuierlich hinzu. Ist die Referenzbeziehung wie folgt?

Dann tritt ygc auf? Wenn das ArrayList-Objekt nicht in den alten Bereich gelangt, gibt es dann keine generationsübergreifende Referenz? Wenn es eingegeben wird, wird obj = new BigObject () in der neuen Generation nach ygc zugewiesen, und dann list.add (obj). Wäre da nicht ein Verweis auf den alt-> jungen Bereich? Wie hoch ist die Speicherzuweisung? wie?

Der Ursprung des Problems

Führen Sie den folgenden Code aus:
Parameter: /jdk1.7.0_79.jdk/bin/java -Xmx500M -Xms500M -Xmn200M -XX:+UseConcMarkSweepGC -XX:+UseCMSInitiatingOccupancyOnly -XX:CMSInitiatingOccupancyFraction=90. -XX:+PrintGCApplication ConcurrentTime -XX : +PrintGCApplicationStoppedTime -XX:+PrintHeapAtGC -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -XX:+PrintGCDateStamps -verbose:gc -XX:+PrintGCDetails -Xloggc:/Users/*/temp/test.gc.log

import java.util.ArrayList;
import java.util.List;

/**
 * @author ***
 * @time 2017-04-19-11:14
 */
public class CrossReference {
    private static int unit = 20 * 1024;

    public static void main(String[] args) {
        allocate();

        try {
            Thread.sleep(1000);
            System.out.println("allocate end************");
            Thread.sleep(100000);
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    private static void allocate(){
        List<BigObject> list = new ArrayList<>();
        int size = 1024 * 1024 * 400;
        int len = size / unit;

        for( int i = 0; i < len; i++){

            BigObject bigObject = new BigObject();
            list.add(bigObject);
        }
    }

    private static class BigObject{
        private byte[] foo;

        BigObject(){
            foo = new byte[unit]; //
        }
    }


}

Ein Blick auf gc.log zeigt, dass nach der Ausführung der allocate()-Methode der alte Bereich immer noch zu mehr als 90 % belegt ist und CMS GC kontinuierlich ausgeführt wird, aber nicht recycelt werden kann.

Answer 1

我最近看到两篇文章，应该对你有用：

http://zhuanlan.51cto.com/art...
http://zhuanlan.51cto.com/art...