Java8 JVM内存结构

基本结构与之前类似,只是Java8取消了之前的“永久代”,取而代之的是“元空间”——Metaspace,两者本质是一样的。“永久代”使用的是JVM的堆内存,而“元空间”是直接使用的本机物理内存。

GC Roots

如果判断一个对象可以被回收?

引用计数算法

维护一个计数器,如果有对该对象的引用,计数器+1,反之-1。无法解决循环引用的问题。

可达性分析算法

从一组名为“GC Roots”的根节点对象出发,向下遍历。那些没有被遍历到、与GC Roots形成通路的对象,会被标记为“回收”。

哪些对象可以作为GC Roots?

  1. 虚拟机栈(栈帧中的局部变量)中引用的对象。
  2. 本地方法栈(native)中引用的对象。
  3. 方法区中常量引用的对象。
  4. 方法区中类静态属性引用的对象。

JVM参数

JVM 三种类型参数

标配参数

比如-version-help-showversion等,几乎不会改变。

X参数

用得不多,比如-Xint,解释执行模式;-Xcomp,编译模式;-Xmixed,开启混合模式(默认)。

XX参数

重要,用于JVM调优。

JVM XX参数

布尔类型

公式-XX:+某个属性-XX:-某个属性,开启或关闭某个功能。比如-XX:+PrintGCDetails,开启GC详细信息。

KV键值类型

公式-XX:属性key=值value。比如-XX:Metaspace=128m-XX:MaxTenuringThreshold=15

JVM Xms/Xmx参数

-Xms-Xmx十分常见,用于设置初始堆大小最大堆大小。第一眼看上去,既不像X参数,也不像XX参数。实际上-Xms等价于-XX:InitialHeapSize-Xmx等价于-XX:MaxHeapSize。所以-Xms-Xmx属于XX参数。

JVM 查看参数

查看某个参数

使用jps -l配合jinfo -flag JVM参数 pid 。先用jsp -l查看java进程,选择某个进程号。

17888 org.jetbrains.jps.cmdline.Launcher
5360 org.jetbrains.idea.maven.server.RemoteMavenServer
18052 demo3.demo3

jinfo -flag PrintGCDetails 18052可以查看18052 Java进程的PrintGCDetails参数信息。

-XX:-PrintGCDetails

查看所有参数

使用jps -l配合jinfo -flags pid可以查看所有参数。

也可以使用java -XX:+PrintFlagsInitial

[Global flags]
     intx ActiveProcessorCount                      = -1            {product}
    uintx AdaptiveSizeDecrementScaleFactor          = 4             {product}
    uintx AdaptiveSizeMajorGCDecayTimeScale         = 10            {product}
    uintx AdaptiveSizePausePolicy                   = 0             {product}
······
    uintx YoungPLABSize                             = 4096          {product}
     bool ZeroTLAB                                  = false         {product}
     intx hashCode                                  = 5             {product}

查看修改后的参数

使用java -XX:PrintFlagsFinal可以查看修改后的参数,与上面类似。只是修改过后是:=而不是=

查看常见参数

如果不想查看所有参数,可以用-XX:+PrintCommandLineFlags查看常用参数。

-XX:InitialHeapSize=132375936 -XX:MaxHeapSize=2118014976 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC

JVM 常用参数

-Xmx/-Xms

最大和初始堆大小。最大默认为物理内存的¼,初始默认为物理内存的1/64。

-Xss

等价于-XX:ThresholdStackSize。用于设置单个栈的大小,系统默认值是0,不代表栈大小为0。而是根据操作系统的不同,有不同的值。比如64位的Linux系统是1024K,而Windows系统依赖于虚拟内存。

-Xmn

新生代大小,一般不调。

-XX:MetaspaceSize

设置元空间大小。

-XX:+PrintGCDetails

输出GC收集信息,包含GCFull GC信息。

-XX:SurvivorRatio

新生代中,Eden区和两个Survivor区的比例,默认是8:1:1。通过-XX:SurvivorRatio=4改成4:1:1

-XX:NewRatio

老生代和新年代的比列,默认是2,即老年代占2,新生代占1。如果改成-XX:NewRatio=4,则老年代占4,新生代占1。

-XX:MaxTenuringThreshold

新生代设置进入老年代的时间,默认是新生代逃过15次GC后,进入老年代。如果改成0,那么对象不会在新生代分配,直接进入老年代。

四大引用

以下Demo都需要设置-Xmx-Xms,不然系统默认很大,很难演示。

强引用

使用new方法创造出来的对象,默认都是强引用。GC的时候,就算内存不够,抛出OutOfMemoryError也不会回收对象,死了也不回收

public class StrongReferenceDemo {
    public static void main(String[] args) {
        Object o1=new Object();
        Object o2=new Object();
        o1=null;
        System.gc();
        System.out.println(o2);
    }
}

软引用

需要用Object.Reference.SoftReference来显示创建。如果内存够,GC的时候不回收内存不够则回收。常用于内存敏感的应用,比如高速缓存。

import java.lang.ref.SoftReference;

public class SoftReferenceDemo {
    public static void main(String[] args) {
        softRef_Memory_Enough();
        System.out.println("Not Enough");
        softRef_Memory_NotEnough();
    }

    private static void softRef_Memory_Enough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());
        System.out.println("===========");
        o1 = null;
        System.gc();
        System.out.println(o1);
        System.out.println(softReference.get());
    }

    private static void softRef_Memory_NotEnough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());
        System.out.println("===========");
        o1 = null;
        System.gc();

        try {
            byte[] bytes = new byte[30 * 1024 * 1024];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(o1);
            System.out.println(softReference.get());
        }
    }
}

弱引用

需要用Object.Reference.WeakReference来显示创建。无论内存够不够,GC的时候都回收,也可以用在高速缓存上。

import java.lang.ref.WeakReference;

public class WeakReferenceDemo {
    public static void main(String[] args) {
        Object o1 = new Object();
        WeakReference<Object> weakReference = new WeakReference<>(o1);
        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println("==========");
        o1 = null;
        System.gc();
        System.out.println(o1);
        System.out.println(weakReference.get());
    }
}

WeakHashMap

传统的HashMap就算key==null了,也不会回收键值对。但是如果是WeakHashMap,一旦内存不够用时,且key==null时,会回收这个键值对。

import java.util.HashMap;
import java.util.WeakHashMap;

public class WeakHashMapDemo {
    public static void main(String[] args) {
        myHashMap();
        System.out.println("===============");
        myWeakHashMap();
    }

    private static void myHashMap() {
        HashMap<Integer, String> map = new HashMap<>();
        Integer key = 1;
        String value = "HashMap";
        map.put(key, value);
        System.out.println(map);

        key = null;
        System.out.println(map);
        System.gc();
        System.out.println(map + "\t" + map.size());
    }

    private static void myWeakHashMap() {
        WeakHashMap<Integer, String> map = new WeakHashMap<>();
        Integer key = 2;
        String value = "WeakHashMap";
        map.put(key, value);
        System.out.println(map);

        key = null;
        System.out.println(map);

        System.gc();
        System.out.println(map + "\t" + map.size());
    }
}

虚引用

软应用和弱引用可以通过get()方法获得对象,但是虚引用不行。虚引形同虚设,在任何时候都可能被GC,不能单独使用,必须配合引用队列(ReferenceQueue)来使用。设置虚引用的唯一目的,就是在这个对象被回收时,收到一个通知以便进行后续操作,有点像Spring的后置通知。

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference phantomReference = new PhantomReference(o1, referenceQueue);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("===========");

        o1 = null;
        System.gc();
        Thread.sleep(500);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());
    }
}

引用队列

弱引用、虚引用被回收后,会被放到引用队列里面,通过poll方法可以得到。关于引用队列和弱、虚引用的配合使用。

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

public class ReferenceQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        WeakReference<Object> weakReference = new WeakReference<>(o1, referenceQueue);
        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("==========");
        o1 = null;
        System.gc();
        Thread.sleep(500);
        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());

    }
}

OutOfMemoryError

StackOverflowError

栈满会抛出该错误。无限递归就会导致StackOverflowError,是java.lang.Throwablejava.lang.Errorjava.lang.VirtualMachineError下的错误。

OOM—Java head space

栈满会抛出该错误。

OOM—GC overhead limit exceeded

这个错误是指:GC的时候会有“Stop the World",STW越小越好,正常情况是GC只会占到很少一部分时间。但是如果用超过98%的时间来做GC,而且收效甚微,就会被JVM叫停。下例中,执行了多次Full GC,但是内存回收很少,最后抛出了OOM:GC overhead limit exceeded错误。

[GC (Allocation Failure) [PSYoungGen: 2048K->496K(2560K)] 2048K->960K(9728K), 0.0036555 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2544K->489K(2560K)] 3008K->2689K(9728K), 0.0060306 secs] [Times: user=0.08 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 2537K->512K(2560K)] 4737K->4565K(9728K), 0.0050620 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2560K->496K(2560K)] 6613K->6638K(9728K), 0.0064025 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 

[Full GC (Ergonomics) [PSYoungGen: 2048K->860K(2560K)] [ParOldGen: 6264K->7008K(7168K)] 8312K->7869K(9728K), [Metaspace: 3223K->3223K(1056768K)], 0.1674947 secs] [Times: user=0.63 sys=0.00, real=0.17 secs] 
[Full GC (Ergonomics) [PSYoungGen: 2048K->2006K(2560K)] [ParOldGen: 7008K->7008K(7168K)] 9056K->9015K(9728K), [Metaspace: 3224K->3224K(1056768K)], 0.1048666 secs] [Times: user=0.45 sys=0.00, real=0.10 secs] 
[Full GC (Ergonomics) [PSYoungGen: 2047K->2047K(2560K)] [ParOldGen: 7082K->7082K(7168K)] 9130K->9130K(9728K), [Metaspace: 3313K->3313K(1056768K)], 0.0742516 secs] [Times: user=0.28 sys=0.00, real=0.07 secs] 

·······

[Full GC (Ergonomics) [PSYoungGen: 2047K->2047K(2560K)] [ParOldGen: 7084K->7084K(7168K)] 9132K->9132K(9728K), [Metaspace: 3313K->3313K(1056768K)], 0.0738461 secs] [Times: user=0.36 sys=0.02, real=0.07 secs] 

Exception in thread "main" [Full GC (Ergonomics) [PSYoungGen: 2047K->0K(2560K)] [ParOldGen: 7119K->647K(7168K)] 9167K->647K(9728K), [Metaspace: 3360K->3360K(1056768K)], 0.0129597 secs] [Times: user=0.11 sys=0.00, real=0.01 secs] 
java.lang.OutOfMemoryError: GC overhead limit exceeded
    at java.lang.Integer.toString(Integer.java:401)
    at java.lang.String.valueOf(String.java:3099)
    at jvm.GCOverheadDemo.main(GCOverheadDemo.java:12)

OOM—GC Direct buffer memory

在写NIO程序的时候,会用到ByteBuffer来读取和存入数据。与Java堆的数据不一样,ByteBuffer使用native方法,直接在堆外分配内存。当堆外内存(也即本地物理内存)不够时,就会抛出这个异常。

import java.nio.ByteBuffer;

//-Xms10m -Xmx10m -XX:MaxDirectMemorySize=5m -XX:+PrintGCDetails
public class DirectBufferMemoryDemo {
    public static void main(String[] args) {
        System.out.println("配置的maxDirectMemory: " + (sun.misc.VM.maxDirectMemory() / (double) 1024 / 1024) + "MB");
        try {
            Thread.sleep(300);
        } catch (Exception e) {
            e.printStackTrace();
        }
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(6 * 1024 * 1024);
    }
}

OOM—unable to create new native thread

在高并发应用场景时,如果创建超过了系统默认的最大线程数,就会抛出该异常。Linux单个进程默认不能超过1024个线程。解决方法要么降低程序线程数,要么修改系统最大线程数vim /etc/security/limits.d/90-nproc.conf

OOM—Metaspace

元空间满了就会抛出这个异常。

JVM垃圾收集器

四大垃圾收集算法

标记整理

标记清除

复制算法

分代收集算法

准确来讲,跟前面三种算法有所区别。分代收集算法就是根据对象的年代,采用上述三种算法来收集。

  1. 对于新生代:每次GC都有大量对象死去,存活的很少,常采用复制算法,只需要拷贝很少的对象。
  2. 对于老年代:常采用标整或者标清算法。

四种垃圾收集器

Java 8可以将垃圾收集器分为四类。

串行收集器Serial

为单线程环境设计且只使用一个线程进行GC,会暂停所有用户线程,不适用于服务器。就像去餐厅吃饭,只有一个清洁工在打扫。

并行收集器Parrallel

使用多个线程并行地进行GC,会暂停所有用户线程,适用于科学计算、大数据后台,交互性不敏感的场合。多个清洁工同时在打扫。

并发收集器CMS

用户线程和GC线程同时执行(不一定是并行,交替执行),GC时不需要停顿用户线程,互联网公司多用,适用对响应时间有要求的场合。清洁工打扫的时候,也可以就餐。

G1收集器

对内存的划分与前面3种很大不同,将堆内存分割成不同的区域,然后并发地进行垃圾回收。

默认垃圾收集器

默认收集器有哪些?

SerialParallelConcMarkSweep(CMS)、ParNewParallelOldG1。还有一个SerialOld,快被淘汰了。

查看默认垃圾修改器

使用java -XX:+PrintCommandLineFlags即可看到,Java 8默认使用-XX:+UseParallelGC

-XX:InitialHeapSize=132375936 -XX:MaxHeapSize=2118014976 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC

七大垃圾收集器

体系结构

SerialParallel ScavengeParNew用户回收新生代;SerialOldParallelOldCMS用于回收老年代。而G1收集器,既可以回收新生代,也可以回收老v年代。

连线表示可以搭配使用,红叉表示不推荐一同使用,比如新生代用Serial,老年代用CMS

Serial收集器

年代最久远,是Client VM模式下的默认新生代收集器,使用复制算法优点:单个线程收集,没有线程切换开销,拥有最高的单线程GC效率。缺点:收集的时候会暂停用户线程。

使用-XX:+UseSerialGC可以显式开启,开启后默认使用Serial+SerialOld的组合。

ParNew收集器

也就是Serial的多线程版本,GC的时候不再是一个线程,而是多个,是Server VM模式下的默认新生代收集器,采用复制算法

使用-XX:+UseParNewGC可以显式开启,开启后默认使用ParNew+SerialOld的组合。但是由于SerialOld已经过时,所以建议配合CMS使用。

Parallel Scavenge收集器

ParNew收集器仅在新生代使用多线程收集,老年代默认是SerialOld,所以是单线程收集。而Parallel Scavenge在新、老两代都采用多线程收集。Parallel Scavenge还有一个特点就是吞吐量优先收集器,可以通过自适应调节,保证最大吞吐量。采用复制算法

使用-XX:+UseParallelGC可以开启, 同时也会使用ParallelOld收集老年代。其它参数,比如-XX:ParallelGCThreads=N可以选择N个线程进行GC,-XX:+UseAdaptiveSizePolicy使用自适应调节策略。

SerialOld收集器

Serial的老年代版本,采用标整算法。JDK1.5之前跟Parallel Scavenge配合使用,现在已经不了,作为CMS的后备收集器。

ParallelOld收集器

Parallel的老年代版本,JDK1.6之前,新生代用Parallel而老年代用SerialOld,只能保证新生代的吞吐量。JDK1.8后,老年代改用ParallelOld

使用-XX:+UseParallelOldGC可以开启, 同时也会使用Parallel收集新生代。

CMS收集器

并发标记清除收集器,是一种以获得最短GC停顿为目标的收集器。适用在互联网或者B/S系统的服务器上,这类应用尤其重视服务器的响应速度,希望停顿时间最短。是G1收集器出来之前的首选收集器。使用标清算法。在GC的时候,会与用户线程并发执行,不会停顿用户线程。但是在标记的时候,仍然会STW

使用-XX:+UseConcMarkSweepGC开启。开启过后,新生代默认使用ParNew,同时老年代使用SerialOld作为备用。

过程

  1. 初始标记:只是标记一下GC Roots能直接关联的对象,速度很快,需要STW
  2. 并发标记:主要标记过程,标记全部对象,和用户线程一起工作,不需要STW。
  3. 重新标记:修正在并发标记阶段出现的变动,需要STW
  4. 并发清除:和用户线程一起,清除垃圾,不需要STW。

优缺点

优点:停顿时间少,响应速度快,用户体验好。

缺点

  1. 对CPU资源非常敏感:由于需要并发工作,多少会占用系统线程资源。
  2. 无法处理浮动垃圾:由于标记垃圾的时候,用户进程仍然在运行,无法有效处理新产生的垃圾。
  3. 产生内存碎片:由于使用标清算法,会产生内存碎片。

G1收集器

G1收集器与之前垃圾收集器的一个显著区别就是——之前收集器都有三个区域,新、老两代和元空间。而G1收集器只有G1区和元空间。而G1区,不像之前的收集器,分为新、老两代,而是一个一个Region,每个Region既可能包含新生代,也可能包含老年代。

G1收集器既可以提高吞吐量,又可以减少GC时间。最重要的是STW可控,增加了预测机制,让用户指定停顿时间。

使用-XX:+UseG1GC开启,还有-XX:G1HeapRegionSize=n-XX:MaxGCPauseMillis=n等参数可调。

特点

  1. 并行和并发:充分利用多核、多线程CPU,尽量缩短STW。
  2. 分代收集:虽然还保留着新、老两代的概念,但物理上不再隔离,而是融合在Region中。
  3. 空间整合G1整体上看是标整算法,在局部看又是复制算法,不会产生内存碎片。
  4. 可预测停顿:用户可以指定一个GC停顿时间,G1收集器会尽量满足。

过程

CMS类似。

  1. 初始标记。
  2. 并发标记。
  3. 最终标记。
  4. 筛选回收。

附—Linux相关指令

top

主要查看%CPU%MEM,还有load averageload average后面的三个数字,表示系统1分钟、5分钟、15分钟的平均负载值。如果三者平均值高于0.6,则复杂比较高了。当然,用uptime也可以查看。

vmstat

查看进程、内存、I/O等多个系统运行状态。2表示每两秒采样一次,3表示一共采样3次。procsr表示运行和等待CPU时间片的进程数,原则上1核CPU不要超过2。b是等待资源的进程数,比如磁盘I/O、网络I/O等。

[root@ ~]# vmstat -n 2 3
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 2  0      0 173188 239748 1362628    0    0     0     3   17    8  0  0 99  0  0
 0  0      0 172800 239748 1362636    0    0     0     0  194  485  1  1 99  0  0
 1  0      0 172800 239748 1362640    0    0     0     0  192  421  1  1 99  0  0

pidstat

查看某个进程的运行信息。

free

查看内存信息。

df

查看磁盘信息。

iostat

查看磁盘I/O信息。比如有时候MySQL在查表的时候,会占用大量磁盘I/O,体现在该指令的%util字段很大。对于死循环的程序,CPU占用固然很高,但是磁盘I/O不高。

ifstat

查看网络I/O信息,需要安装。

CPU占用过高原因定位

先用top找到CPU占用最高的进程,然后用ps -mp pid -o THREAD,tid,time,得到该进程里面占用最高的线程。这个线程是10进制的,将其转成16进制,然后用jstack pid | grep tid可以定位到具体哪一行导致了占用过高。

JVM性能调优和监控工具

jps

Java版的ps -ef查看所有JVM进程。

jstack

查看JVM中运行线程的状态,比较重要。可以定位CPU占用过高位置,定位死锁位置。

jinfo/jstat

jinfo查看JVM的运行环境参数,比如默认的JVM参数等。jstat统计信息监视工具。

jmap

JVM内存映像工具。

评论