java_JVM+java_反射 itEighteen(每启动一个java程序，它都是一个单独的java虚拟机)

runtime data area
--------------------
    1.method area(共享)
    2.heap  (共享)
    3.java stack(非)
    4.native method stack(非)
    5.program couter register(非)

    method frame(stack frame)

从heap角度
-------------
    1.heap      //
        young gen(eden + survivor0 + survivor 2) + old gen.
    2.non-heap
        perm | metaspace
    3.off-heap
        jvm之外的内容

jvm调优
--------------
    -Xmx
    -Xms
    -Xmn        //young 
    -XX:NewSize=
    -XX:MaxNewSize=


java -Xmx xx.x.xx.App



反射
--------------
    动态访问对象的属性和方法。
    Class           //类
    Method          //方法，成员函数
    Field           //字段,成员变量
    Constructor     //构造函数

    private


Field[] fs = getDeclaredFields()
for(Field f : fs){
    get + ""
}

JVM
----------------
    java virtual machine.
栈区
堆区
方法区
dll(windows)
-----------
    dynamic link library,动态链接库
    函数库 + 资源.
so(linux)
-------------
    shared object,共享对象

*.java ---> *.class --> ClassLoader(加载到JVM当中)

//类类,类的描述符
Class clazz = Person.class ;

OOM
-------------------
    Outof memory,内存溢出.

www.StackOverflow.com
---------------------


从Runtime data area角度划分
-------------------
    1.Method area
        方法区.
        存放类描述符.
        Class只需加载一次。
        扩容.
        maven
        共享。
        Class.forName("");//加载类，用到谁加载谁，加载进来就不出去了，常住在这里。
        用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译后的代码等信息。方法区是线程间共享的，当两个线程同时需要加载一个类型时，只有一个类会请求ClassLoader加载，另一个线程会等待。


    2.heap
        堆区.
        虚拟机中用于存放对象与数组实例的地方，垃圾回收的主要区域就是这里（还可能有方法区）。
        在所有线程间共享

    3.java stack
        每个线程对应一个栈。
        每个进程至少有个一个线程(主线程).
        method frame(stack frame).
        虚拟机栈也是线程私有的，每创建一个线程，虚拟机就会为这个线程创建一个虚拟机栈，虚拟机栈表示Java方法执行的内存模型，每调用一个方法，就会生成一个栈帧（Stack Frame）用于存储方法的本地变量表、操作栈、方法出口等信息，当这个方法执行完后，就会弹出相应的栈帧。如果请求的栈的深度过大，虚拟机可能会抛出StackOverflowError异常，如果虚拟机的实现中允许虚拟机栈动态扩展，当内存不足以扩展栈的时候，会抛出OutOfMemoryError异常。


    4.native method stack
        native方法。
    5.program counter register
        略.


从heap角度划分
----------------------
    heap(堆):    虚拟机中用于存放对象与数组实例的地方，垃圾回收的主要区域就是这里（还可能有方法区）。
    non-heap(非堆):    
    off-heap(离堆):    JVM虚拟机之外的内存
    堆和非堆构成了java虚拟机的内存结构

通过jdk自带jvisualvm软件考察
-------------------------------
    1.cmd>jvisualvm
    2.安装visualgc的插件
        工具菜单 --> 插件 -> visual gc ->安装.

jconsole
---------------------

jmap
------------
    1.查看堆信息
        jmap -heap 19524
    2.查看永久区
        jmap -permstat 19524
    3.查看类加载信息
        jmap -clstats 19524

JVM调优
-------------
    -Xms            //堆初始值  1/64( < 1G)
    -Xmx            //堆最大值  1/4 ( < 1G)
    -Xmn            //年轻代(eden + s0 + s1),-Xmn150M

    -XX:NewSize     //for 1.3/1.4/1.8,设置年轻代大小
                    //-XX:NewSize=150m
                    //优先级 > NewRatio.

    -XX:MaxNewSize  //for 1.3/1.4/1.8,设置年轻带大小最大值

    -XX:PermSize    //设置永久代值,1.8移除了该属性
                    //-XX:PermSize=150m
    -XX:MaxPermSize //设置永久代值最大值
                    //-XX:MaxPermSize=150m

    -XX:MetaspaceSize=2048m
    -XX:MaxMetaspaceSize=2048m
    -XX:CompressedClassSpaceSize=2048m      //***** 设置1.8的meta区 *****

    -Xss            //栈空间
    -XX:NewRatio    //年轻代和年老代的比例，-XX:NewRation=n,
                    //代表 年轻代 : 年老代 = 1 : n
                    //-XX:NewRatio=2
                    //-XX:NewRatio=0.5,错误的，不能指定小数。

    -XX:SurvivorRatio   //设置,单个幸存区 : 伊甸区 = 1 : n 
                        //-XX:SurvivorRatio=2,



java com.it18zhang.java24.jvm.TestJVM

    old   : 133.5M
    young : 8  + 8 + 50.5 = 66.5M

    young : old  = 1 : 2        //

    eden : survivor = 3 : 1     //

ClassLoader加载
----------------
    1.转换类名到location,定位class文件。
    2.
    3.

java集合就两种容器==数组(连续分配的内存空间)+链表(通过指针之间的引用来保存它们之间的关系)。

    x instanceof Person ;           //模糊判断.
    getClass() == Person.class ;    //精准判断

反射
-----------------
    动态访问对象的属性和方法。
    Person p = new Person();
    p.setName("xxx");
    p.getName();

    1.Class
        类的描述符.
        描述类的特征。
        Person.class ;
        Class clazz = Class.forName();
        Class clazz = Xxx.class()
        Class clazz = obj.getClass();


    2.Method
        方法.
        方法描述符。
        //得到类中声明的方法(private + public + protected)
        Method m = clazz.getDeclaredMethod("name",...);

        //得到所可用的方法(继承的方法)·
        Method m = clazz.getMethod("name",...);

        //
        m.setAccessible(true);

    3.Field
        字段。
        字段描述符.
        Field f = clazz.getField("name");
        Field f = clazz.getDeclaredField("name");
        f.setAccessible(True);

    4.Constructor
        构造函数描述符.
        clazz.getConstructor(Class...)

package com.it18zhang.java24.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

import com.it18zhang.java24.jvm.Person;

public class TestReflect {
    /**
     * 测试Class
     */
    @Test
    public void testClass(){
        Person p = new Person();
        Class clazz = p.getClass();
        Class clazz2 = Person.class ;
        System.out.println(clazz.hashCode());
        System.out.println(clazz2.hashCode());
        System.out.println(clazz.getName());
    }

    /**
     * 动态访问对象的属性和方法。
     * 反射的出发点是类，方法，字段。
     */
    @Test
    @SuppressWarnings({ "rawtypes", "unused" })
    public void testNewInstance() throws Exception{
        //加载类,返回Class对象
        Class clazz = Class.forName("com.it18zhang.java24.jvm.Person");

        //通过Class动态创建对象.
        Object obj = clazz.newInstance();

        //得到setName(String x);
        Method m = clazz.getDeclaredMethod("setName",String.class,String.class);

        //设置可访问性
        m.setAccessible(true);

        //等价于obj.setName("tom");
        m.invoke(obj, "t","om");

        System.out.println("xxx");

        //动态取得getName方法
        Method m2 = clazz.getDeclaredMethod("getName");
        Object ret = m2.invoke(obj);
        System.out.println(ret);

        //Field,字段描述符
        Field f = clazz.getDeclaredField("name");
        f.setAccessible(true);
        ret = f.get(obj);
        System.out.println(ret);

        f.set(obj, "jerry");

        System.out.println("xxx");

        //得到所有可用的方法
        Method[] ms = clazz.getMethods();
        for(Method mm : ms){
            String fname = mm.getName();
            Class[] ptypes = mm.getParameterTypes();
            if(fname.startsWith("get") && (ptypes == null || ptypes.length == 0)){
                //修饰符总和
                int mod = mm.getModifiers();
                System.out.println(Modifier.isPublic(mod));

                ret = mm.invoke(obj);
                System.out.println(fname + " = " + ret);
            }
            //System.out.println(mm.toString());
        }
//      System.out.println("===================");
//      //得到该类声明的方法
//      ms = clazz.getDeclaredMethods();
//      for(Method mm : ms){
//          System.out.println(mm);
//      }
    }

    /**
     * Constructor，构造函数描述符
     */
    @Test
    public void testConstructor() throws Exception{
        Class vc = void.class; 
        System.out.println(vc.isPrimitive());

        Class clazz = Class.forName("com.it18zhang.java24.jvm.Person");
        Constructor c1 = clazz.getDeclaredConstructor(String.class,int[][][][].class);
        c1.setAccessible(true);
        Object obj = c1.newInstance("tom",12);
        System.out.println(obj);

        Method[] ms = clazz.getMethods();
        for(Method mm : ms){
            String fname = mm.getName();
            Class rtype = mm.getReturnType();
            if(rtype == void.class){
                System.out.println(fname);
            }
        }
    }

    @Test
    public void testCopy() throws Exception{
        Person a = new Person();
        a.setName("tom");
        a.setAge(12);

        Person b = new Person();
        propCopy(a,b);
        System.out.println("xx");
    }

    /**
     * 属性复制
     */
    public void propCopy(Person a , Person b) throws Exception{
        Class clazz = a.getClass();
        Field[] fs = clazz.getDeclaredFields();
        for(Field f : fs){
            f.setAccessible(true);
            Object ret = f.get(a);
            f.set(b, ret);
        }
    }
}