Java进阶知识 —— 垃圾回收机制

版权声明：欢迎转载，希望声明出处http://blog.csdn.net/dazhaodai https://blog.csdn.net/dazhaoDai/article/details/81182396

1. 垃圾回收机制

• 垃圾回收的意义
  当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾，JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是”无用信息”，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。事实上，除了释放没用的对象，垃圾回收也可以清除内存记录碎片。

• 垃圾收集的算法分析
  1.为什么会有年轻代

  我们先来屡屡，为什么需要把堆分代？不分代不能完成他所做的事情么？其实不分代完全可以，分代的唯一理由就是优化GC性能。你先想想，如果没有分代，那我们所有的对象都在一块，GC的时候我们要找到哪些对象没用，这样就会对堆的所有区域进行扫描。而我们的很多对象都是朝生夕死的，如果分代的话，我们把新创建的对象放到某一地方，当GC的时候先把这块存“朝生夕死”对象的区域进行回收，这样就会腾出很大的空间出来。

  2.年轻代中的GC

  HotSpot JVM把年轻代分为了三部分：1个Eden区和2个Survivor区（分别叫from和to）。默认比例为8：1,为啥默认会是这个比例，接下来我们会聊到。一般情况下，新创建的对象都会被分配到Eden区(一些大对象特殊处理),这些对象经过第一次Minor GC后，如果仍然存活，将会被移到Survivor区。对象在Survivor区中每熬过一次Minor GC，年龄就会增加1岁，当它的年龄增加到一定程度时，就会被移动到年老代中。

  因为年轻代中的对象基本都是朝生夕死的(80%以上)，所以在年轻代的垃圾回收算法使用的是复制算法，复制算法的基本思想就是将内存分为两块，每次只用其中一块，当这一块内存用完，就将还活着的对象复制到另外一块上面。复制算法不会产生内存碎片。

  在GC开始的时候，对象只会存在于Eden区和名为“From”的Survivor区，Survivor区“To”是空的。紧接着进行GC，Eden区中所有存活的对象都会被复制到“To”，而在“From”区中，仍存活的对象会根据他们的年龄值来决定去向。年龄达到一定值(年龄阈值，可以通过-XX:MaxTenuringThreshold来设置)的对象会被移动到年老代中，没有达到阈值的对象会被复制到“To”区域。经过这次GC后，Eden区和From区已经被清空。这个时候，“From”和“To”会交换他们的角色，也就是新的“To”就是上次GC前的“From”，新的“From”就是上次GC前的“To”。不管怎样，都会保证名为To的Survivor区域是空的。Minor GC会一直重复这样的过程，直到“To”区被填满，“To”区被填满之后，会将所有对象移动到年老代中。

  

  3.一个对象的这一辈子
  我是一个普通的Java对象，我出生在Eden区，在Eden区我还看到和我长的很像的小兄弟，我们在Eden区中玩了挺长时间。有一天Eden区中的人实在是太多了，我就被迫去了Survivor区的“From”区，自从去了Survivor区，我就开始漂了，有时候在Survivor的“From”区，有时候在Survivor的“To”区，居无定所。直到我18岁的时候，爸爸说我成人了，该去社会上闯闯了。于是我就去了年老代那边，年老代里，人很多，并且年龄都挺大的，我在这里也认识了很多人。在年老代里，我生活了20年(每次GC加一岁)，然后被回收。

---

  JVM 新生代老年代
  https://www.cnblogs.com/E-star/p/5556188.html

---

2. 常见编码方式

• 1.ASCII
  共有128个，用一个字节的低7位表示
  0~31 控制字符 如换行、回车、删除
  32~126 打印字符
• 2.GB2312
• 3.GBK
• 4.UTF-16
• 5.UTF-8

3. 静态代理和动态代理的区别，以及使用场景

原因是采用代理模式可以有效的将具体的实现与调用方进行解耦，通过面向接口进行编码完全将具体的实现隐藏在内部
- 1.静态代理
静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能
- 2.动态代理
动态代理类：在程序运行时，运用反射机制动态创建而成。

静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。

静态代理Demo

public interface Iuser {
 　　void eat(String s);
}


public class UserImpl implements Iuser {
　　@Override
　　public void eat(String s) {
　　　　System.out.println("我要吃"+s);
　　}
}


public class DynamicProxy implements InvocationHandler {
　　private Object object;//用于接收具体实现类的实例对象
　　//使用带参数的构造器来传递具体实现类的对象
　　public DynamicProxy(Object obj){
　　　　this.object = obj;
　　}
　　@Override
　　public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
　　　　System.out.println("前置内容");
　　　　method.invoke(object, args);
　　　　System.out.println("后置内容");
　　　　return null;
　　}
}


public class ProxyTest {
　　public static void main(String[] args) {
　　　　Iuser user = new UserImpl();
　　　　InvocationHandler h = new DynamicProxy(user);
　　　　Iuser proxy = (Iuser) Proxy.newProxyInstance(Iuser.class.getClassLoader(), new Class[]{Iuser.class}, h);
　　　　proxy.eat("苹果");
　　}
}

动态代理Demo

public interface Iuser {
 　　void eat(String s);
 }


public class UserImpl implements Iuser {
　　@Override
　　public void eat(String s) {
　　　　System.out.println("我要吃"+s);
　　}
}

public class DynamicProxy implements InvocationHandler {
　　private Object object;//用于接收具体实现类的实例对象
　　//使用带参数的构造器来传递具体实现类的对象
　　public DynamicProxy(Object obj){
　　　　this.object = obj;
　　}
　　@Override
　　public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
　　　　System.out.println("前置内容");
　　　　method.invoke(object, args);
　　　　System.out.println("后置内容");
　　　　return null;
　　}
}

public class ProxyTest {
　　public static void main(String[] args) {
　　　　Iuser user = new UserImpl();
　　　　InvocationHandler h = new DynamicProxy(user);
　　　　Iuser proxy = (Iuser) Proxy.newProxyInstance(Iuser.class.getClassLoader(), new Class[]{Iuser.class}, h);
　　　　proxy.eat("苹果");
　　}
}

4. 如何将一个Java对象序列化到文件

让对象实现Serializable接口或者Parcelable接口

   public void saveObjToFile(Person p){  
        try {  
            //写对象流的对象  
            ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(fileName));  

            oos.writeObject(p);                 //将Person对象p写入到oos中  

            oos.close();                        //关闭文件流  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }   
    }  

    /* 
     * 从文件中读出对象，并且返回Person对象 
     */  
    public Person getObjFromFile(){  
        try {  
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream(fileName));  

            Person person=(Person)ois.readObject();              //读出对象  

            return person;                                       //返回对象  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  

        return null;  
    }  

5. Java反射的理解

反射的含义

反射(Reflection)是Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性

简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。
程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。
 反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。

Java反射框架主要提供以下功能：

• 1.在运行时判断任意一个对象所属的类；
• 2.在运行时构造任意一个类的对象；
• 3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；
• 4.在运行时调用任意一个对象的方法
  

  重点：是运行时而不是编译时

反射的运用

1、获得Class对象

---

方法有三种 - (1)使用Class类的forName静态方法:

 public static Class<?> forName(String className)
 ```
 - (2)直接获取某一个对象的class，比如:
 ```
 Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

• (3)调用某个对象的getClass()方法,比如:

StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

2、判断是否为某个类的实例

---

一般地，我们用instanceof关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的isInstance()方法来判断是否为某个类的实例，它是一个Native方法：

public native boolean isInstance(Object obj);

3、创建实例

---

通过反射来生成对象主要有两种方式。
- （1）使用Class对象的newInstance()方法来创建Class对象对应类的实例。

Class<?> c = String.class;
Object str = c.newInstance();

• （2）先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例。

//获取String所对应的Class对象
Class<?> c = String.class;
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);
//根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

4、获取方法

---

获取某个Class对象的方法集合，主要有以下几个方法：
getDeclaredMethods()方法返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

public Method[] getDeclaredMethods() throws SecurityException

getMethods()方法返回某个类的所有公用（public）方法，包括其继承类的公用方法。

public Method[] getMethods() throws SecurityException

getMethod方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象

public Method getMethod(String name, Class<?>... parameterTypes)

getMethod 中方法 需要是public，才能获取到

用例子说明一下，加深理解

    private void testReflect(){
        try {
            Class<?> cls = Class.forName("hard.uistudy.dai.uifinaltest.main.view.activity.MainActivity6");
            try {
                Object object =  cls.newInstance();
              Method[] methods =  cls.getMethods();
              Method[] declaredMethods = cls.getDeclaredMethods();
                for (Method m: methods) {
                    Log.e("method",m.toString());
                }
                for (Method m: declaredMethods) {
                    Log.e("declaredMethods",m.toString());
                }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

5、获取构造器信息

---

获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例:

public T newInstance(Object ... initargs)

此方法可以根据传入的参数来调用对应的Constructor创建对象实例~

6、获取类的成员变量（字段）信息

---

主要是这几个方法，在此不再赘述：
getFiled: 访问公有的成员变量
getDeclaredField：所有已声明的成员变量。但不能得到其父类的成员变量
getFileds和getDeclaredFields用法同上（参照Method）

 private void testReflect(){
        try {
            Class<?> cls = Class.forName("hard.uistudy.dai.uifinaltest.main.view.activity.MainActivity6");
            try {
              Object object =  cls.newInstance();
              Method[] methods =  cls.getMethods();
              Field[] fields = cls.getDeclaredFields();
              for (Field field: fields ) {
                    Log.e("Field",field.toString());
              }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

7、调用方法

---

当我们从类中获取了一个方法后，我们就可以用invoke()方法来调用这个方法。invoke方法的原型为:

public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException

参考下面的实例：

public class test1 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> klass = methodClass.class;
        //创建methodClass的实例
        Object obj = klass.newInstance();
        //获取methodClass类的add方法
        Method method = klass.getMethod("add",int.class,int.class);
        //调用method对应的方法 => add(1,4)
        Object result = method.invoke(obj,1,4);
        System.out.println(result);
    }
}
class methodClass {
    public final int fuck = 3;
    public int add(int a,int b) {
        return a+b;
    }
    public int sub(int a,int b) {
        return a+b;
    }
}

8、利用反射创建数组

---

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference。下面我们看一看利用反射创建数组的例子：

public static void testArray() throws ClassNotFoundException {
        Class<?> cls = Class.forName("java.lang.String");
        Object array = Array.newInstance(cls,25);
        //往数组里添加内容
        Array.set(array,0,"hello");
        Array.set(array,1,"Java");
        Array.set(array,2,"fuck");
        Array.set(array,3,"Scala");
        Array.set(array,4,"Clojure");
        //获取某一项的内容
        System.out.println(Array.get(array,3));
    }

注意事项

由于反射会额外消耗一定的系统资源，因此如果不需要动态地创建一个对象，那么就不需要用反射。
另外，反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

---

  原文: http://www.sczyh30.com/posts/Java/java-reflection-1/　　作者: sczyh30

---