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解析)






    

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    

    • 

  • 迎接2019
唯有杜康1994

    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    

    • 

  • 亲子日记之祝姑姥姥生日快乐（282）
冰心雨露_d504

    2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
    

    • 

  • 数据结构奇妙旅程之深入解析快速排序
山间漫步人生路
数据结构排序算法算法

    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
    

    • 

  • 被隔离的日子（五）@三七会写作营
三七会萍海临风

    从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
    

    • 

  • android 自定义曲线图,Android自定义View——贝赛尔曲线
weixin_39767513
android自定义曲线图

    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
    

    • 

  • word字号和mathtype磅值关系及批量修改
小铁匠-Ma
office小技巧经验分享

    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
    

    • 

  • 易经第六十一卦风泽中孚
徐徐微风正好

    易经第六十一卦风泽中孚，巽上兑下。中孚：豚鱼吉，利涉大川，利贞。中孚卦象征着中心诚信，甚至诚信到了能够感动小猪小鱼，可获吉祥，对渡过大河巨流有利，对坚守正道有利。诚信是立人之本，立身处世心怀诚信广施仁义才会走的长远。但是诚信也要合理合时，君子从中得到启示，要以诚信的德行慎重审议案件并宽缓死刑。诚信可以使人信服，有利于坚守中正，内在谦逊柔顺外在坚守行动诚信，连最顽固的老百姓都被感化，天何言哉，四时行
    

    • 

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 信任
饮冰伊乔

    随着社会的发展，微信和支付宝交易给人们带来了极大的方便，越来越多的人出门都只选择拿一部手机即可，方便安全，可昨天我就遇到了一件比较尴尬的事。昨天傍晚，我从公司出来，感觉有点饿，决定索性吃了饭再回去，来到去过几次的一个店里，如往常一样叫了餐，当时店里吃饭的不多，老板麻利的先去做了，正要扫微信付账的时候发现手机没电了，迷之尴尬，我只好跟老板说不用做了，手机没电了，我身上又没现金，付不了帐了。老板娘很热
    

    • 

  • Django之Debug篇
菜鸟之编程
Djangodjangopython后端

    一、DebugToolBar基本使用1.1、概述Django框架的调试工具栏使用django-debug-toolbar库，是一组可配置的面板，显示有关当前请求/响应的各种调试信息，点击时，显示有关面板内容的更多详细信息。官方文档：DjangoDebugToolbar—DjangoDebugToolbar4.3.0documentation1.2、安装pipinstalldjango-debug-
    

    • 

  • 亲子日记 3月15日 星期四
侯耀斐妈妈

    今天的天气跟昨天相比简直是两重天，昨天热的不行，今天又冷的不行，今天不用出门，都听到风呼呼的刮着。昨天晚上剩下一点土豆丝，今天早晨和孩子做了卷饼吃，侯耀斐说特别好吃，说晚上还想再吃一顿，哈哈，真是太容易满足了，就这点要求立马答应了。晚上孩子一回家就说饿了，问中午干嘛了，说是吃的太少了。自己找了饼干先吃了一点。爸爸下班后炒了土豆丝，炖了豆腐，搭配卷饼又吃了一顿，心想如果孩子能天天像今天这样好好吃饭可
    

    • 

  • 2021.12.13 自律日记
夏舒帅然a

    深感时光转瞬即逝，如指缝流金！自律、习惯养成、执行力提高迫在眉睫！今天是什么日子：平日艳阳天起床：7：50任务清单（明日）1.起床：7:302.就寝：10：103.读书30分钟4.打两套太极5.两次静坐（每次15分钟）昨日完成的任务情况，最重要的三件事一.读书30分。未完成二.就寝10：00完成三.起床7：30未完成四.打两套太极未完成五.两次静坐（每次15分钟）未完成习惯养成：早睡早起、每日读书
    

    • 

  • 以高质量调查研究助力组织工作提质增效
木同木同

    近日，中共中央办公厅印发了《关于在全党大兴调查研究的工作方案》(后简称《方案》），要求各地区各部门结合实际认真贯彻落实。调查研究是我们党的传家宝，是谋事之基、成事之道。组织部门作为党管干部的核心部门，肩负着管党员、管干部、管人才的重要职责，调查研究更是把握组织工作规律、破解组织工作难题的重要办法。要用好调查研究这一法宝，把准政治方向，贯穿问题导向，坚持实事求是，以高质量调查研究助力组织工作提质增效
    

    • 

  • 地低为海人低为王
缘梦草

    地低为海，人低为王。低，高之基，高，低之顶。谦虚才能收益，咄咄逼人会招损。高粱熟了，头会低下。受益反而会深藏不露。捧人之术，把人捧高，然后控制。受控之人，大都是虚荣心作祟。活成别人想象中的样子，像别人想象中那么有面子的活着是悲哀的。穷不可怕，怕的是虚荣心。当你好面子，你就会被控制。一旦受虚荣心控制，你不得不谨小慎微的维护面子，付出多余的能量，希望得到别人的一句赞。面子就是金子打造的牢笼，让你在赞美
    

    • 

  • 标定系列——基于OpenCV实现普通相机、鱼眼相机不同标定板下的标定（五）
JANGHIGH
标定opencv

    标定系列——基于OpenCV实现相机标定（五）说明代码解析VID5.xmlin_VID5.xmlcamera_calibration.cpp说明该程序可以实现多种标定板的相机标定工作代码解析VID5.xmlimages/CameraCalibration/VID5/xx1.jpgimages/CameraCalibration/VID5/xx2.jpgimages/CameraCalibratio
    

    • 

  • 计划比盲目做重要
一祉微笑

    坚持分享第99天。一次次会议提醒着老师们假期余额不足，马上面临停机状态。50多天掐指而过，想想放假时的计划，对照如今的完成情况，感觉差太远。想着好好看书，如今50多天过去了第6本还处在未完待续状态；想着假期好好陪陪孩子，在玩中学一些知识，如今想想，孩子学的真不多；想着暑假坚持跑步，有时还是容易给自己找借口，休息三两天。给这个假期一个综合评价，只能说只完成了计划的百分之五六十。想想为什么临近开学没达
    

    • 

  • 关于举办第十五届蓝桥杯全国软件和信息技术专业人才大赛项目实战赛的通知
QSNKJJSW
蓝桥杯职场和发展青少年编程无人机机器人科技人工智能

    各高等院校及相关单位：为贯彻落实《中国教育现代化2035》和《国务院关于印发新时期促进集成电路产业和软件产业高质量发展若干政策的通知》有关精神，为我国制造强国和网络强国战略提供人才支持，提高学生自主创新意识和工程实践能力，工业和信息化部人才交流中心决定举办第十五届蓝桥杯全国软件和信息技术专业人才大赛——项目实战赛。大赛连续四年入围中国高等教育学会“全国普通高校大学生竞赛排行榜”竞赛项目榜单。现将项
    

    • 

  • docker怎么端口映射
Lance_mu
docker容器运维

    1、默认固定的端口#Web服务器：WebApache或Nginx通常使用80端口HTTP：80HTTPS：443#数据库服务器MySQL：3306PostgreSQL：5432MongoDB：27017Redis：6379#邮件服务器SMTP：25POP3：110IMAP：143#其他服务SSH：22FTP：21DNS（域名解析）：53代理服务器Squid：3128版本控制系统Git：9418(S
    

    • 

  • 新注册的阿里云账号有哪些优惠？阿里云新用户必看优惠大合集
阿里云最新优惠和活动汇总

    很多用户看到阿里云各种活动中的云服务器、云数据库、企业邮箱等云产品都仅限新用户购买之后，都纷纷直接注册了阿里云新账号之后购买，其实，阿里云新用户不仅可以优惠购买活动中的各种云产品，还有很多优惠，下面是“阿里云最新优惠和活动汇总”整理汇总的阿里云新用户必看优惠大合集。新注册的阿里云账号在购买活动中的云产品之前，还有免费领云产品通用代金券、抽取无门槛代金券、免费试用云服务器和正式购买云服务器等阿里云产
    

    • 

  • Golang标准库fmt深入解析与应用技巧
walkskyer
golang标准库golangjava数据库

    Golang标准库fmt深入解析与应用技巧前言fmt包的基本使用打印与格式化输出函数Print系列函数格式化字符串格式化输入函数小结字符串格式化基本类型的格式化输出自定义类型的格式化输出控制格式化输出的宽度和精度小结错误处理与fmt使用fmt.Errorf生成错误信息fmt包与错误处理的最佳实践小结日志记录与fmtfmt包在日志记录中的应用结合log包使用fmt进行高级日志处理小结fmt与IOfm
    

    • 

  • 081天 约柜失而复得
宁宁2018

    撒迦利亚书4:6他对我说：“这是耶和华指示所罗巴伯的。万军之耶和华说：‘不是倚靠势力，不是倚靠才能，乃是倚靠我的灵方能成事。’
    

    • 

  • 剧本杀【幕后玩家】复盘解析+凶手是谁+剧透结局+测评+怎么玩？
VX搜_彤彤速递

    每天持续更新复盘有15000＋：线下剧本杀·百变大侦探·我是谜·谁是凶手·玩吧·剧本杀线上·戏精大侦探·魔王杀·儿童剧本杀...所有谜题在等着你去揭开。为了你获得更好的游戏体验，本文仅显示《幕后玩家》剧本杀部分真相复盘，获取完整真相复盘只需两步①【微信关注公众号：云云复盘】②回复【幕后玩家】即可查看获取哦贾友仁利用自己保险公司的职务，在杨光审车时，隐瞒了车子存在刹车不灵的问题。想让杜若出车祸死亡，
    

    • 

  • 《金文成〈正蒙〉日记124。2020-11-9》
金吾生

    《金文成〈正蒙〉日记124。2020-11-9》今天是庚子丁亥丙子，九月廿四，2020年11月9日星期一。作者篇7【舜之孝，汤、武之武，虽顺逆不同，其为不幸均矣。】船山讲解说，顺，指的是舜的父亲最终受到感化，转变了态度，结局圆满之事；逆，指的是＂桀放、纣诛＂，即，商汤放桀，周武诛纣，都是采用暴力，不是感化方式，所以是逆。顺与逆，都是为了解决弊政，然其差异之大如此，然而，无论圆满还是遗憾，其实他们都
    

    • 

  • 【奶茶剧本杀】玩吧《梨园醉》剧本杀凶手是谁剧透+真相答案复盘解析攻略
VX搜_奶茶剧本杀

    本文为玩吧剧本杀《梨园醉》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复玩吧剧本杀《梨园醉》即可获取查看玩吧剧本杀《梨园醉》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
    

    • 

  • 如何把大象装进冰箱的思考 210624
大丁_初心生活

    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
    

    • 

  • python转码
Desamond
python开发语言

    转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
    

    • 

  • 今日阅读任务
扎西措的简书

    四圣谛是总纲释迦牟尼佛开示的法很多，其中四圣谛是纲要。一般祖师们讲经或讲论时，会先讲“略”的，再讲“广”的，先讲纲要，把方向抓出来，再慢慢慢慢发展;如果一开始就从头讲到尾，可能会让听者东南西北都搞不清。先把大纲抓住，就容易与别的法连结。释尊所讲的所有法当中，包括小乘、大乘、显教、密教的法，总的来说，四圣谛是纲要，不论南传的小乘佛教、或是汉传与藏传的大乘佛教，四圣谛是大家共同承认的、大家共有的基础。
    

    • 

  • 解锁开心生命密码 NO.4
糊糊陪你瑜伽

    第四次的沟通是围绕着“何为真我”展开的。让我知道，原来真我的外面围了这么多层的“伪装”。真我-疗愈性事件-低层自我-信息系统-防御系统-面具自我，就是这样一层又一层的包裹让我们迷失了真我。谈到疗愈性事件，我甚至有点说不上来，尤其对童年的记忆是很模糊的，也说不上什么原因。通过分享三件自己的疗愈性事件，看到了事件发生时低层的自我，那是真我的反面。有这样低层的自我，形成了当时的信念系统和防御系统，才有了
    

    • 

  • 风险管理和采购管理核心考点梳理
WorkLee
PMPPMP风险管理采购管理

    个人总结，仅供参考，欢迎加好友一起讨论PMP-风险管理和采购管理核心考点梳理风险管理风险是一个中性词，包括机会和威胁。风险管理的子过程非常多，但是相对来说子过程之间的逻辑非常清晰，整个风险管理的过程都是在维护一个非常重要的工件-风险登记册。风险管理是项目管理全生命周期都要开展的。1）规划风险管理风险管理计划包含哪些内容？解析：风险管理计划是描述如何安排与实施风险管理活动。（风险管理计划中无风险）包
    

    • 

  • 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
    

    •