面试题和错题总结_ajax,序列化,内存回收（一）_数据序列化垃圾回收-优快云博客

1、由服务器返回前端html界面json数据的时候发现返回对象的时候，总是[object object]
解决方法：经查明返回的结果需要使用JSON.stringify(message)进行转换

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    //如果想使用ajax 必须导入这个包，可以在菜鸟教程jQuery中找到，这里使用的是微软的
    使用谷歌的不行
    <script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-1.9.0.min.js"></script>
</head>
<body>
    <input name="data" id="data">
    <input type="button" id="btu" value="点我啊" onclick="abc()"/>


    <script type="text/javascript">

        function abc() {
            var data = document.getElementById("data").value;
            alert("这句话执行了");
            $.ajax({
                url:"/test/getone",
                type:"Get",
                data:"i="+data,
				//dataType  期望服务器返回的数据的类型为json
                dataType:"json",  
                success:function (message) {
                    // alert(message.data());
                    //将json字符串转换成对象的格式
                    alert(JSON.stringify(message));
                }
            })

        }

    </script>
</body>
</html>

对象的序列化和反序列化
把对象转换为字节序列的过程称为对象的序列化。
　　把字节序列恢复为对象的过程称为对象的反序列化。
　　对象的序列化主要有两种用途：
　　1）把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
　　2）在网络上传送对象的字节序列。
ObjectOutputStream writeObject 序列化
ObjectInputStream readObject 反序列化

package com.qf.serializable.test;

import com.qf.serializable.pojo.People;
import org.junit.Test;

import java.io.*;

/**
 * @author dongbo
 * @date 2018/11/12 8:49
 */
public class TestMain {

    @Test
    public void test(){
        //执行序列化
        testSerializable();
        //反序列化
        People people = fanSerializable();
        System.out.println(people);

    }


    /**
     * 序列化对象
     */
    public void testSerializable(){

        People people = new People();
        people.setId(1);
        people.setName("张三");
        people.setGender("男");
        people.setAge(20);
        File file = new File("D:\\aa\\bb.txt");
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
            outputStream.writeObject(people);
            System.out.println("序列化对象成功");
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 反序列化
     * @return
     */
    public People fanSerializable(){

        File  file = new File("D:\\aa\\bb.txt");
        try {
            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
            People people = (People) inputStream.readObject();
            System.out.println("反序列化成功");
            inputStream.close();
            return people;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;

    }

}

如果对对象进行序列化，那么该对象必须实现serializable接口

package com.qf.serializable.pojo;

import java.io.Serializable;

/**
 * 只有实现了Seralizable 和 Externalizable 接口的类的对象才能被序列化，Externalizable 接口继承自
 * Serializable 接口，实现 Exteralizable 接口的类完全有自身来控制序列化的行为，而仅实现Serializable
 * 接口的类可以采用默认的序列化方式
 * @author dongbo
 * @date 2018/11/12 8:41
 */
public class People implements Serializable {


    private static final long serialVersionUID = -6194049175448250781L;
    private int id;
    private String name;
    private String gender;

    private int age;


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "People{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
}

在实例对象中有一句对象的序列号：
private static final long serialVersionUID = -6194049175448250781L;
这是对象的唯一标识，如够类中没有序列号，则当对一个对象序列后，在类中添加了一个属性，那么如果再反序列化这个对象，则就会报错，加上就可以避免这个问题

3、java垃圾回收（GC）机制
点一：那些内存需要回收
1、引用计数法
这个算法的实现是，给对象添加一个引用计数器，每当一个地方引用这个对象时，计数器值+1，当引用失效时，计数器值-1，任何时刻计数值为0的对象就是不可能被使用的，但是java中没有使用这种算法，如特殊情况

        ReferenceCountingGC objectA = new ReferenceCountingGC();
        ReferenceCountingGC objectB = new ReferenceCountingGC();
        objectA.instance = objectB;
        objectB.instance = objectA;
        objectA = null;
        objectB = null;
        
        System.gc();
    }

上述中object A 和 object B两个对象相互引用者，所以永远无法将这两个对象清除掉
方法二：可达性分析法
这个算法的基本思想是通过一系列称为 "GC Roots"的对象作为起始点，从这些节点向下搜索，搜索做过的路径称为引用链，当一个对象到GC Roots 没有任何引用链（即GC Roots 到对象不可达）时，则证明此对象是不可用的。
在这里插入图片描述

点二：四种引用状态
1、强引用
代码中普遍存在的类似 "Object obj = new Object()"这类的引用你，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象
2、软引用
描述还有些用但并非必须的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常，java中的SoftReference 表示软引用
3、弱引用
描述非必须对象，被弱引用关联的对象只能生存到下一次垃圾回收之前，垃圾收集器工作之后，无论当前内存是否足够，都会回收掉只被弱引用关联的对象java中的类 WeakReference表示弱引用
4、虚引用
这个引用存在的唯一目的就是在这个对象呗收集器回收时收到一个系统通知，被虚引用关联的对象，和其生存时间完全没有关系，java中的类PhantomReference表示虚引用
在这里插入图片描述
对于可达性分析算法而言，未到达的对象并非是“非死不可”的，若要宣判一个对象死亡，至少需要经历两次标记阶段。

如果对象在进行可达性分析后发现没有与GCRoots相连的引用链，则该对象被第一次标记并进行一次筛选，筛选条件为是否有必要执行该对象的finalize方法，若对象没有覆盖finalize方法或者该finalize方法是否已经被虚拟机执行过了，则均视作不必要执行该对象的finalize方法，即该对象将会被回收。反之，若对象覆盖了finalize方法并且该finalize方法并没有被执行过，那么，这个对象会被放置在一个叫F-Queue的队列中，之后会由虚拟机自动建立的、优先级低的Finalizer线程去执行，而虚拟机不必要等待该线程执行结束，即虚拟机只负责建立线程，其他的事情交给此线程去处理。

2.对F-Queue中对象进行第二次标记，如果对象在finalize方法中拯救了自己，即关联上了GCRoots引用链，如把this关键字赋值给其他变量，那么在第二次标记的时候该对象将从“即将回收”的集合中移除，如果对象还是没有拯救自己，那就会被回收。如下代码演示了一个对象如何在finalize方法中拯救了自己，然而，它只能拯救自己一次，第二次就被回收了。