1. Integer是int的包装类，int则是java的一种基本数据类型
2. Integer变量必须实例化后才能使用，而int变量不需要
3. Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4. Integer的默认值是null，int的默认值是0
5. 由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false

6. Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);
int j = 100；
System.out.print(i == j); //true

7. 非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false

8. 对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了

• TCP（Transmission Control Protocol，传输控制协议）提供的是面向连接，可靠的字节流服务。即客户和服务器交换数据前，必须现在双方之间建立一个TCP连接，之后才能传输数据。并且提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
• UDP（User Data Protocol，用户数据报协议）是一个简单的面向数据报的运输层协议。它不提供可靠性，只是把应用程序传给IP层的数据报发送出去，但是不能保证它们能到达目的地。由于UDP在传输数据报前不用再客户和服务器之间建立一个连接，且没有超时重发等机制，所以传输速度很快。

• 第一次握手: 建立连接，客户端A发送SYN=1、随机产生Seq=client_isn的数据包到服务器B，等待服务器确认。
• 第二次握手: 服务器B收到请求后确认联机(可以接受数据)，发起第二次握手请求，ACK=(A的Seq+1)、SYN=1，随机产生Seq=client_isn的数据包到A。
• 第三次握手: A收到后检查ACK是否正确，若正确，A会在发送确认包ACK=服务器B的Seq+1、ACK=1，服务器B收到后确认Seq值与ACK值，若正确，则建立连接。

• Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序，主要的用途是设置字符集、控制权限、控制转向、做一些业务逻辑判断等。其工作原理是，只要你在web.xml文件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统一设置编码，简化操作；同时还可进行逻辑判断，如用户是否已经登陆、有没有权限访问该页面等等工作。它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关请求，只有当你的web应用停止或重新部署的时候才销毁。
• 拦截器是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。是基于JAVA的反射机制。拦截器不是在web.xml，比如struts在struts.xml中配置。
• 拦截器，在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前，进行拦截，然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。
• Spring的Interceptor(拦截器)与Servlet的Filter有相似之处，比如二者都是AOP编程思想的体现，都能实现权限检查、日志记录等。不同的是：
  1. Filter Interceptor Summary
  2. Filter 接口定义在 javax.servlet 包中 接口 HandlerInterceptor 定义在org.springframework.web.servlet 包中
  3. Filter 定义在 web.xml 中
  4. Filter 只在 Servlet 前后起作用。 拦截器能够深入到方法前后、异常抛出前后等，因此拦截器的使用具有更大的弹性。
  5. Filter 是 Servlet 规范规定的。 而拦截器既可以用于Web程序，也可以用于Application、Swing程序中。 使用范围不同
  6. Filter 是在 Servlet 规范中定义的，是 Servlet 容器支持的。 而拦截器是在 Spring容器内的，是Spring框架支持的。 规范不同
  7. Filter 不能够使用 Spring 容器资源 拦截器是一个Spring的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源、对象，例如 Service对象、数据源、事务管理等，通过IoC注入到拦截器即可 Spring 中使用 interceptor 更容易
  8. Filter 是被 Server(like Tomcat) 调用 Interceptor 是被 Spring 调用 因此 Filter 总是优先

遍历二叉树：递归 非递归

• 前序遍历：根左右
• 中序遍历：左根右
• 后序遍历：左右根
• 转换：知二求三
  • 通过前序找到根（最前），再到中序里按根分开，再去前序里找到靠前的即为根，再次分开
  • 通过后序找到根（最后），再到中序里按根分开，再去后序里找到靠后的即为根，再次分开

public class Recursive{
    public void preOrder(Node root,LinkedList result){
        if(null==root){
            return;
        }
        result.add(root.data);          
        preOrder(root.left,result);
        preOrder(root.right,result);                
    }
}
public class NoRecursive{
    //前序，后序先push进入while后pop，取值（注意插入列表的顺序），再判断左右孩子不为空就压栈（注意压栈顺序）
    public LinkedList postOrder(Node root){
        LinkedList<Integer> result=new LinkedList<>();
        Stack<Node> stack=new Stack<>();
        if(null==root){
            return result;
        }
        stack.push(root);
        while(!stack.empty()){
            Node tmp=stack.pop();
            result.add(0,tmp.data);
            if(null!=root.left){
                stack.push(root.left);
            }
            if(null!=root.right){
                stack.push(root.right);
            }
        }
        return result;
    }
    //中序，先不push，进入while不为空就push，再往左走，为空就pop，再往右走
    public LinkedList inOrder(Node root){
        Stack<Node> stack=new Stack<>();
        LinkedList<Integer> result=new LinkedList<>();
        while(null!=root||!stack.empty()){
            if(null!=root){
                stack.push(root);
                root=root.left;
            }else{
                Node tmp=stack.pop();
                result.add(tmp.data);
                root=tmp.right;
            }
        }
    }
}

1. Redis是基于内存存储的，MySQL是基于磁盘存储的
2. Redis存储的是k-v格式的数据。时间复杂度是O(1),常数阶，而MySQL引擎的底层实现是B+Tree，时间复杂度是O(logn)，对数阶。Redis会比MySQL快一点点。
3. Redis是单线程。简化算法的实现，第二，单线程避免了线程切换以及加锁释放锁带来的消耗，对于服务端开发来说，锁和线程切换通常是性能杀手。当然了，单线程也会有它的缺点，也是Redis的噩梦：阻塞。如果执行一个命令过长，那么会造成其他命令的阻塞，对于Redis是十分致命的，所以Redis是面向快速执行场景的数据库，例如缓存，分布式session。
4. Redis是单线程的多路复用IO，而多路复用IO避免了IO等待的开销，在多核处理器下提高处理器的使用效率可以对数据进行分区，然后每个处理器处理不同的数据。

• 平衡二叉查找树
  定义为：节点的子节点高度差不能超过1
• B Tree
  多路平衡查找树 数据存在节点里
• B+tree
  所有的叶子结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大的顺序链接。 (而B 树的叶子节点并没有包括全部需要查找的信息)

• 使用搜索条件
  in:name spring boot
in:readme spring boot
stars:>1000
in:description 微服务
language:java
pushed:>2019-01-01

• InnoDB是事务型数据库的首选引擎，支持事务安全表（ACID），支持行锁定和外键，
  • InnoDB主要特性有：
    • InnoDB给MySQL提供了具有提交、回滚和崩溃恢复能力的事物安全（ACID兼容）存储引擎。
    • InnoDB是为处理巨大数据量的最大性能设计。
    • InnoDB被用在众多需要高性能的大型数据库站点上
• MyISAM基于ISAM存储引擎，并对其进行扩展。它是在Web、数据仓储和其他应用环境下最常使用的存储引擎之一。
  • MyISAM拥有较高的插入、查询速度，但不支持事物。
  • MyISAM主要特性有：
    • 大文件（达到63位文件长度）在支持大文件的文件系统和操作系统上被支持
• MEMORY存储引擎将表中的数据存储到内存中，查询和引用其他表数据提供快速访问。
  • MEMORY主要特性有：
    • 不支持事务

for (int i = 0, size = list.size(); i < size; i++) {
        if (list.get(i) == 2) {
            list.remove(i);
            size--;
            i--;  //注意将i-1,否则打印结果将变为：  [1, 2, 4, 5]
        }
    }

• removeAll
  用于从列表中移除指定collection中包含的所有元素
  移除对象为实体类时注意
  实体类没有Override hashCode和equals方法 ！而在执行removeAll方法时是通过equals方法来判断集合元素是否相等的，如果没有Override equals方法，其默认的仍是比较对象，
• remove（）方法不能删除传入的集合对象。括号参数只能是 remove（Object element）和 remove（int index）. 而 removeAll（）方法中参数只能是 一个集合对象 。而不能是 一个元素名称，如 list.removeAll("Hello");提示错误 。不被允许输入。

• 错误示范: float x = 12.4
• 正确做法: float x = (float)12.4 或者 float x = 12.4f

• 由字母、下划线、美元符号$、数字构成，长度无限制。
• 第一个字符不可以是数字字符。
• 使用比ASCII码更广泛的Unicode字符集，所以在(1)中所说的“字母”包含部分简体中文。

1. 八进制转义序列：\ + 1到3位数字；范围'\000'~'\377',\0：空字符
2. Unicode转义字符：\u + 四个十六进制数字；0~65535,\u0000：空字符

• Spring Boot简化配置，降低难度，开发者更好上手,优点非常多，如：独立运行 简化配置 自动配置 无代码生成和XML配置 无需部署war文件
• Spring cloud流应用程序启动器是基于SpringBoot的Spring集成应用程序，提供与外部系统的集成。Spring cloud Task，一个生命周期短暂的微服务框架，用于快速构建执行有限数据处理的应用程序。
• SpringBoot专注于快速,方便的开发单个的微服务个体,SpringCloud关注全局的服务治理框架
• SpringCloud和Dubbo区别:服务的调用方式Dubbo使用的是RPC（协议）远程调用,而SpringCloud使用的是 Rest API,其实更符合微服务官方的定义

• 对称加密
  • 简介：
    对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。
  • 特点：
    加密速度快、加密效率高。安全性得不到保证，密钥管理困难
  • 具体算法：DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法。
  • 非对称加密
  • 简介：
    因为加密和解密使用的是两个不同的密钥，
  • 特点：
    算法强度复杂，安全性高，速度慢
  • 主要算法：
    RSA、Elgamal、背包算法、Rabin、HD,ECC（椭圆曲线加密算法）。
    使用最广泛的是RSA算法，Elgamal是另一种常用的非对称加密算法。

• 为什么要使用
  1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
  2. Hibernate 是一个基于JDBC的主流持久化框架，是一个优秀的ORM 实现。他很大程度的简化DAO层的编码工作
  3. hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，

• 父静>子静>父非静>父构造>子非静>子构造
• 首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，
• 如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。
• 子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

• 引入线程的目的：在传统的操作系统中，拥有资源和程序执行的基本单位都是进程，但是为了提高操作系统的并发性能，引入线程作为基本的CPU执行单元。
• 进程和线程的关系：一个进程可以由多个线程组成，同一进程的线程可以并发执行，进程拥有独立的地址空间，同一进程的线程可以共享进程的资源，所以同一进程内的线程切换时，时空开销很少。
• 资源拥有方面：进程是拥有资源的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，线程可以访问所隶属进程的资源。
• 通信方面：线程之间的通信更方便，进程之间的通信较困难。
• 创建销毁方面：创建和撤销一个线程比启动一个进程的开销要小。

1. 共享存储：在通信进程之间存在一块可以直接访问的共享空间，通过对这块共享空间的读写操作，实现进程之间的通信。
2. 消息传递：
   直接通信方式：利用系统提供的进程消息发送和消息接收功能进行通信。
   间接通讯方式：发送进程先把消息发送到某个消息存储设备当中，接收进程从这设备当中消费消息。
3. 管道通信：是消息传递的特殊方式，发送进程向管道写入数据，接收进程从管道中读取数据。
4. 信号量（PV操作）在系统中创建一个信号量集合（本质是个数组），可以使进程互斥地访问临界资源。

• AOP：代理模式
• 单例模式
  所谓的单例设计指的是一个类只允许产生一个实例化对象。
• 工厂设计模式
  • 工厂方法模式
    普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
    使用工厂类来创建数据库的连接对象
  • 静态工厂方法模式
    将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

• 饿汉式

  public class Singleton{
      private static Singleton instence = new Singleton;
      private Singleton(){}
      public static Singleton getInstence(){
          return instence;
      }
  }
  

• 懒汉式线程安全

  public class Singleton{
      private static Singleton instence;
      private Singleton(){}
      public static synchronized Singleton getInstence(){
          if(instence==null){
              instence=new Singleton();
          }
          return instence;
      }
  }   
  

• GET在浏览器回退时是无害的，而POST会再次提交请求。
• GET产生的URL地址可以被加入到书签，而POST不可以。
• GET请求会被浏览器主动cache，而POST不会，除非手动设置。
• GET请求只能进行url编码，而POST支持多种编码方式。
• 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。
• GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
• GET请求在URL中传送的参数是有长度限制的，而POST么有。
• GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
• GET参数通过URL传递，POST放在Request body中。
• 大多数浏览器通常都会限制url长度在2K个字节，而大多数服务器最多处理64K大小的url。
• http是明文传输，所以post的数据还是能被查看，所以最好使用https协议，它使用SSL加密，更加安全。

public static int getValue(int i) {
    int result = 0;
    switch (i) {
    case 1:
        result = result + i;
    case 2:
        result = result + i * 2;
    case 3:
        result = result + i * 3;
    }
    return result;
}

A0 B2 C4 D10
答案：D
解析：注意这里case后面没有加break，所以从case 2开始一直往下运行

1. 用 new 语句创建对象，这是最常见的创建对象的方法。
2. 运用反射手段,调用 java.lang.Class 或者 java.lang.reflect.Constructor 类的 newInstance() 实例方法。
3. 调用对象的 clone() 方法。
4. 运用反序列化手段，调用 java.io.ObjectInputStream 对象的 readObject() 方法。
   1.和2.都会明确的显式的调用构造函数 ;3.是在内存上对已有对象的影印，所以不会调用构造函数 ;4.是从文件中还原类的对象，也不会调用构造函数。

1. 根据域名到DNS中找到IP
2. 根据IP建立TCP连接(三次握手)
3. 连接建立成功发起http请求
4. 服务器响应http请求
5. 浏览器解析HTML代码并请求html中的静态资源（js,css）
6. 关闭TCP连接（四次挥手）
7. 浏览器渲染页面

java 1.8开始支持接口中定义静态方法，

int n;
System.out.println(n=0);
if (n=0){

判断条件n = 0，先将0赋给int型变量n,这时候条件是一个int类型的0，

空白符字符输入

char temp;
string str;
while((temp=cin.get())!='\n'){
    str+=temp;
}
cout<<str.length()<<endl<<str<<endl;
for(int i=0;i<str.length();i++){
    cout<<str[i]<<endl;
}

@RequestMapping("restful/{id}")
@ResponseBody
public String showInfo6(@PathVariable Integer id){
    System.out.println("restful id:"+id);
    return "id:"+id;
}

• nginx常用做静态内容服务和代理服务器（不是你FQ那个代理），直面外来请求转发给后面的应用服务（tomcat，django什么的）
• tomcat更多用来做做一个应用容器，让java web app跑在里面的东西
• 动静态资源分离——运用Nginx的反向代理功能分发请求：所有动态资源的请求交给Tomcat，而静态资源的请求（例如图片、视频、CSS、JavaScript文件等）则直接由Nginx返回到浏览器，这样能大大减轻Tomcat的压力。
• 负载均衡，当业务压力增大时，可能一个Tomcat的实例不足以处理，那么这时可以启动多个Tomcat实例进行水平扩展，而Nginx的负载均衡功能可以把请求通过算法分发到各个不同的实例进行处理

• spring 中 AOP是基于 “动态代理” 实现，其采用了两种方式：
  • JDK 动态代理
    采用java内置的代理API实现,cglib代理类的实现效率是比 jdk代理类实现效率要高，并且更强大的，但spring中更推荐使用java原生的代理方式，因为稳定。
    生成的代理类实现了被代理对象的接口并继承Proxy
  • CGLIB 动态代理
    采用第三方API实现,生成的代理类是直接继承被代理类

1. 继承Thread类，重写run方法（其实Thread类本身也实现了Runnable接口）
   new Thread子类（）.start（）
2. 实现Runnable接口，重写run方法
   new Thread（Runnable接口实现类的对象）.start()
3. 实现Callable接口，重写call方法（有返回值）

   public class MyThread {
       public static void main(String ards[]) throws InterruptedException, ExecutionException{
           for(int i=0;i<10;i++){
               Callable<Integer> implCallable = new ImplCallable();
               FutureTask<Integer> futureTask = new FutureTask<Integer>(implCallable);
               new Thread(futureTask).start();
               System.out.println(Thread.currentThread().getName()+"----"+futureTask.get());
           }
           System.out.println(Thread.currentThread().getName());
       }           
   }
   //重写call方法
   class ImplCallable implements Callable<Integer>{
   
       @Override
       public Integer call() throws Exception {
           int result = 0;
           for(int i=0;i<10;i++){
               result += i;
           }
           System.out.println(Thread.currentThread().getName());
           return result;
       }
   
   }
   

4. 使用线程池（有返回值）

   public class ThreadPool {
       public static void main(String[] args){
           //使用Executors工具类中的方法创建线程池
           ExecutorService pool = Executors.newFixedThreadPool(5);
           ThreadPoolDemo demo = new ThreadPoolDemo();
           //为线程池中的线程分配任务,使用submit方法，传入的参数可以是Runnable的实现类，也可以是Callable的实现类
           for(int i=1;i<=5;i++){
               pool.submit(demo);
           }
           //关闭线程池
           //shutdown ： 以一种平和的方式关闭线程池，在关闭线程池之前，会等待线程池中的所有的任务都结束，不在接受新任务
           //shutdownNow ： 立即关闭线程池
           pool.shutdown();
       }
   }
   class ThreadPoolDemo implements Runnable{
       /**多线程的共享数据*/
       private int i = 0;
       @Override
       public void run() {
           while(i<=50){
               System.out.println(Thread.currentThread().getName()+"---"+ i++);
           }
       }
   }
   

FileReader file=new FileReader("C:\\Users\\Yuyy\\Desktop\\Ego.txt");
BufferedReader bufferedReader=new BufferedReader(file);
String line="";
while((line=bufferedReader.readLine())!=null){
    System.out.println(line);
}

File file1 = new File("C:\\Users\\Yuyy\\Desktop\\out.txt");
file1.createNewFile();
FileWriter fileWriter=new FileWriter(file1);
BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
bufferedWriter.write("4545sssafaf");
bufferedWriter.flush();
bufferedWriter.close();

SELECT
    * 
FROM
    (
    SELECT
        tb1.*,
        ROWNUM ROWNUM1 
    FROM
        ( 
        SELECT * 
        FROM TABLE1 
        WHERE TABLE1_ID = XX 
        ORDER BY GMT_CREATE DESC 
        ) tb1 
    WHERE
        ROWNUM <= 20 ) 
WHERE ROWNUM1 >= 10;    

int a=3;            
int b=4;
String c="5";
char d='a'
sout(a+b+c);  //75
sout(c+a+b);  //534
sout(a+d);  //100 将字符转为Unicode码对应的int来算

r：可读取文件的实际内容
w：可编辑、新增、修改该文件的实际内容
x：可被执行

所有者(属主)有读写权限，
所有组(属组)有读权限，
其余人也仅有读权限。

二分查找

while(low<=high){        //注意是<=
    count++;
    mid=(low+high)/2;
    mid="<<mid<<endl;
    if(guess==a[mid]){  //成功的条件
        flag=1;
        cout<<"success！比较次数:"<<count<<"次"<<endl;
        break;//查找成功就退出，如果想要继续查找也是可以的
    }
    if(guess>a[mid]){
        low=mid+1;
    }
    if(guess<a[mid]){
        high=mid-1;
    }       
}

• Eden，对应MinorGc，采用效率高的复制算法，存储了未通过垃圾回收的对象，Eden满了就会触发Minor Gc
• Survivor存放垃圾回收后的对象，Survivor1、Survivor2，同一时间只使用一块，当对象经历了15次垃圾回收后便进入年老代。
  持久代存放静态文件，如类，方法等，对应方法区
• Major Gc用于清理年老代
• Full Gc用于清理年轻代，年老代，成本较高，对系统能产生影响.
• 回收过程
  1. 新创建的对象，大多数存放在Eden区
  2. 当Eden区满了（达到一定比例），不能创建新对象，则出发MinorGc，清理无用对象，将剩余对象复制到某个Survivor区，同时清空Eden区。
  3. 当Eden区再次满了，会将S1和Eden中不能清空的对象存到S2，清空S1，Eden。
  4. 经历15次未被清理的对象将被复制到年老区
  5. 当Old区满了，触发FullGc
• Jvm调优很大部分工作都是针对FullGc
  • 触发FullGc的有
  1. 年老代满
  2. 持久代满
  3. System.gc()被显示调用（并不会立刻执行，只是建议jvm执行，执不执行，什么时候执行由jvm控制）
  4. 上一次Gc之后Heap的各域分配策略动态变化

1. 创建大量无用对象，例如拼接字符串使用String。
2. 静态集合类的使用，HashMap、Vector、List之类的，最容易造成内存泄漏，这些静态变量的生命周期与程序的生命周期一致，所有的对象Object不能被释放。
3. 各种连接对象（IO流对象，数据库连接对象，网络连接对象）未关闭。
4. 监听器的使用，释放对象时，没删除对应的监听器。

1. TCP主要的特点：
   1. TCP是面向连接的的运输层协议；
   2. 每一条TCP连接只能有两个端点，每一条TCP只能是点对点的；
   3. TCP提供可靠交付的服务；
   4. tcp提供全双工通信；
   5. 面向字节流。
2. UDP的主要特点：
   1. udp是无连接的，即发送数据之前不需要建立连接；
   2. udp使用尽最大努力交付，即不保证可靠交付；
   3. udp是面向报文的；
   4. udp没有阻塞控制；
   5. udp支持一对一、一对多、多对一和多对多交互通信；
   6. udp的首部开销小。
3. tcp和udp各自应用的场合：
   • UDP 适用于不需要可靠机制的情形，比如，当高层协议或应用程序提供错误和流控制功能的时候。
   • UDP 是传输层协议， 服务于很多知名应用层协议，包括网络文件系统（NFS）、简单网络管理协议（SNMP）、域名系统（DNS）以及简单文件传输系统（TFTP）。
   • TCP是一种面向连接的、可靠的、基于字节流的运输层通信协议，通常由IETF的RFC 793说明。在简化的计算机网络OSI模型中，它完成运输层所指定的功能。一些要求比较高的服务一般使用这个协议，如FTP、Telnet、SMTP、HTTP、POP3等

• 通过可达性分析的无用的对象，会首先被标记，以确定对象是否需要执行finaliize（）方法；之后会进行一次筛选，如果对象覆盖了finalize（）方法，同时finalize（）没有被其他虚拟机调用，则该对象再次被标记；
• 通过了第二次标记的对象会加入一个F-Queue的队列，同时等待一个由虚拟机自启的，低优先级的Finalizer线程去执行gc；
• 执行：这里的执行只能保证触发，并不保证会虚拟机会等待它执行完成
• 自我拯救：在第一次标记后，线程仍然有机会去和可达性分析可以到达的线程建立联系，来再次使自己免于被回收