Java及SpringBoot
Java及SpringBoot

阿里P6之四JVM+GC解析

个人专题目录：

ActiviMQ专题

链路追踪

Dubbo专题

Docker专题

Git专题

Idea专题

Java阿里P6+必会专题

Java工具类

Kafka专题

Linux专题

Maven专题

Markdown专题

Mysql专题

Netty专题

Nginx专题

Openstack专题

Redis专题

Spring专题

SpringBoot专题

SpringCloud专题

Zookeeper专题

个人随笔专题

数据结构专题

单点登录专题

设计模式专题

架构优化专题

4 JVM+GC解析

4.1 回顾

4.1.1 JVM内存结构

JVM体系概述

阿里P6之四JVM+GC解析_第1张图片
1558690006345.png

Java8以后的JVM

阿里P6之四JVM+GC解析_第2张图片
1558690061817.png

4.1.2 GC作用域

方法区，堆

4.1.3 常见的垃圾回收算法

引用计数

阿里P6之四JVM+GC解析_第3张图片
1558690144067.png

复制

阿里P6之四JVM+GC解析_第4张图片
1558690188814.png

标记清除

阿里P6之四JVM+GC解析_第5张图片
1558690225969.png

标记整理

阿里P6之四JVM+GC解析_第6张图片
1558690275674.png

4.2 题目1

4.2.1 JVM垃圾回收的时候如何确定垃圾？是否知道什么是GC Roots

什么是垃圾

简单来说就是内存中已经不再被使用到的空间就是垃圾

要进行垃圾回收，如何判断一个对象是否可以被回收？

引用计数法

​ Java中，引用和对象是有关联的。如果要操作对象则必须用引用进行。

因此，很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收。简单说，给对象中添加一个引用计数器，每当有一个地方引用它，计数器值加1，每当有一个引用失效时，计数器值减1。

​ 任何时刻计数器值为零的对象就是不可能再被使用的，那么这个对象就是可回收对象。为什么主流的Java虚拟机里面都没有选用这种算法呢？其中最主要的原因是它很难解决对象之间相互循环引用的问题。

枚举根节点做可达性分析(根搜索路径)

​ 为了解决引用计数法的循环引用问题，Java使用了可达性分析的方法。

阿里P6之四JVM+GC解析_第7张图片
1558840571793.png

所谓“GC roots”或者说tracing GC的“根集合”就是一组必须活跃的引用。

基本思路就是通过一系列名为“GC Roots”的对象作为起始点，从这个被称为GC Roots的对象开始向下搜索，如果一个对象到GC Roots没有任何引用链相连时，则说明些对象不可用。也即给定一个集合的引用作为根出发，通过引用关系遍历对象图，能被遍历到的对象就被判定为存活;没有被遍历到的就自然被决定死亡。

阿里P6之四JVM+GC解析_第8张图片
1559790714426.png

Java中可以作为GC Roots的对象

  • 虚拟机栈(栈帧中的局部变量区，也叫做局部变量表)中引用的对象。
  • 方法区中的类静态属性引用的对象。
  • 方法区中常量引用的对象。
  • 本地方法栈中JNI(Native方法)引用的对象。

4.2.2 你说你做过JVM调优和参数配置，请问如何盘点查看JVM系统默认值

JVM的参数类型

标配参数
  • -version
  • -help
  • java -showversion
X参数（了解）
  • -Xint 解释执行
  • -Xcomp 第一次使用就编译成本地代码
  • -Xmixed 混合模式
XX参数
  • Boolean类型
    • 公式
      • -XX:+或者 - 某个属性值
      • +表示开启，-表示关闭
    • Case
      • 是否打印GC收集细节
        • -XX:-PrintGCDetails
          • jps -l
          • jinfo -flag PrintGCDetails 进程编号
        • -XX:+PrintGCDetails
          • jps -l
          • jinfo -flag PrintGCDetails 进程编号
      • 是否使用串行垃圾收集器
        • -XX:-UseSerialGC
        • -XX:+UseSerialGC
  • KV设值类型
    • 公式
      • -XX:属性key=属性值value
    • Case
      • -XX:MetaspaceSize=128m
      • -XX:MaxTenuringThreshold=15
  • jinfo类型，如何查看当前运行程序的配置
    • 公式（jinfo -flag 配置项 进程编号）
    • Case
      • jinfo -flag InitialHeapSize 进程编号
      • jinfo -flags 进程编号
      • jinfo -flag UseParallelGC 进程编号
  • 其它
    • 两个经典参数：-Xms和-Xmx
    • 如何理解
      • -Xms 等价于 -XX:InitialHeapSize
      • -Xmx 等价于 -XX:MaxHeapSize

盘点查看JVM默认值

  • -XX:+PrintFlagsInitial
    • 主要查看初始默认
    • 公式
      • java -XX:+PrintFlagsInitial -version
  • -XX:+PrintFlagsFinal
    • 主要查看修改更新
    • 公式
      • java -XX:+PrintFlagsFinal -version
  • PrintFlagsFinal举例，运行java命令的同时打印出参数
    • java -XX:+PrintFlagsFinal -XX:MetaspaceSize=512m Test
  • -XX:+PrintCommandLineFlags

4.2.3 你平时工作中用过的JVM常用基本配置参数有哪些？

基础知识

在java8中，永久代已经被移除，被一个称为元空间的区域所取代。元空间的本质和永久代类似。

元空间(java8)与永久代（java7）之间最大的区别在于：永久代使用的JVM的堆内存，但是java8以后的元空间并不在虚拟机中而是使用本机物理内存。

因此，默认情况下，元空间的大小仅受本地内存限制。类的元数据放入native memory，字符串池和类的静态变量放入java堆中，这样可以加载多少类的元数据就不再由MaxPermSize控制，而由系统的实际可用空间来控制。

public class HelloGC {
    public static void main(String[] args) {
        long totalMemory = Runtime.getRuntime().totalMemory();//返回Java虚拟机中的内存总量。
        long maxMemory = Runtime.getRuntime().maxMemory();//返回Java虚拟机试图使用的最大内存量。
        System.out.println((totalMemory / (double) 1024 / 1024) + "MB");
        System.out.println((maxMemory / (double) 1024 / 1024) + "MB");
    }
}

常用参数

  • -Xms
    • 初始大小内存，默认为物理内存1/64,等价于-XX:InitialHeapSize
  • -Xmx
    • 最大分配内存，默认为物理内存1/4,等价于-XX:MaxHeapSize
  • -Xss
    • 设置单个线程栈的大小，一般默认为512k~1024k,等价于-XX:ThradStackSize
  • -Xmn
    • 设置年轻代大小
  • -XX:MetaspaceSize
    • 设置元空间大小
      • 元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制
      • -Xms10m -Xmx10m -XX:MetespaceSize=1024m -XX:+PrintFlagsFinal
  • -XX:+PrintGCDetails
    • 输出详细GC收集日志信息
    • GC
    • FullGC
  • -XX:SurvivorRatio
    • 设置新生代中eden和s0/s1空间的比例，默认-XX:SurvivorRatio=8,Eden:s0:s1=8:1:1,假如-XX:SurvivorRatio=4,Eden:s0:s1=4:1:1,SurvivorRatio值就是设置eden区的比例占多少，s0/s1相同
  • -XX:NewRatio
    • 配置年轻代与老年代在堆结构的占比，默认-XX:NewRatio=2,新生代占1，老年代占2，年轻代占整个堆的1/3;假如-XX:NewRatio=4新生代占1，老年代占4，年轻代占整个堆的1/5,NewRatio值就是设置老年代的占比，剩下的1给新生代
  • -XX:MaxTenuringThreshold
    • 设置垃圾最大年龄，默认值为15，有效值在0到15之间，-XX:MaxTenuringThreshold=0:设置垃圾最大年龄。如果设置为0的话，则年轻代对象不经过Survivor区，直接进入年老代。对于年老代比较多的应用，可以提高效率。如果将此值设置为一个较大值，则年轻代对象会在Survivor区进行多次复制，这样可以增加对象在年轻代的存活时间，增加在年经代即被回收的概率。
阿里P6之四JVM+GC解析_第9张图片
1558875048259.png

4.2.4 强引用、软引用、弱引用、虚引用分别是什么？

阿里P6之四JVM+GC解析_第10张图片
1558934719418.png

  • 整体架构

  • 强引用(默认支持模式)

    • 当内存不足，JVM开始垃圾回收，对于强引用对象，就算是出现了OOM也不会对该对象进行回收，死都不收。强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。在Java中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。对于一个普通的对象，如果没有其它的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为null,一般认为就是可以被垃圾收集了（当然具体回收时机还是要看垃圾收集策略）。
  public class StrongReferenceDemo {
      public static void main(String[] args) {
          Object obj1 = new Object();//这样定义的默认就是强引用
          Object obj2 = obj1;//obj2引用赋值
          obj1 = null;//置空
          System.gc();
          System.out.println(obj2);
      }
  }

  • 软引用

    • 软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。对于只有软引用的对象来说，当系统内存充足时它不会被回收，当系统内存不足时会被回收。软引用通常用在对内存敏感的程序中，比如高速缓存就有和到软引用，内存够用的时候就保留，不够用就回收。
  public class SoftReferenceDemo {
      /**
       * 内存够用的时候就保留，不够用就回收
       */
      public static void softRef_Memory_Enough() {
          Object o1 = new Object();
          SoftReference softReference = new SoftReference<>(o1);
          System.out.println(o1);
          System.out.println(softReference.get());
          o1 = null;
          System.gc();
          System.out.println(o1);
          System.out.println(softReference.get());
      }
  
      /**
       * JVM配置，故意产生大对象并配置小的内存，让它内存不够用了导致OOM，看软引用的回收情况
       * -Xms5m -Xmx5m -XX:+PrintGCDetails
       */
      public static void softRef_Memory_NotEnough() {
          Object o1 = new Object();
          SoftReference softReference = new SoftReference<>(o1);
          System.out.println(o1);
          System.out.println(softReference.get());
          o1 = null;
          try {
              byte[] bytes = new byte[30 * 1024 * 1024];
          } catch (Throwable e) {
              e.printStackTrace();
          } finally {
              System.out.println(o1);
              System.out.println(softReference.get());
          }
      }
  
      public static void main(String[] args) {
          softRef_Memory_Enough();
          softRef_Memory_NotEnough();
      }
  }
 
 
     
  
  •  
    弱引用
     
   
       
    
    • 弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存周期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。
      •  
    
    • 软引用和弱引用的使用场景。 假如有一个应用需要读取大量的本地图片：如果每次读取图片都从硬盘读取则会严重影响性能，如果一次性全部加载到内存中又可能造成内存溢出。此时可以用软引用解决这个问题。设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象占用的空间，从而有效地避免了OOM的问题。Map> imageCache = new HashMap<>();
      •  
    
    • 谈谈WeakHashMap
      •  
   
     
    •  
 
 
 
  public class WeakReferenceDemo {
      public static void main(String[] args) {
          Object o1 = new Object();
          WeakReference weakReference = new WeakReference<>(o1);
          System.out.println(o1);
          System.out.println(weakReference.get());
  
          o1 = null;
          System.gc();
          System.out.println("----------------------");
  
          System.out.println(o1);
          System.out.println(weakReference.get());
  
      }
  }
  
  public class WeakHashMapDemo {
      public static void main(String[] args) {
          myHashMap();
          myWeakHashMap();
      }
  
      private static void myHashMap() {
          HashMap map = new HashMap<>();
          Integer key = new Integer(1);
          String value = "HashMap";
          map.put(key, value);
          System.out.println(map);
          key = null;
          System.out.println(map);
          System.gc();
          System.out.println(map);
      }
  
      private static void myWeakHashMap() {
          WeakHashMap map = new WeakHashMap<>();
          Integer key = new Integer(2);
          String value = "WeakHashMap";
          map.put(key, value);
          System.out.println(map);
          key = null;
          System.out.println(map);
          System.gc();
          System.out.println(map);
      }
  }
 
 
     
  
  •  
    虚引用
     
   
       
    
    • 虚引用需要java.lang.ref.PhantomReference类来实现。顾名思义，就是形同虚设，与其它几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。它不能单独使用也不能通过它访问对象，虚引用必须和引用队列（ReferenceQueue联合实用）。
      •  
    
    • 虚引用的主要作用跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被finalize以后，做某些事情的机制。PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。其意义在于说明一个对象已经进入finalization阶段，可以被gc回收，用以实现比finalization机制更灵活的回收操作。
      •  
    
    • 换句话说，设置虚引用关联 唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。Java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。
      •  
    
    • 引用队列
      •  
   
     
    •  
 
 
 
  public class ReferenceQueueDemo {
      public static void main(String[] args) throws InterruptedException {
          Object o1 = new Object();
          ReferenceQueue referenceQueue = new ReferenceQueue<>();
          WeakReference weakReference = new WeakReference<>(o1, referenceQueue);
  
          System.out.println(o1);
          System.out.println(weakReference.get());
          System.out.println(referenceQueue.poll());
  
          o1 = null;
          System.gc();
          Thread.sleep(10);
          
          System.out.println(o1);
          System.out.println(weakReference.get());
          //被回收前需要引用队列保存下
          System.out.println(referenceQueue.poll());
      }
  }
 
 
/**
 * java提供了4种引用类型，在垃圾回收的时候，都有各自的特点。
 * ReferenceQueue是用来配合引用工作的，没有ReferenceQueue一样可以运行。
 * 创建引用的时候可以指定关联的队列，当GC释放对象的时候，会将引用加入到引用队列，
 * 如果程序发现某个虚引用已经被加入以引用队列，那么就可以在所引用的对象的内存被回收之前采取必须的行动
 * 这相当于是一种通知机制。
 * 当关联的引用队列中有数据的时候，意味着引用指向的堆内存中的对象被回收。通知这种方式，JVM允许我们在对象被销毁后，做一些我们自己想做的事情
 */
public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue 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(10);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());
    }
}
 
 
     
  
  • GCRoots和四大引用总结
    •  
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第11张图片 
   
 
  
 
  

    1559791208982.png 
  
 
 
 
 
4.2.5 请谈谈你对OOM的认识。
 
 
     
  
  • java.lang.StackOverflowError
    •  
 
 
 
public class StackOverflowErrorDemo {
    public static void main(String[] args) {
        stackOverflowError();
    }

    private static void stackOverflowError() {
        //Exception in thread "main" java.lang.StackOverflowError
        stackOverflowError();
    }
}

 
 
     
  
  • java.lang.OutOfMemoryError:Java heap space
    •  
 
 
 
//-Xms10m -Xmx10m
public class JavaHeapSpaceDemo {
    public static void main(String[] args) {
        String str = "xubh";
        while (true) {
            str += str + new Random().nextInt(100000) + new Random().nextInt(999999);
            str.intern();
        }
        //Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    }
}

 
 
     
  
  • java.lang.OutOfMemoryError:GC overhead limit exceeded
    •  
 
 
 
/**
 * JVM参数配置演示
 * -Xms10m -Xmx10m -XX:MaxDirectMemorySize=5m -XX:+PrintGCDetails
 * GC回收时间过长会抛出OutOfMemoryError。过长的定义是，超过98%的时间用来做GC并且回收了不到2%的堆内存
 * 连续多次GC都只回收了不到2%的极端情况下才会抛出。假如不抛出GC overhead limit错误会发生什么情况呢
 * 那就是GC清理的这么点内存很快会再次填满，迫使GC再次执行，这样就形成恶性循环，
 * CPU使用率一直是100%，而GC却没有任何成果。
 * Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
 */
public class GCOverHeadLimitErrorDemo {
    public static void main(String[] args) {
        int i = 0;
        List list = new ArrayList<>();
        try {
            while (true) {
                list.add(String.valueOf(++i).intern());
            }
        } catch (Throwable e) {
            System.out.println(i);
            e.printStackTrace();
        }
    }

}

 
 
     
  
  • java.lang.OutOfMemoryError:Direct buffer memory
    •  
 
 
 
/**
 * JVM参数配置演示
 * -Xms10m -Xmx10m -XX:MaxDirectMemorySize=5m -XX:+PrintGCDetails
 * 故障现象：
 * Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
 * 原因：
 * 写NIO程序经常使用ByteBuffer来读取或者写入数据，这是一种基于通道（Channel）与缓冲区（Buffer）的I/O方式，
 * 它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆里面DirectByteBuffer对象作为这块内存的引用进行操作。
 * 这样能在一些场景中显著提高性能，因为避免了Java堆和Native堆中来回复制数据。
 * ByteBuffer.allocate(capability) 第一种方式是分配JVM堆内存，属于GC管辖范围，由于需要拷贝所以速度相对较慢
 * ByteBuffer.allocateDerect(capability) 第二种方式是分配OS本地内存，不属于GC管辖范围，由于不需要内存拷贝所以速度相对较快。
 * 但如果不断分配本地内存，堆内存很少使用，那么JVM就不需要执行GC，DirectByteBuffer对象们就不会被回收，
 * 这时候堆内存充足，但本地内存可能已经用光了，再次尝试分配本地内存就会出现OutOfMemoryError,程序就直接崩溃了。
 */
public class DirectBufferMemoryDemo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(sun.misc.VM.maxDirectMemory() / (double) 1024 / 1024 + "MB");
        Thread.sleep(2000);
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8 * 1024 * 1024);
    }
}

 
 
     
  
  • java.lang.OutOfMemoryError:unable to create new native thread 
   
       
    
    • ulimit -u
      •  
    
    • vim /etc/security/limits.d/90-nproc.conf(除了root用户，其它都限制1024)
      •  
   
     
    •  
 
 
 
/**
 * 高并发请求服务器时，经常出现如下异常：java.lang.OutOfMemoryError:unable to create new native thread
 * 准确的讲该native thread 异常与对应的平台有关
 * 

 * 导致原因：
 * 1、你的应用程序创建了太多的线程了，一个应用进程创建多个线程，超过系统承载极限
 * 2、你的服务器并不允许你的应用程序创建这么多线程，linux系统默认允许单个进程可以创建的线程数是1024个，
 * 你的应用创建超过这个数量，就会报java.lang.OutOfMemoryError:unable to create new native thread
 * 

 * 解决方案：
 * 1、想办法降低应用程序创建线程的数量，分析应用程序是否需要创建这么多线程，修改代码优化。
 * 2、对于有的应用，确实需要大量线程，可以通过修改linux服务器配置，扩大linux默认限制。
 */
public class UnableCreateNewThreadDemo {
    public static void main(String[] args) {
        for (int i = 1; ; i++) {
            System.out.println(i);
            new Thread(() -> {
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, "" + i).start();
        }
    }
}

 
 
     
  
  • java.lang.OutOfMemoryError:Metaspace 
   
       
    
    • 使用java -XX:+PrintFlagsInitial命令查看本机的初始化参数，-XX:MetaspaceSize约20m
      •  
   
     
    •  
 
 
 
/**
 * java.lang.OutOfMemoryError: Metaspace
 * JVM参数：
 * -XX:MetaspaceSize=10m -XX:MaxMetaspaceSize=10m
 * java8及以后版本使用metaspace替代永久代。
 * Metaspace是方法区在Hotspot中的实现，它与持久代最大区别在于：Metaspace并不在虚拟机内存中而是在本地内存，被存储在民做
 * Metaspace的native memory
 * 

 * 永久代存放了以下信息：
 * 虚拟机加载的类信息
 * 常量池
 * 静态变量
 * 即时编译后的代码
 * 

 * 模拟让类占据的空间超过Metaspace指定的空间大小
 */
public class MetaspaceOOMDemo {
    static class OOMTest {

    }

    public static void main(String[] args) {
        int i = 0;
        try {
            while (true) {
                i++;
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(OOMTest.class);
                enhancer.setUseCache(false);
                enhancer.setCallback(new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        return methodProxy.invokeSuper(o, args);
                    }
                });
                enhancer.create();
            }
        } catch (Throwable e) {
            System.out.println("运行多少次发生了异常：" + i);
            e.printStackTrace();
        }

    }
}

 
 
4.2.6 GC垃圾回收算法和垃圾收集器的关系？分别是什么请谈谈
 
 
     
  
  • GC算法（引用计数/复制/标清/标整）是内存回收的方法论，垃圾收集器就是算法落地实现。
    •  
  
  •  
    4种主要垃圾收集器
     
   
     
    
     
     
     
      阿里P6之四JVM+GC解析_第12张图片 
     
     
    
     
    
    
      1558949129653.png 
    
     
   
     
   
       
    
    •  
      串行垃圾收集器（Serial）
       
     
         
      
      • 它为单线程环境设计且只使用一个线程进行垃圾回收，会暂停所有的用户线程。所以不适合服务器环境。
        •  
     
       
      •  
    
    •  
      并行垃圾收集器（Parallel）
       
     
         
      
      • 多个垃圾收集线程并行工作，此时用户线程是暂停的，适用于科学计算/大数据处理后台处理等弱交互场景
        •  
     
       
      •  
    
    •  
      并发垃圾收集器（CMS）
       
     
         
      
      • 用户线程和垃圾收集线程同时执行（不一定是并行，可能交替执行），不需要停顿用户线程，互联网公司多用它，适用对响应时间有要求的场景
        •  
     
       
      •  
    
    •  
      G1垃圾回收器
       
     
         
      
      • G1垃圾回收器将堆内存分割成不同的区域然后并发的对其进行垃圾回收
        •  
     
       
      •  
   
     
    •  
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第13张图片 
   
 
  
 
  

    1558948546767.png 
  
 
 
 
 
4.2.7 怎么查看服务器默认的垃圾收集器是哪个？生产上如何配置垃圾收集器的？谈谈你对垃圾收集器的理解？
 
 
     
  
  • 怎么查看默认的垃圾收集器是哪个 
   
       
    
    • JVM参数：java -XX:+PrintCommandLineFlags -version (-XX:+UseParallelGC)
      •  
   
     
    •  
  
  • 默认的垃圾收集器有哪些 
   
       
    
    • java的gc回收的类型主机有几种：UseSerialGC，UseParallelGC，UseConcMarkSweepGC，UseParNewGC，UseParallelOldGC，UseG1GC
      •  
   
     
    •  
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第14张图片 
   
 
  
 
  

    1558951205411.png 
  
 
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第15张图片 
   
 
  
 
  

    1558951448067.png 
  
 
 
 
 
     
  
  • 垃圾收集器 
   
       
    
    •  
      部分参数说明
       
     
         
      
      •  DefNew Default New Generation
        •  
      
      •  Tenured Old
        •  
      
      •  ParNew Parallel New Generation
        •  
      
      •  PSYoungGen Parallel Scavenge
        •  
      
      •  ParOldGen Parallel Old Generation
        •  
     
       
      •  
    
    •  
      Server/Client模式
       
     
         
      
      • Client模式基本不会用，64位仅支持Swerver模式
        •  
     
       
      •  
    
    •  
      新生代
       
     
         
      
      • 串行GC（Serial）/（Serial Copying） 
       
           
        
        • 一句话：一个单线程的收集器，在进行垃圾收集时候，必须暂停其它所有的工作线程直到它收集结束。
          •  
        
        • 串行收集器是最古老，最稳定以及效率最高的收集器，只使用一个线程去回收但是其在回收过程中可能会产生较长时间的停顿（Stop-The-World）状态。虽然在收集垃圾过程中需要暂停所有其它的工作线程，但是它简单高效，对于限定单个CPU环境来说，没有线程交互的开销可以获得最高的单线程垃圾收集效率，因此Serial垃圾收集器依然是Java虚拟机运行在Client模式下默认的新生代垃圾收集器。
          •  
        
        • 对应的JVM参数是：-XX:+UseSerialGC，开启后会使用:Serial(Young区用)+Serial Old(Old区用)的收集器组合。表示新生代、老年代都会使用串行回收收集器，新生代使用复制算法，老年代使用标记-整理算法。
          •  
       
         
        •  
      
      • 并行GC（ParNew） 
       
           
        
        • 一句话：使用多线程进行垃圾回收，在垃圾收集时，会Stop-the-world暂停其他所有的工作线程直到它收集结束。
          •  
        
        •  ParNew收集器其实就是Serial收集器新生代的并行多线程版本，最常见的应用场景是配合老年代的CMS GC工作，其余的行为和Serial收集器完全一样，ParNew垃圾收集器在垃圾收集过程中同样也要暂停所有其它的工作线程。它是很多java虚拟机运行在Server模式下新生代的默认垃圾收集器。
          •  
        
        • 常见的JVM参数：-XX:+UseParNewGC 启用ParNew收集器，只影响新生代的收集，不影响老年代。开启上述参数后，会使用：ParNew(Young区用)+Serial Old的收集器组合，新生代使用复制算法，老年代采用标记-整理算法。
          •  
        
        • 但是，ParNew+Tenured这样的搭配，java8已经不再被推荐， 备注：-XX:ParallelGCThreads限制线程数量，默认开启和CPU核数相同的线程数。
          •  
       
         
        •  
      
      • 并行回收GC（Parallel）/（Parallel Scavenge） 
       
           
        
        • Parallel Scavenge收集器类似ParNew，也是一个新生代垃圾收集器，使用复制算法，也是一个并行的多线程的垃圾收集器，俗称吞吐量优先的收集器。一句话：串行收集器在新生代和老年代的并行化。
          •  
        
        • 它重点关注的是：可控制的吞吐量（Thoughput=运行用户代码时间/(运行用户代码时间+垃圾收集时间)，也即比如程序运行100分钟，垃圾收集时间1分钟，吞吐量就是99%）。高吞吐量意味着高效利用CPU的时间，它多用于在后台运算而不需要太多交互的任务。
          •  
        
        •  自适应调节策略也是ParallelScavenge收集器与ParNew收集器的一个重要区别。（自适应调节策略：虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间（-XX:MaxGCPauseMillis）或最大的吞吐量。
          •  
        
        • 常用JVM参数：-XX:+UseParallelGC或-XX:+UseParallelOldGC(可互相激活)使用Parallel Scanvenge收集器，开启后：新生代使用复制算法，老年代使用标记-整理算法。-XX:ParallelGCThreads=数字N，表示启动多少个GC线程，cpu大于8，N=5/8,cpu小于8，N=实例核数。
          •  
       
         
        •  
     
       
      •  
    
    •  
      老年代
       
     
         
      
      • 串行GC（Serial Old）/（Serial MSC） 
       
           
        
        •  Serial Old是Serial垃圾收集器的老年代版本，它同样是个单线程的收集器，使用标记-整理算法，这个收集器也主要是运行在Client默认的java虚拟机默认的老年代垃圾收集器。
          •  
        
        • 在Server模式下，主要有2个用途：1、在JDK1.5之前版本中与新生代的Parallel Scavenge收集器搭配使用。（Parallel Scavenge+Serial Old）,2、作为老年代版中使用CMS收集器的后备垃圾收集方案。
          •  
       
         
        •  
      
      • 并行GC（Parallel Old）/（Parallel MSC） 
       
           
        
        •  Parallel Old收集器是Parallel Scavenge的老年代版本，使用多线程的标记-整理算法，Parallel Old收集器在JDK1.6才开始提供。
          •  
        
        • Parallel Old正是为了年老代同样提供吞吐量优先的垃圾收集器，如果系统对吞吐量要求比较高，JDK1.8后可优先考虑新生代Parallel Scavenge和年老代Parallel Old收集器的搭配策略。在JDK1.8及后（Parallel Scavenge+Parallel Old）
          •  
        
        • 常用JVM参数：-XX:+UseParallelOldGC使用Parallel Old收集器，设置该参数后，新生代Parallel+老年代Parallel Old
          •  
       
         
        •  
      
      • 并发标记清除GC（CMS） 
       
           
        
        • CMS收集器（Concurrent Mark Sweep:并发标记清除）是一种以获取最短回收停顿时间为目标的收集器。 适合应用在互联网站或者B/S系统的服务器上，这类应用尤其重视服务器的响应速度，希望系统停顿时间最短。
          •  
        
        • CMS非常适合堆内存大、CPU核数多的服务器端应用，也是G1出现之前大型应用的首选收集器。
          •  
        
        • Concurrent Mark Sweep:并发标记清除，并发收集低停顿，并发指的是与用户线程一起执行。
          •  
        
        • 开启该垃圾收集器的JVM参数：-XX:+UseConcMarkSweepGC 开启该参数后会自动将-XX:+UseParNewGC打开，开启该参数后，使用ParNew(Young区用)+CMS(Old区用)+Serial Old的收集器组合，Serial Old将作为CMS出错的后备收集器。
          •  
        
        • 优点：并发收集低停顿。缺点：并发执行，对CPU资源压力大，由于并发进行，CMS在收集与应用线程会同时会增加对堆内存的占用，也就是说，CMS必须要在老年代堆内存用尽之前完成垃圾回收，否则CMS回收失败时，会触发担保机制，串行老年代收集器将会以STW的方式进行一次GC，从而造成较大停顿时间。采用的标记清除算法会导致大量内存碎片，无法整理空间碎片，老年代空间会随着应用时长被逐步耗尽，最后将不得不通过担保机制对堆内存进行压缩。CMS也提供了参数：-XX:CMSFullGCsBeForeCompaction(默认0，即每次都进行内存整理)来指定多少次CMS收集之后，进行一次压缩的Full GC。
          •  
       
         
        •  
      
      • 初始标记（CMS initial mark） 
       
           
        
        • 只是标记一下GC Roots能直接关联的对象，速度很快，仍然需要暂停所有的工作线程。
          •  
       
         
        •  
      
      • 并发标记（CMS concurrent mark）和用户线程一起 
       
           
        
        • 进行GC Roots跟踪的过程，和用户线程一起工作，不需要暂停工作线程。主要标记过程，标记全部对象。
          •  
       
         
        •  
      
      • 重新标记（CMS remark） 
       
           
        
        • 为了修正在并发标记期间，因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，仍然需要暂停所有的工作线程。由于并发标记时，用户线程依然运行，因此在正式清理前，再做修正。
          •  
       
         
        •  
      
      • 并发清除（CMS concurrent sweep）和用户线程一起 
       
           
        
        • 清除GC Roots不可达对象，和用户线程一起工作，不需要暂停工作线程。基于标记结果，直接清理对象。由于耗时最长的并发标记和并发清除过程中，垃圾收集线程可以和用户线程一起并发工作，所以总体上来看CMS收集器的内存回收和用户线程是一起并发地执行。
          •  
       
         
        •  
     
       
      •  
    
    •  
      垃圾收集器配置总结
       
     
         
      
      • 底层代码
        •  
     
       
      •  
   
     
    •  
 
 
 
 // Check consistency of GC selection
/**
 * 检查GC策略的配置是否正确
 */
bool Arguments::check_gc_consistency() {
  check_gclog_consistency();
 
  bool status = true;
  // Ensure that the user has not selected conflicting sets
  // of collectors. [Note: this check is merely a user convenience;
  // collectors over-ride each other so that only a non-conflicting
  // set is selected; however what the user gets is not what they
  // may have expected from the combination they asked for. It's
  // better to reduce user confusion by not allowing them to
  // select conflicting combinations.
  uint i = 0;
 
  if (UseSerialGC)                       i++;
  if (UseConcMarkSweepGC || UseParNewGC) i++;
  if (UseParallelGC || UseParallelOldGC) i++;
  if (UseG1GC)                           i++;
 
  if (i > 1) {
    jio_fprintf(defaultStream::error_stream(),
                "Conflicting collector combinations in option list; "
                "please refer to the release notes for the combinations "
                "allowed\n");
    status = false;
  }
 
  return status;
}

 
 
     
  
  • 实际代码
    •  
 
 
 
1、(DefNew+Tenured)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseSerialGC
2、(ParNew+Tenured)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseParNewGC
3、(PSYongGen+ParOldGen)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseParallelGC
4、(PSYongGen+ParOldGen)(java8默认配置)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseParallelOldGC

5、(par new generation+concurrent mark sweep)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseConcMarkSweepGC
6、(G1)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseG1GC
7、(java8已经被优化掉了)
-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseSerialOldGC

 
 
​
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第16张图片 
   
 
  
 
  

    1558959826312.png 
  
 
 
 
 
     
  
  • 如何选择垃圾收集器 
   
       
    
    • 单CPU或小内存，单机程序 -XX:+UseSerialGC
      •  
    
    • 多CPU,需要最大吞吐量，如后台计算型应用 -XX:+UseParllelGC 或者 -XX:+UseParllelOldGC
      •  
    
    • 多CPU，追求低停顿时间，需快速响应如互联网应用 -XX:+UseConcMarkSweepGC -XX:+ParNewGC
      •  
   
     
    •  
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第17张图片 
   
 
  
 
  

    1559007533195.png 
  
 
 
 
 
4.2.8 G1垃圾收集器
 
 
     
  
  •  
    以前收集器的特点
     
   
       
    
    • 年轻代和老年代是各自独立且连续的内存块
      •  
    
    • 年轻代收集使用单eden+s0+s1进行复制算法
      •  
    
    • 老年代收集必须扫描整个老年代区域
      •  
    
    • 都是以尽可能少而快速地执行GC为设计原则
      •  
   
     
    •  
  
  •  
    G1是什么
     
   
       
    
    • G1（Garbage-First）收集器，是一款面向服务端应用的收集器。从官网描述中可知道，G1是一种服务器端的垃圾收集器，应用在多处理器和大容量内存环境中，在实现高吞吐量的同时，尽可能的满足垃圾收集暂停时间的要求。另外，它还具有以下特性：
      •  
    
    • 像CMS收集器一样，能与应用程序线程并发执行。
      •  
    
    • 整理空闲空间更快。
      •  
    
    • 需要更多的时间来预测GC停顿时间。
      •  
    
    • 不希望牺牲大量的吞吐性能。
      •  
    
    • 不需要更大的Java Heap。
      •  
    
    •  
      G1收集器的设计目标是取代CMS收集器，它同CMS相比，在以下方面表现的更出色：
       
     
         
      
      • G1是一个有整理内存过程的垃圾收集器，不会产生很多内存碎片。
        •  
      
      • G1的Stop The World(STW)更可控，G1在停顿时间上添加了预测机制，用户可以指定期望停顿时间。
        •  
     
       
      •  
    
    • CMS垃圾收集器虽然减少了暂停应用程序的运行时间，但是它还是存在着内存碎片问题，于是，为了去除内存碎片问题，同时又保留CMS垃圾收集器低暂停时间的优点，JAVA7发布了一个新的垃圾收集器-G1垃圾收集器。
      •  
    
    • G1是在2012年才在JDK1.7u4中可用。oracle官方计划在java9中将G1变成默认的垃圾收集器以替代CMS。它是一款面向服务端应用的收集器，主要应用在多CPU和大内存服务器环境下，极大的减少垃圾收集的停顿时间，全面提升服务器的性能，逐步替换java8以前的CMS收集器。
      •  
    
    • 主要改变是Eden,Survivor和Tenured等内存区域不再是连续的了，而是变成了一个个大小一样的region，每个region从1M到32M不等。一个region有可能属于Eden,Survivor或者Tenured内存区域。
      •  
   
     
    •  
  
  •  
    G1特点
     
   
       
    
    • G1能充分利用多CPU、多核环境硬件优势，尽量缩短STW。
      •  
    
    • G1整体上采用标记-整理算法，局部是通过复制算法，不会产生内存碎片。
      •  
    
    • 宏观上看G1之中不再区分年轻代和老年代。把内存划分成多个独立的子区域（Region）,可以近似理解为一个围棋的棋盘。
      •  
    
    • G1收集器里面将整个的内存区域都混合在一起了，但是其本身依然在小范围内要进行年轻代和老年代的区分，保留了新生代和老年代，但是它们不再是物理隔离的，而是一部分Region的集合且不需要Region是连续的，也就是说依然地采用不同的GC方式来处理不同的区域。
      •  
    
    • G1虽然也是分代收集器，但是整个内存分区不存在物理上的年轻代与老年代的区别，也不需要完全独立的survivor(to space)堆做复制准备。G1只有逻辑上的分代概念，或者说每个分区都可能随G1的运行在不同代之间前后切换。
      •  
   
     
    •  
  
  •  
    底层原理
     
   
       
    
    • Region区域化垃圾收集器 
     
         
      
      • 最大的好处是化整为零，避免全内存扫描，只需要按照区域来进行扫描即可。
        •  
      
      • 区域化内存划片Region，整体编为了一些列不连续的内存区域，避免了全内存区的GC操作。
        •  
      
      • 核心思想是将整个堆内存区域分成大小相同的子区域（Region），在JVM启动时会自动设置这些子区域的大小，在堆的使用上，G1并不要求对象的存储一定是物理上连续的只要逻辑上连接即可，每个分区也不会固定地为某个代服务，可以按需在年轻代和老年代之间切换。启动时可以通过参数-XX:G1HeapRegionSize=n可指定分区大小（1mb~32mb,且必须是2的幂），默认将整堆划分为2048个分区。
        •  
      
      • 大小范围为1MB~32MB，最多能设置2048个区域，也即能够支持的最大内存为：32MB*2048=65536MB=64G内存
        •  
     
       
      •  
   
     
    •  
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第18张图片 
   
 
  
 
  

    1559010248200.png 
  
 
 
 
 
G1算法将堆划分为若干个区域（Region）,它仍然属于分代收集器，这些Region的一部分包含新生代，新生代 的垃圾收集依然采用暂停所有应用线程的方式，将存活对象拷贝到老年代或者Survivor空间。
 
 
这些Region的一部分包含老年代，G1收集器通过将对象从一个区域复制到另外一个区域，完成了清理工作。这意味着，在正常的处理过程中，G1完成了堆的压缩（至少是部分堆的压缩），这样也就不会有CMS内存碎片问题的存在了。
 
 
在G1中，还有一种特殊的区域，叫Humongous(巨大的)区域，如果一个对象占用的空间超过了分区容量50%以上，G1收集器认为这是一个巨型的对象。这些巨型对象默认直接被分配在老年代，但是如果它是一个短期存在的巨型对象，就会对垃圾收集器造成负面影响。为了解决这个问题，G1划分了一个Humongous区，它用来专门存放巨型对象。如果一个H区装不下一个巨型对象，那么G1会寻找连续的H分区来存储。为了能找到连续的H区，有时候不得不启动Full GC。
 
 
     
  
  • 回收步骤 
   
       
    
    • G1收集器下的Young GC
      •  
    
    • 针对Eden区进行收集，Eden区耗尽后会被触发，主要是小区域收集+形成连续的内存块，避免内存碎片。 
     
         
      
      • Eden区的数据移动到Surivor区，假如出现Surivor区空间不够，Eden区数据会部分晋升到Old区
        •  
      
      • Surivor区的数据移动到新的Surivor区，部分数据晋升到Old区
        •  
      
      • 最后Eden区收拾干净了，GC结束，用户的应用程序继续工作。
        •  
     
       
      •  
   
     
    •  
  
  • 4步过程
    •  
 
 
 
 
  
 
   
 
    阿里P6之四JVM+GC解析_第19张图片 
   
 
  
 
  

    1559791677203.png 
  
 
 
 
 
     
  
  • 常用配置参数 
   
       
    
    • -XX:+UseG1GC
      •  
    
    • -XX:G1HeapRegionSize=n: 设置G1区域的大小。但是2的幂，范围1mb-32mb。目标是根据最小的java堆大小划分出约2048个区域。
      •  
    
    • -XX:MaxGCPauseMilis=n:最大GC停顿时间，这个软目标，JVM尽可能停顿少于这个时间
      •  
    
    • -XX:InitiatingHeapOccupancyPercent=n:堆占用了多少的时候就触发GC，默认为45
      •  
    
    • -XX:ConcGCThreads=n:并发GC使用的线程数
      •  
    
    • -XX:G1ReservePercent=n:设置作为空闲空间的预留内存百分比，以降低目标空间溢出的风险，默认值是10%
      •  
    
    • 三步归纳：开始G1+设置最大内存+设置最大停顿时间 -XX:+UseG1GC -Xmx32g -XX:MaxGCPauseMillis=100
      •  
   
     
    •  
  
  • 和CMS相比的优势 
   
       
    
    • G1不会产生内存碎片。
      •  
    
    • 是可以精确控制停顿。该收集器把整个堆（新生代、老年代）划分成多个固定大小的区域，每次根据允许停顿的时间去收集垃圾最多的区域。
      •  
   
     
    •  
 
 
 
4.2.9 生产环境服务器变慢，诊断思路和性能评估谈谈？
 
 
     
  
  •  
    整机：top
     
   
       
    
    • uptime,系统性能命令的精简版
      •  
   
     
    •  
  
  •  
    CPU：vmstat
     
   
       
    
    • 查看CPU（包含但不限于）vmstat -n 2 3 
     
         
      
      • 一般vmstat工具的使用是通过两个数字参数来完成的，第一个参数是采样的时间间隔单位是秒，第二个参数是采样的次数
        •  
      
      • procs r:运行和等待CPU时间片的进程数，原则上1核的CPU的运行队列不要超过2，整个系统的运行队列不能超过总核数的2倍，否则代表系统压力过大。b:等待资源的进程数，比如正在等待磁盘I/O、网络I/O等。
        •  
      
      • cpu us:用户进程消耗CPU时间百分比，us值高，用户进程消耗CPU时间多，如果长期大于50%，优化程序；sy:内核进程消耗的CPU时间百分比。us+sy参考值为80%，如果大于80%，说明可能存在CPU不足。
        •  
      
      • id:处于空闲的CPU百分比。
        •  
      
      • wa：系统等待IO的CPU时间百分比。
        •  
      
      • st:来自于一个虚拟机偷取的CPU时间的百分比。
        •  
     
       
      •  
    
    • 查看额外 
     
         
      
      • 查看所有CPU核信息 mpstat -P ALL 2
        •  
      
      • 每个进程使用cpu的用量分解信息 pidstat -u 1 -p 进程编号
        •  
     
       
      •  
   
     
    •  
 
 
 
[[email protected] ~]# 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
 0  0      0 458120 300268 1545292    0    0     1    11    2    2  1  0 99  0  0   
 0  0      0 458988 300268 1545336    0    0     0    16  756 2123  2  1 97  0  0   
 0  0      0 459112 300268 1545416    0    0     0    40 1035 2398  2  1 97  0  0   

 
 
     
  
  • 内存：free -m 
   
       
    
    • 应用程序可用内存数 
     
         
      
      • 应用程序可用内存/系统物理内存>70%，内存不足
        •  
      
      • 应用程序可用内存/系统物理内存<20%,内存不足，需要增加内存
        •  
      
      • 20%<应用程序可用内存/系统物理内存<70%内存基本够用。
        •  
     
       
      •  
    
    • 查看额外 pidstat -p 进程号 -r 采样间隔秒数
      •  
   
     
    •  
  
  • 硬盘：df 
   
       
    
    • 查看磁盘剩余空间数 df -h
      •  
   
     
    •  
  
  • 磁盘IO： iostat 
   
       
    
    • 磁盘I/O性能评估 （iostat -xdk 2 3） 
     
         
      
      • 磁盘块设备分布
        •  
      
      • rkB/s每秒读取数据量kB;
        •  
      
      • wkB/s每秒写入数据量kB;
        •  
      
      • svctm I/O请求的平均服务时间，单位毫秒;
        •  
      
      • await I/O请求的平均等待时间，单位毫秒；值越少，性能越好；
        •  
      
      •  util 一秒中有百分之几时间用于I/O操作。接近100%时，表示磁盘带跑满，需要优化程序或者增加磁盘；
        •  
      
      • rkB/s、wkB/s根据系统应用不同会有不同的值，但有规律遵循：长期、超大内存读写，肯定不正常，需要优化程序读取。
        •  
      
      • svctm的值与await的值很接近，表示几乎没有I/O等待，磁盘性能好，如果await的值远高于svctm的值，则表示I/O队列等待太长，需要优化程序或更换快磁盘。
        •  
     
       
      •  
    
    • 查看额外 pidstat -d 采样间隔秒数 -p 进程号
      •  
   
     
    •  
  
  • 网络IO：ifstat 
   
       
    
    • 默认本地没有，下载安装ifstat ./configure make && make install
      •  
    
    • 查看网络IO (ifstat -1) ,各个网卡的in、out,观察网络负载情况，程序网络读写是否正常，程序网络I/O优化，增加网络I/O带宽。
      •  
   
     
    •  
 
 
 
4.2.10 假如生产环境出现CPU占用过高，请谈谈你的分析思路和定位
 
 
     
  
  • 结合linux命令的JDK命令一块分析
    •  
  
  • 先用top命令找出CPU占比最高的pid
    •  
  
  • ps -ef或者jps进一步定位， 得知是一个什么后台程序(ps -ef|grep pid|grep -v grep)
    •  
  
  •  定位到具体线程或者代码 
   
       
    
    • ps -mp 进程 -o THREAD,tid,time
      •  
    
    • -m 显示所有的线程， -p pid进程使用CPU的时间，-o 该参数后是用户自定义格式
      •  
   
     
    •  
  
  • 将需要的线程ID转换为16进制格式（英文小写格式） 
   
       
    
    • print "%x\n" 有问题的线程ID
      •  
   
     
    •  
  
  • jstack 进程ID|grep tid(16进制线程ID小写英文) -A60
    •  
 
 
 
4.2.11 对于JDK自带的JVM监控和性能分析工作用过哪些？一般你是怎么用的？
 
 
     
  
  • jps（虚拟机进程状况工具，列出当前机器上正在运行的虚拟机进程） 
   
       
    
    • -p :仅仅显示VM 标示，不显示jar,class, main参数等信息.
      •  
    
    • -m:输出主函数传入的参数. 下的hello 就是在执行程序时从命令行输入的参数
      •  
    
    • -l: 输出应用程序主类完整package名称或jar完整名称.
      •  
    
    • -v: 列出jvm参数, -Xms20m -Xmx50m是启动程序指定的jvm参数
      •  
   
     
    •  
  
  • jinfo（java配置信息工具，查看和修改虚拟机的参数） 
   
       
    
    • jinfo –sysprops 可以查看由System.getProperties()取得的参数
      •  
    
    • jinfo –flag 未被显式指定的参数的系统默认值
      •  
    
    • jinfo –flags（注意s）显示虚拟机的参数
      •  
    
    • jinfo –flag +[参数] 可以增加参数，但是仅限于由java -XX:+PrintFlagsFinal –version查询出来且
       为manageable的参数
      •  
    
    • jinfo –flag -[参数] 可以去除参数
      •  
   
     
    •  
  
  • jmap（内存映像工具） 
   
       
    
    • 官网
      •  
    
    • 用于生成堆转储快照（一般称为heapdump或dump文件）。jmap的作用并不仅仅是为了获取dump文件，它还可以查询finalize执行队列、Java堆和永久代的详细信息，如空间使用率、当前用的是哪种收集器等。
      •  
    
    • 和jinfo命令一样，jmap有不少功能在Windows平台下都是受限的，除了生成dump文件的-dump选项和用于查看每个类的实例、空间占用统计的-histo选项在所有操作系统都提供之外，其余选项都只能在Linux/Solaris下使用。
      •  
    
    • jmap -dump:live,format=b,file=heap.bin 
       Sun JDK提供jhat（JVM Heap Analysis Tool）命令与jmap搭配使用，来分析jmap生成的堆转储快照。
      •  
    
    • jhat dump文件名
       后屏幕显示“Server is ready.”的提示后，用户在浏览器中键入http://localhost：7000/就可以访问详情
      •  
    
    • case 
     
         
      
      • 映射堆快照 jmap -heap 进程ID
        •  
      
      • 抓取堆内存 
       
           
        
        • 生成hprof文件并下载到本地
          •  
        
        • MAT分析插件工具
          •  
       
         
        •  
     
       
      •  
   
     
    •  
  
  • jstat（统计信息监视工具） 
   
       
    
    • 官网
      •  
    
    • 解释 
     
         
      
      • jstat命令是用于监视虚拟机各种运行状态信息的命令行工具。它可以显示本地或者远程虚拟机进程中的类装载、内存、垃圾收集、JIT编译等运行数据，在没有GUI图形界面，只提供了纯文本控制台环境的服务器上，它将是运行期定位虚拟机性能问题的首选工具。
        •  
      
      • jstat [-命令选项][vm进程ID] 间隔时间（单位毫秒）查询次数，假设需要每250毫秒查询一次进程2764垃圾收集状况，一共查询20次，那命令应当是：jstat-gc 2764 250 20
        •  
      
      • 常用参数： 
       
           
        
        • -class (类加载器)
          •  
        
        • -compiler (JIT)
          •  
        
        • -gc (GC堆状态)
          •  
        
        • -gccapacity (各区大小)
          •  
        
        • -gccause (最近一次GC统计和原因)
          •  
        
        • -gcnew (新区统计)
          •  
        
        • -gcnewcapacity (新区大小)
          •  
        
        • -gcold (老区统计)
          •  
        
        • -gcoldcapacity (老区大小)
          •  
        
        • -gcpermcapacity (永久区大小)
          •  
        
        • -gcutil (GC统计汇总)
          •  
        
        • -printcompilation (HotSpot编译统计)
          •  
       
         
        •  
     
       
      •  
    
    • case 
     
         
      
      • 类加载统计
        •  
      
      • 编译统计
        •  
      
      • 垃圾回收统计(jstat -参数 线程id 执行时间（单位毫秒） 执行次数)
        •  
     
       
      •  
   
     
    •  
  
  • jstack（堆栈异常跟踪工具） 
   
       
    
    • 命令用于生成虚拟机当前时刻的线程快照。线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等都是导致线程长时间停顿的常见原因。
      •  
    
    • 在代码中可以用java.lang.Thread类的getAllStackTraces（）方法用于获取虚拟机中所有线程的StackTraceElement对象。使用这个方法可以通过简单的几行代码就完成jstack的大部分功能，在实际项目中不妨调用这个方法做个管理员页面，可以随时使用浏览器来查看线程堆栈。
      •  
    
    • 管理远程进程需要在远程程序的启动参数中增加：
       -Djava.rmi.server.hostname=…..
       -Dcom.sun.management.jmxremote
       -Dcom.sun.management.jmxremote.port=8888
       -Dcom.sun.management.jmxremote.authenticate=false
       -Dcom.sun.management.jmxremote.ssl=false
      •  
   
     
    •  
  
  • jvisualvm
    •  
  
  • jconsole
    •  
 
 
 
4.3 其他
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(阿里P6之四JVM+GC解析)

        

            

                
    
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 2022-04-18
                        Apbenz

                        
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • 我的黑历史
                        袖手围观有来有去

                        
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    
                    
    • 
                    
  • python八股文面试题分享及解析(1)
                        Shawn________
python
                        
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
    
                    
    • 
                    
  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    
                    
    • 
                    
  • 大伟说成语之唉声叹气
                        求索大伟

                        
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    
                    
    • 
                    
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
                        高省APP珊珊

                        
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • ARM中断处理过程
                        落汤老狗
嵌入式linux
                        
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
    
                    
    • 
                    
  • 百善孝为先
                        杜友顺

                        
    2018年11月29日天气~晴星期四找点空闲找点时间领着孩子常回家看看带上笑容带上祝福陪同爱人常回家看看家，永远是儿女们幸福温暖的港湾，那里有我们日夜思念的父母，有着彼此的牵挂，无论走到哪里，家永远是避风雨的港湾。今天没事，和媳妇回了趟老家，看看父母，回到家，房间里不算凌乱，可是细心的我发现有的地方已经沾满了灰尘，桌子上父亲不离手的烟灰缸也弹满了烟灰。几个马上就要腐烂掉的水果蔫耷的搭拉着脑袋躺在了
    
                    
    • 
                    
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南）
                        诚芯微科技
社交电子
                        
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
    
                    
    • 
                    
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 锁之缘
                        尘缘诗词原创作品

                        
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • C++ | Leetcode C++题解之第409题最长回文串
                        Ddddddd_158
经验分享C++Leetcode题解
                        
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    
                    
    • 
                                
  • JAVA基础
                                    灵静志远
位运算加载Date字符串池覆盖
                                    
    一、类的初始化顺序 
1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器 
 同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。 
 
二、String 
1 String a = "abc"; 
 JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
    
                                
    • 
                                
  • keepalived实现redis主从高可用
                                    bylijinnan
redis
                                    
    方案说明 
 
两台机器（称为A和B），以统一的VIP对外提供服务 
1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 
2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 
3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
    
                                
    • 
                                
  • java文件操作大全
                                    0624chenhong
java
                                    
    最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 
 
http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 
 
转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 
 
 
一.获得控制台用户输入的信息 
 
   &nbs
    
                                
    • 
                                
  • android学习任务
                                    不懂事的小屁孩
工作
                                    
    任务 
完成情况   搞清楚带箭头的pupupwindows和不带的使用 已完成   熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成   熟练使用android的线程handler,并敲示例代码 进行中   了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar   研究一下android的动画效果，写一个实例 已完成   复习fragem
    
                                
    • 
                                
  • zoom.js
                                    换个号韩国红果果
oom
                                    
    它的基于bootstrap 的 
https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序 
 

<link rel="stylesheet" href="style/zoom.css">
<script src=&q
    
                                
    • 
                                
  • 详解Oracle云操作系统Solaris 11.2
                                    蓝儿唯美
Solaris
                                    
    当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。  
    
                                
    • 
                                
  • spring学习——springmvc（一）
                                    a-john
springMVC
                                    
    Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。 
  
1，跟踪Spring MVC的请求 
请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
    
                                
    • 
                                
  • hdu4342 History repeat itself-------多校联合五
                                    aijuans
数论
                                    
    水题就不多说什么了。 
#include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){    int t;    ll n;    scanf("%d",&t);    while(t--)   
    
                                
    • 
                                
  • EJB和javabean的区别
                                    asia007
beanejb
                                    
    EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了 
  
1.EJB用于服务端应用开发, 而JavaBeans
    
                                
    • 
                                
  • Struts的action和Result总结
                                    百合不是茶
strutsAction配置Result配置
                                    
      
  
一:Action的配置详解: 
     下面是一个Struts中一个空的Struts.xml的配置文件 
    
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	&quo
    
                                
    • 
                                
  • 如何带好自已的团队
                                    bijian1013
项目管理团队管理团队
                                    
    在网上看到博客" 
怎么才能让团队成员好好干活"的评论，觉得写的比较好。   原文如下：   我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 
1.诚信 
        对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。   2.努力提
    
                                
    • 
                                
  • Java代码混淆工具
                                    sunjing
ProGuard
                                    
    Open Source Obfuscators 
ProGuard 
http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
    
                                
    • 
                                
  • 【Redis三】基于Redis sentinel的自动failover主从复制
                                    bit1129
redis
                                    
    在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。 
  什么是Sentine
    
                                
    • 
                                
  • 使用代理实现Hibernate Dao层自动事务
                                    白糖_
DAOspringAOP框架Hibernate
                                    
    都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 
public void save(Object obj){
		Session session = this.getSession();
		Transaction tran = session.beginTransaction();
		try 
    
                                
    • 
                                
  • maven3实战读书笔记
                                    braveCS
maven3
                                    
    Maven简介 
是什么？ 
Is a software project management and comprehension tool.项目管理工具 
是基于POM概念(工程对象模型) 
[设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] 
[与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区] 
  
  
功能： 
    
                                
    • 
                                
  • 编程之美-子数组的最大乘积
                                    bylijinnan
编程之美
                                    
    

public class MaxProduct {

	/**
	 * 编程之美 子数组的最大乘积
	 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。
	 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。
	 * 但按题目的意思，是要求得这个子数组，而不
    
                                
    • 
                                
  • 读书笔记-2
                                    chengxuyuancsdn
读书笔记
                                    
    1、反射 
2、oracle年-月-日 时-分-秒 
3、oracle创建有参、无参函数 
4、oracle行转列 
5、Struts2拦截器 
6、Filter过滤器(web.xml) 
 
 
1、反射
(1)检查类的结构
在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。
2、oracle年月日时分秒
s
    
                                
    • 
                                
  • [求学与房地产]慎重选择IT培训学校
                                    comsci
it
                                    
          关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题 
 
      培训学校的教学楼和宿舍的环境和稳定性问题 
 
      我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... 
 
&nb
    
                                
    • 
                                
  • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系
                                    daizj
oraclermanfilespersetPARALLELISM
                                    
    RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转 
 
PARALLELISM --- 
 
我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： 
RMAN > configure device type disk parallelism 3 ; 
表示启动三个通道，可以加快备份恢复的速度。 
    
                                
    • 
                                
  • 简单排序:冒泡排序
                                    dieslrae
冒泡排序
                                    
    
    public void bubbleSort(int[] array){
        for(int i=1;i<array.length;i++){
            for(int k=0;k<array.length-i;k++){
                if(array[k] > array[k+1]){
             
    
                                
    • 
                                
  • 初二上学期难记单词三
                                    dcj3sjt126com
sciet
                                    
    concert 音乐会 
tonight 今晚 
famous 有名的；著名的 
song 歌曲 
thousand 千 
accident 事故；灾难 
careless 粗心的，大意的 
break 折断；断裂；破碎 
heart 心（脏） 
happen  偶尔发生，碰巧 
tourist 旅游者；观光者 
science （自然）科学 
marry 结婚 
subject 题目；
    
                                
    • 
                                
  • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码
                                    dcj3sjt126com
redis
                                    
    wget http://download.redis.io/redis-stable.tar.gz 
tar xvzf redis-stable.tar.gz 
cd redis-stable 
make 
  
前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。 
异常一： 
make[2]: cc: Command not found 
异常原因：没有安装g
    
                                
    • 
                                
  • 并发容器
                                    shuizhaosi888
并发容器
                                    
       通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。 
   并发容器ConcurrentHashMap 
      替代同步基于散列的Map，通过Lock控制。 
  &nb
    
                                
    • 
                                
  • Spring Security（12）——Remember-Me功能
                                    234390216
Spring SecurityRemember Me记住我
                                    
    Remember-Me功能 
  
目录 
  
1.1     概述 
1.2     基于简单加密token的方法 
1.3     基于持久化token的方法 
1.4     Remember-Me相关接口和实现
    
                                
    • 
                                
  • 位运算
                                    焦志广
位运算
                                    
    
一、位运算符Ｃ语言提供了六种位运算符： 
 
& 按位与 
| 按位或 
^ 按位异或 
~ 取反 
<< 左移 
>> 右移 
 
 

1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 
 
例如：9&am
    
                                
    • 
                                
  • nodejs 数据库连接 mongodb mysql
                                    liguangsong
mongodbmysqlnode数据库连接
                                    
    1.mysql 连接 
   package.json中dependencies加入 
  
  
"mysql":"~2.7.0" 
   执行 npm install 
  
   在config 下创建文件 database.js 
    

    
                                
    • 
                                
  • java动态编译
                                    olive6615
javaHotSpotjvm动态编译
                                    
        在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。 
    HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
    
                                
    • 
                                
  • Storm0.9.5的集群部署配置优化
                                    roadrunners
优化storm.yaml
                                    
    nimbus结点配置（storm.yaml）信息： 
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional inf
    
                                
    • 
                                
  • 101个MySQL 的调节和优化的提示
                                    tomcat_oracle
mysql
                                    
    　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。   　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。   　　3. 使用电池供电的RAM（注：RAM即随机存储器）。   　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
    
                                
    • 
                                
  • zoj 3829 Known Notation(贪心)
                                    阿尔萨斯
ZOJ
                                    
     题目链接：zoj 3829 Known Notation 
 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。 
 解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
    
                                
    •