上周末面试被问到List和Set的区别，支支吾吾答不上（之前没有用过Set，学过却忘了），写个文章补一下。

本来想直接写一篇文章复习整个Collection Framework的，后来发现要写完可以变成一本书……（其实是水平不够）

Set:
一个不包含重复元素的 collection。
更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

事实上最常用的Set接口的实现类HashSet，底层是使用HashMap实现的，元素是HashMap的Key，而Value是一个私有的静态的Object对象。

HashSet有一个addAll方法，可以用来给ArrayList去重（阿里代码规约也有提到）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public static void main(String[] args) {  
    Set  set=new HashSet();  
    set.add("字符串1");  
    set.add("字符串1");  
    set.add("字符串1");  
    set.add("字符串2");      
    set.add("字符串3");  
    System.out.println("size="+ set.size());  //3
  
    List list = new ArrayList();  
    list.add("字符串1");  
    list.add("字符串4");  
    list.add("字符串5");  
    set.addAll(list);
    System.out.println("size="+ set.size() );  //5

    for(String s:set)  {               
        System.out.println(s);              
    }
}  

最近做笔试题总是遇到覆盖重写，总是记不住，干脆写个笔记辅助记忆。
（不知是我太菜了还是黑皮书的翻译太拗口，本来想着Java语言规范这本书即使看不下去，拿来做工具书查也是好的，结果当工具书也看不懂x）

@Override
方法覆盖存在于子类和父类（接口）之间，遵循以下原则：
方法名字：必须相同
参数列表：必须相同

抛出异常：子类必须<=父类（子类抛出的异常类，必须与父类相同，或者是父类抛出的异常类的子类）
返回类型：子类必须<=父类（子类的返回类型，必须与父类相同，必须是父类的返回类型的子类）

访问权限：子类必须>=父类（例如public不能覆盖为protected）

俗称两同两小一大原则

Overload
方法重写：在一个类中定义多个重名的方法，遵循以下原则：
方法名字：必须相同
参数列表：必须不同，如果参数个数相同，必须保证参数的类型或者顺序不同。
返回类型、访问权限、没有要求。

第二节：多线程编程的基本需求。

JUC满足了多线程编程的各种需求，但是丰富的需求也是从简单需求开始的。

1.复习：创建线程

我还记得，当年培训班的SE部分结课作业是实现一个Socket客户端/服务端。
其实从这个角度上来说，某鸟的排课水平并不差；这个作业同时要求掌握Socket库的基本用法，还要求理解和实现BIO模型，也就是“服务端监听客户端连接，每个连接创建一个新线程”。

大致的代码如下（节省篇幅，我省略了继承/实现接口的部分，直接使用lambda表达式）：

1 2 3 4 5 6 7 8 9 10 11

//略去主类、主方法 //监听10086端口 ServerSocket sc = new ServerSocket(10086); while(true){ //循环监听 Socket socket = serverSocket.accept(); //为每个连接创建新线程 new Thread(() -> { //具体的操作，相当于重写run()方法 }).start(); }

这样的代码可能大家都很熟悉（如果觉得陌生的话，也可以改写成一个MyThread类，实现Runnable接口并重写Run方法），而且肯定会有人让我用线程池；还请暂且忍耐一下，看完这些“原始”的代码。

基本需求1：同步与线程安全（synchronized）

问题来了，假设我们要在业务逻辑里对某个东西进行操作，例如……购买商品？

我们设计一个商店类，剩余库存为2，当库存为0时显示已售空，同时让线程睡眠1秒以模拟数据库读写等操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Shop{
    private int count = 2;
    public void sell(String name){
        System.out.println(name+"开始购买商品");
        if(count<=0){
            System.out.println(name+"发现商品已售空");
        }else{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count--;
            System.out.println(name+"购买商品完成，剩余库存："+count);
        }
    }
}

看起来是不是很合理？

对主方法进行修改，专注于线程而不是Socket：

1
2
3
4
5
6

Shop s = new Shop();
for (int i = 0; i < 5; i++) {
//lambda表达式要求表达式中只有静态变量
    int finalI = i;
    new Thread(() -> s.sell("顾客" + finalI)).start();
}

我们同时建立5个连接，观察一下控制台，结果是什么？

1
2
3
4
5
6
7
8
9
10

线程0开始购买商品
线程3开始购买商品
线程1开始购买商品
线程2开始购买商品
线程4开始购买商品
线程0购买商品完成，剩余库存：0
线程3购买商品完成，剩余库存：0
线程2购买商品完成，剩余库存：-3
线程1购买商品完成，剩余库存：-3
线程4购买商品完成，剩余库存：-3

这……这是一场灾难！5个买家全都购买成功，而库存变成了-3！

（题外话：在高并发秒杀环境中， count 不再是简单的成员变量，而是缓存/数据库的某个值。万一并发处理错误，导致 count 瞬间变成了负数，这时候如果以 count==0 作为判断条件，会导致秒杀无法停止，所以一定要将判断条件改为小于区间。）

这就是一个典型的线程不安全的类。

定义：线程安全：在单个/多个线程环境下都能得到预期运行结果。

究其原因，是由于线程受到操作系统的调度，我们无法直接控制线程何时运行，即使是调节优先级，得到的也只是影响，而不是保证（可以试试把五个线程的优先级排一下看看结果）！

幸运的是，Java语言提供了同步关键字 synchronized ，它是Java对多种锁的封装，根据使用情况不同有不同的表现。

我们把它加到 sell 方法上……

1
2
3
4
5
6
7
8
9
10

线程0开始购买商品
线程0购买商品完成，剩余库存：1
线程3开始购买商品
线程3购买商品完成，剩余库存：0
线程4开始购买商品
线程4发现商品已售空
线程2开始购买商品
线程2发现商品已售空
线程1开始购买商品
线程1发现商品已售空

结论：在将 synchronize 关键字加到某个方法上后，我们可以确保在一个线程进入 这个对象 的这个方法之后，就不会有另一个线程也进入，避免了超售的情况。

这背后实际是线程获取了 这个对象 的锁，在执行完方法后，自动释放了 这个对象 的锁，是不是很智能？

与此相同的用法还有：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 public void sell(String name){
    synchronized (this){
        System.out.println(name+"开始购买商品");
        if(count<=0){
            System.out.println(name+"发现商品已售空");
        }else{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count--;
            System.out.println(name+"购买商品完成，剩余库存："+count);
        }
    }
}

所以明确一个概念： synchronize 代码块锁住的不是代码块，而是 synchronize 后面圆括号中的对象！

定义：对象锁： 让同一个对象的某个方法无法被多个线程并发执行的机制。

题外话：

为什么我要强调同一对象呢？

让我修改一下代码，每次创建线程都创建一个 Shop 对象……

1
2
3
4
5
6

//主方法、主类
        for (int i = 0; i < 5; i++) {
        //lambda表达式要求表达式中只有静态变量
            int finalI = i;
            new Thread(() -> new Shop().sell("顾客" + finalI)).start();
        }

然后把Shop对象的库存属性改为静态变量，以使所有Shop对象可以共享它。

1
2
3
4

class Shop{
    private static int count = 2;
    ...
}

点击运行，灾难又出现了！

现在的编码需求，变成了让 所有Shop类的对象的 sell() 方法都无法被同时执行。

继续修改 sell() 方法，既然 count 已经是静态变量，那么我们为什么不把 sell() 方法也改成静态方法呢？

这时候IDE报了一个错，原来在静态方法中不能用 this 关键字（对象都不一定有， this 指定谁去？），那么把它改为 Shop.Class ，类对象就不是对象了？

现在的 sell() 方法：

1
2
3
4
5
6

public static void sell(String name){
        synchronized (Shop.class){
            ....
            }
        }
    }

当然，我们也可以直接把 synchronize 关键字丢回到静态方法上：

1
2
3

public synchronized static void sell(String name){
...
}

定义：类锁： 让同一个类 多个实例对象 的某个方法，都 无法被多个线程并发执行的机制。

基本需求2：线程间通信（Object.wait()/Object.notify()）

刚刚我们实现了一家有序出售物品的商店，但是一家商店不能只能出售物品，卖光了怎么办呢？进货。

大致的过程是，当某个顾客线程发现 count<=0 时，挂起所有“顾客”线程，并且通知一个线程去进货，等待进货完成后给所有挂起的“顾客”线程发送通知。

首先我们要在主方法中，单独开启一个进货线程（这个写法是lambda表达式中的方法引用，由于该线程的run方法只执行这一个无参方法，被IDE检测到了提示替换）：

1

new Thread(s::purchase).start();

仅仅 synchronized 关键字已经不够用，我们给 Shop 类增加一个字段：

1

private final Object myLock = new Object();

这个字段没有其他意义，仅仅作为一把被别人持有的对象锁而存在。

和上一章不同， 这把对象锁的目的，不再是让这个对象的方法无法被并发执行，而是让其他线程持有它，以便唤醒或挂起这些线程。

注意：

虽然我这里用了 “唤醒”和“挂起”，但我指的并不是 Thread.suspend() 和 Thread.resume() 。

这一对被废弃了十几年的方法，是属于 Thread 类的，调用 suspend() 在挂起时并不释放这个线程持有的锁，因此极其容易引发死锁；

而 Object.wait() 会让所有持有这个对象的对象锁的线程阻塞，同时也停止持有这个对象的对象锁。

当调用 Object.notify() 时，会随机取出一个因为 wait() 方法阻塞的线程，让它继续运行的同时重新持有对象锁；

而调用 Object.notifyAll() 时，会让所有之前因为 wait() 方法阻塞的线程解除阻塞，但是注意：只有那个重新持有对象锁的线程才能继续运行。

明白了 wait() 和 notify() 这一对方法后，我们来着手改写 sell() 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

...
        while (count <= 0) {
            try {
                System.out.println(LocalTime.now() + name + "要求了进货");
                synchronized (myLock) {
                    myLock.notify();
                }
                System.out.println(LocalTime.now() + name + "进货等待中");
                this.wait();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
...

在现在的 sell() 方法中，首先把库存不足的判断由 if 改为 while ，这样每个顾客在收到进货完成的通知后，都会重复检查一次库存。

接下来改写条件块的内容：

• 尝试获取myLock的对象锁；

• 在其他获取了myLock对象锁，并且被阻塞的线程中，选一个恢复运行（在主方法中实际我们只创建了一个这样的线程，因此这里 notify() 和 notifyAll() 没有什么区别 ）；

• 将所有持有当前对象的对象锁的线程阻塞。

接下来是进货方法：

• 当然进货方法要写死循环，一旦被 sell() 方法恢复运行后，能再次阻塞，等待下一次需要进货的时候；

• 获取myLock的对象锁，并且开始阻塞；

• 在被 sell() 方法恢复运行后，将库存+5，然后将所有获取了当前对象的对象锁，并且被阻塞的线程恢复运行（招呼其他顾客继续购物）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 public void purchase() {
    while (true) {
        synchronized (myLock) {
            try {
                System.out.println(LocalTime.now()+"店家等待进货通知");
                myLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(LocalTime.now()+"店家开始进货");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count += 5;
        synchronized (this) {
            this.notifyAll();
        }
        System.out.println(LocalTime.now()+"店家进货完成");
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

17:12:32.563顾客0开始购买商品
17:12:32.563店家等待进货通知
17:12:33.564顾客0购买商品完成，剩余库存：1
17:12:33.564顾客4开始购买商品
17:12:34.564顾客4购买商品完成，剩余库存：0
17:12:34.564顾客3开始购买商品
17:12:34.564顾客3要求了进货
17:12:34.564顾客3进货等待中
17:12:34.564店家开始进货
17:12:34.565顾客2开始购买商品
17:12:34.565顾客2要求了进货
17:12:34.565顾客2进货等待中
17:12:34.565顾客1开始购买商品
17:12:34.565顾客1要求了进货
17:12:34.565顾客1进货等待中
17:12:36.565店家进货完成
17:12:36.565店家等待进货通知
17:12:37.566顾客1购买商品完成，剩余库存：4
17:12:38.566顾客2购买商品完成，剩余库存：3
17:12:39.567顾客3购买商品完成，剩余库存：2

我们圆满的完成了需求，尽管这个程序会有一个一直等待是否去进货的店家，所以不会直接结束。

基本需求3：线程间通信2（Thread.join()）

还是刚才的问题，我们让店家去进货，但是我们不希望多加一个对象，然后折腾当前对象/myLock这两个对象的锁。

我们把在主方法中创建进货线程、并且循环阻塞等待通知，改成在 sell() 方法中创建进货线程、并调用 join() 方法。

顾名思义， join() 方法表示立即阻塞当前线程，并且让被调用 join() 方法的线程“参与”到程序执行中，在被调用 join() 方法的线程执行完后，才恢复之前阻塞的当前进程的运行。

注意， join() 方法必须在 start() 方法调用后调用；如果 join() 方法和 start() 方法中有其他代码， join() 方法会优先执行。

同时我们去掉 purchase() 方法中关于对象锁的语句：

sell() 方法：

1
2
3
4
5
6
7
8
9
10
11

while (count <= 0) {
            try {
                System.out.println(LocalTime.now() + name + "要求了进货");
                Thread a = new Thread(this::purchase);
                a.start();
                a.join();
                System.out.println(LocalTime.now() + name + "进货等待中");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

purchase() 方法现在只剩下了操作 count 以及一些提示：

1
2
3
4
5
6
7
8
9
10

public void purchase() {
       System.out.println(LocalTime.now() + "店家开始进货");
       try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       count += 5;
       System.out.println(LocalTime.now() + "店家进货完成");
   }

运行，这次程序执行完自动结束了，因为不再有一个后台持续阻塞的线程了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

17:54:09.025顾客1开始购买商品
17:54:10.027顾客1购买商品完成，剩余库存：1
17:54:10.027顾客4开始购买商品
17:54:11.027顾客4购买商品完成，剩余库存：0
17:54:11.027顾客3开始购买商品
17:54:11.028顾客3要求了进货
17:54:11.031店家开始进货
17:54:13.032店家进货完成
17:54:13.032顾客3进货等待中
17:54:14.033顾客3购买商品完成，剩余库存：4
17:54:14.033顾客2开始购买商品
17:54:15.033顾客2购买商品完成，剩余库存：3
17:54:15.034顾客0开始购买商品
17:54:16.034顾客0购买商品完成，剩余库存：2

对Java库源码有过分析的可能会知道， join() 方法内部其实是由 Object.wait()/Object.notifyAll() 实现的！

附：本章完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

package top.mothership;

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        Shop s = new Shop();
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> s.sell("顾客" + finalI)).start();
        }
    }

}

class Shop {
    private int count = 2;


    public synchronized void sell(String name) {
        System.out.println(LocalTime.now() + name + "开始购买商品");
        if (name.contains("2") || name.contains("0")) {
            Thread.yield();
        }
        while (count <= 0) {
            try {
                System.out.println(LocalTime.now() + name + "要求了进货");
                Thread a = new Thread(this::purchase);
                a.start();
                a.join();
                System.out.println(LocalTime.now() + name + "进货等待中");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count--;
        System.out.println(LocalTime.now() + name + "购买商品完成，剩余库存：" + count);
    }

    public void purchase() {
        System.out.println(LocalTime.now() + "店家开始进货");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count += 5;

        System.out.println(LocalTime.now() + "店家进货完成");
    }
}

昨天在知乎看到一个回答，大意是：如果我是面试官，就从Object类的方法问起。

clone方法可以问深复制浅复制，接下来可以涉及引用类型和值类型，自动装箱拆箱，类初始化顺序……
equals方法可以问Integer的缓存，JVM内存模型，然后转到hashCode；
finalize方法可以问作用、缺点，转到垃圾回收，GC的算法、实现、内存模型……
getClass方法当然问反射，接下来可以拓展到Spring，扩展到动态代理 aop……
hashCode可以考基本算法，HashTable和HashMap，是否线程同步，然后可以考并发容器……
wait/notify/notifyAll引申出多线程，接下来就是并发包中的各种调度器线程池……

翻了翻链接，原回答：你遇到过哪些质量很高的 Java 面试？ - 知乎
https://www.zhihu.com/question/60949531/answer/182146087

前言

本系列文章作为学习笔记，记录了博主向并发包进攻的过程。

在此，我假设本文读者已经掌握了Java的基本编码，如果是大学生，至少Java的课程要通过；如果是培训学员，至少需要学完SE部分。虽然影响不大，但是如果对Spring，或者至少Java Web有一定了解和编码经验，应该会对阅读有所帮助（我可能会举一些网站相关的例子）。

本文夹杂大量个人理解，错误不可避免，非常欢迎评论指正。

正文

第一章 ：假如没有juc……

2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.0。——via 维基百科

前置知识：JSR——Java Specification Requests的缩写，意思是Java 规范提案。是指向JCP(Java Community Process)提出新增一个标准化技术规范的正式请求。

JSR166完成（同样也是J2SE1.5发布）之后，Java程序员发现，除了Thread类、Runnable接口外，Java引入了大量的API，极大的丰富了Java在多线程编程的能力。

让我们从已掌握的知识开始，先忘掉java.util.concurrent，复习一下基础的概念：线程/进程/并发/并行，还有我们的老朋友Thread/Runnable/synchronized/volatile。

第一节：进程与线程。

在提到线程和进程之前，推荐一篇有趣的文章：
《我是一个CPU：这个世界慢！死！了！ 》
（阅读前需要对计算机的基本组成有一定了解，至少要明白SSD、CPU的L1L2缓存是什么。）

如果将一颗2.6GHz频率，一个逻辑核心的CPU（这个性能在现在可以说是很低了，主流的i7-8700K有6个物理核心，通过Intel的超线程技术让系统认为有12个逻辑核心，最高睿频4.7GHz）执行每个指令的时间放大到一秒，那么从内存中读取1MB 需要7.5天，从SSD上的随机读取需要用4.5天，从SSD读取1MB需要一个月，而HDD的磁盘寻址需要10个月，连续读取1MB需要20个月！

我们设想一个场景。你打开一台一个逻辑核心的电脑，登录QQ，同时打开IDEA开始编写代码，在你眼里QQ和IDEA是同时运行着的程序。但是在CPU的眼里，QQ和IDEA需要CPU来执行的操作其实是轮流着来的，只是它切换的速度太快，你感受不到！

CPU其实一直不断的在加载QQ的上下文（内存、显卡、硬盘等资源）→执行QQ→保存QQ的上下文→加载IDEA的上下文…

好，我们引申出概念：

1.什么是进程？

“计算机中已运行程序的实体，分配资源的基本单位。”

我们编写的程序，只是指令（比如做加法）、数据（比如一个整数1）和组织形式（比如某个数组，是按顺序排的一系列元素）的描述，当我们下达运行它的命令时，才会产生进程。操作系统按进程为单位分配资源，这些资源包括一片内存、操作系统描述符（所谓文件句柄/文件描述符），安全特性以及CPU状态（视是否在运行存储在寄存器/内存中）等。

总结：进程是一个单位，我们下达运行程序命令时，就可以向操作系统申请领取“一个进程的”大礼包，包含了一段时间内的一部分计算机资源。

2.什么是线程？

“操作系统调度的最小单位”。
在此不对OS这门课做展开，不讨论内核态用户态线程。

我们再设想一个场景。你从操作系统领取了大礼包，它包含了一部分的时间（我感觉生命在流逝）和一部分的计算机资源。但是现在你的代码里需要打开硬盘上的某个文件，或者更过分的是等待某个网络请求（还记得150ms在CPU的眼里是12.5年吗？）……

这是一种严重的浪费！在这个礼包、甚至之后的好多礼包给的时间内，你创建的进程什么都没有做，白白的浪费了系统资源，时间一到CPU就切换到了别的程序，这极大的影响了程序的执行效率。

这时候如果我能把进程拆分为一个个部分，由它们共享这些资源；当第一个部分需要等待某个耗时较长的操作时，其他部分也可以在这份时间里利用这份资源，岂不美哉？

总结：线程是一个更小的单位，“一个进程”的资源，可以由多个“线程”共享，免得出现资源浪费。

3.什么是并发，什么是并行？

Erlang之父简单的介绍了它们的区别：

串行是一个队列一台咖啡机，如果有人匹到了一把Dota，过了一个小时打完回来接咖啡，后面的人都得必须等着；
并发是两个队列用一台咖啡机，咖啡机在处理两个队列的人的状态中不断切换，在逻辑上这台咖啡机可以同时处理两个队列；
并行则是两个队列用两台咖啡机，有两台咖啡机在同一个时间点处理两个队列，注意，是真正意义上、物理上的同时，这也是多逻辑核心CPU的模型！

快半年了，白菜的功能也发生了很多变化。
加入了对接osu search接口，可以提供搜索词来找到自己在某个图的成绩。
加入了其他三个模式的支持（懒得从其他语言移植其他模式的PP计算）。
另外还有cost和bounspp的计算……
记不太清这五个月做了什么了，现在有了AOP的异常通知、参数拦截，redis缓存……
现在说起来好像挺简单，不过实现的时候还是挺开心的。

比赛分析也改成了用命令增删玩家、谱面……

前几天白菜突然被邀请进入一个站长群，恰好还遇上了熟人手柄。
突然想重新整理一下自己的博客，毕竟这不是游戏博客，放一堆Dota 2的大背景好像很不合适。
干脆换一个仿Github的主题，也开始整理一些自己平时遇到的东西吧。

2018-4-2 补充：

在阅读了深入理解JVM后，作者的这一段话彻底理清了这一块：
“需要说明的是，上面关于对象死亡时finalize()方法的描述（前文描述了在finalize()方法中让对象重新被引用，从而可以避免一次垃圾回收）可能带有悲情的艺术色彩，…笔者建议大家避免使用它，…而是Java刚诞生时为了使C/C++程序员更容易接受它做出的妥协。它运行代价高昂，不确定性太大，无法保证各个对象的调用顺序，有些教材描述它适合用来关闭外部资源，这完全是对这个方法用途的一种自我安慰，finalize()能做的，finally块等其他方式能做的更好、更及时，所以笔者建议大家完全可以忘掉Java中有这个方法的存在。”

这个方法实质是一种妥协，缺点见下文。

先说finalize。

在我之前的个人理解里，finalize方法并不会直接导致该对象被释放/回收；因此它不是C++意义上的析构函数。
（事实上析构函数的作用是定义对象被释放时候的行为，是对析构函数的调用，而不是析构函数本身导致对象被释放）
它用于 标记在对象被回收时应该做一些事情；例如释放其他资源，关闭连接等。

以下说明摘抄自1.6的API文档：

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。
finalize 的常规协定是：当 Java虚拟机已确定尚未终止的任何线程无法再通过任何方法访问此对象时，将调用此方法，除非由于准备终止的其他某个对象或类的终结操作执行了某个操作。finalize 方法可以采取任何操作，其中包括再次使此对象对其他线程可用；不过，finalize 的主要目的是在不可撤消地丢弃对象之前执行清除操作。例如，表示输入/输出连接的对象的 finalize 方法可执行显式 I/O 事务，以便在永久丢弃对象之前中断连接。
Object 类的 finalize 方法执行非特殊性操作；它仅执行一些常规返回。Object 的子类可以重写此定义。
Java 编程语言不保证哪个线程将调用某个给定对象的 finalize 方法。但可以保证在调用 finalize 时，调用 finalize 的线程将不会持有任何用户可见的同步锁定。如果 finalize 方法抛出未捕获的异常，那么该异常将被忽略，并且该对象的终结操作将终止。
在启用某个对象的 finalize 方法后，将不会执行进一步操作，直到 Java 虚拟机再次确定尚未终止的任何线程无法再通过任何方法访问此对象，其中包括由准备终止的其他对象或类执行的可能操作，在执行该操作时，对象可能被丢弃。
对于任何给定对象，Java 虚拟机最多只调用一次 finalize 方法。
finalize 方法抛出的任何异常都会导致此对象的终结操作停止，但可以通过其他方法忽略它。

在JDK9的API中，该方法已经被废弃：

已过时。 finalize机制本质上是有问题的。finalize可能导致性能问题，死锁和挂起。
finalize方法中的错误可能导致资源泄漏; 如果 finalization不再需要，无法取消 ; 并且在不同对象的finalize方法的调用中没有指定排序。 此外，finalization的时间并不能得到保证。finalize方法可能只能在无限期的延迟之后，才调用到可终结的对象上。
如果一个类的实例持有非堆资源，那么它应提供一种方法，来实现这些资源的显式释放，如果适用，它们还应实现AutoCloseable 。
Cleaner和PhantomReference在对象变得不可达时提供更灵活和更有效的方式来释放资源。

API Note:
嵌入非堆资源的类，具有许多清除这些资源的选项。 该类必须确保每个实例的生命周期 比其嵌入的任何资源的寿命都要长。
当嵌入在对象中的资源正在使用时，可以使用Reference.reachabilityFence(java.lang.Object)来确保对象保持可访问。

一个子类应该避免覆盖finalize方法，除非子类嵌入在收集实例之前必须清理的非堆资源。
与构造函数不同，调用子类的finalize()不会自动调用父类的finalize()方法。如果一个子类覆盖了finalize，必须明确地调用超类终结器。
为了防止异常提前终止终结链，子类应该使用一个try-finally块来确保总是调用super.finalize() 。 例如：

1
2
3
4
5
6
7
8

@Override 
protected void finalize() throws Throwable { 
	try {
	... // cleanup subclass state
	} finally {
		super.finalize();
	} 
}

结论：在1.9之后，我们不应该用这个方法来实现 让一个类被回收时做某些事 的功能。如果需要做某些事，应当显式的提供做这些事的方法，例如实现AutoCloseable接口，用虚引用和Cleaner等新版的功能。

再说System.gc()。

从入门开始，我便被各种书籍告知，不要手动调用System.gc()。那么这个方法到底做了什么呢？是立即发起垃圾回收，还是催促虚拟机进行一次垃圾回收呢？
看看API文档：

调用gc方法表明，Java虚拟机花费了回收未使用对象的努力，以使其当前占用的内存可用于快速重用。
当控件从方法调用返回时，Java虚拟机已经尽力从所有丢弃的对象中回收空间。

不知道具体JVM的实现是什么，至少这段话我的理解就是 立即发起一次垃圾回收……
由于垃圾回收会停止主程序活动，而且的确实际开发中也没有理由手动发起垃圾回收，总之还是不要用的比较好（

联动：C#的析构函数

学习finalize的时候，往往会同时提起析构函数这一C系语言的产物。
但是在C#中，析构函数和finalize的作用，在我的理解中是一致的：即 让这个类在被回收前做一些事情。

不过C#的析构函数并没有被废弃，微软同时建议使用IDispose接口，实现Dispose()方法。
不过和Java的AutoCloseable不同，Dispose方法需要被重载两次，第一次是表示该对象不执行析构函数：

1
2
3
4
5
6
7

public void Dispose()
{
   // Dispose of unmanaged resources.
   Dispose(true);
   // Suppress finalization.
   GC.SuppressFinalize(this);
}

第二次才是真正的执行逻辑，此时的重载是Dispose(bool)，如果对它方法的调用是来自Dispose()，则参数为true；如果来自析构函数，则参数为false。因此需要对参数进行判断：当调用来自Dispose()时，释放非托管资源。

联动：C++的析构函数

水平有限，不做拓展.
大致可以看出也是在对象生命周期结束时被自动调用，但是由于没有自动内存管理，C++的析构函数会在如下几种情况被调用：

• 使用 delete 运算符 显式解除 分配了使用 new 运算符分配的对象。 使用 delete 运算符解除分配对象时，将为“大多数派生对象” 或 “属于完整对象，但不是表示基类的子对象的对象”释放内存。 此“大多数派生对象”解除分配一定仅对虚拟析构函数有效。 在类型信息与实际对象的基础类型不匹配的多重继承情况下，取消分配可能失败。
• 具有块范围的本地（自动）对象超出范围。
• 临时对象的生存期结束。
• 程序结束，并且存在全局或静态对象。
• 使用析构函数的完全限定名显式调用了析构函数。

之前的名字好像太长了（

自动清理文件我直接写死了Linux的路径，反正也不会在开发环境下用到这个功能（
今天折腾了个验证码，初步看了一下Interceptor和Filter的区别，前者是基于AOP来拦截每个Controller请求，本质上是个Aspect，和我用来全局捕捉异常的东西是一样的。。
后者则是J2EE里Servlet的功能，在Spring的DispatcherServlet之前工作，在Controller工作之前就拦截了请求……
虽然其实功能差不多，传入的都是HttpServletRequest/Response，不过我的代码要用到redis，而redis的工具类是托管在Spring里的，所以我还是选了Interceptor。

这个比赛分析功能还是挺有用的……后期考虑改成命令（

晚点改一下分数抓取的目标和继续做登录吧（

为了节省费用，我尝试将白菜移植到一台必须有Linux环境的机子上运行（为了和节点共存）。
一开始打算使用WSL，无奈这东西在桌面Win10已经普及了，但是Server系统下只有一个Insider Preview。

Preview到什么程度呢，那个系统没有Explorer，甚至没办法移植（comctl32.dll还是哪个系统文件是定制的，没法覆盖也没法兼容，毕竟VPS可没有PE和安全模式）。

在一番挣扎之后我们彻底放弃了它，改为Ubuntu，于是我的灾难来了……

在此之前我也曾经在CentOS等系统下配过Java+MySQL的环境，但是酷Q是用易语言写的，于是就涉及到一个Docker的使用问题。

在坑了一天之后（其实是我耐不下心去啃文档，只能自己瞎几把试），大概了解了这点：
docker pull是下载一个镜像，类似于创建一个类
docker run是创造一个容器，类似于实例化对象
而docker start和stop是操作这个容器，docker rm是删除容器（对象），docker rmi是删除镜像（类）。

大概遇到的坑有：
在docker内运行的酷Q，虽然能提供5700的HTTP Server，但是同一台机子上运行的Tomcat开放的8080端口它却无法作为客户端使用，
指定localhost:8080和127.0.0.1:8080都无效，必须把酷Q的消息上报地址改为服务器的公网IP（我实际上是改为了域名）

我的代码里需要处理ppy给的类似于 1970-01-01 00:00:00的日期格式，
在Win下面，Gson默认转换没有问题，但是Ubuntu下就不行（似乎和时区无关，我本地的WSL也是这样），必须硬编码一个日期格式才能起作用。

这次重构，把CQService里具体的处理拆出来一个CmdUtil，实体类、util全部分包处理，
为了避免Win/Ubuntu的路径不一致将所有素材以二进制形式存到了数据库……四个语音base64编码之后直接硬编码到程序里（

同时还发现，我之前给ImgUtil加了一个static的Map，然后写了个静态方法去用NIO爬目录，把图片塞到那个Image里，最后在构造器里调用这个方法……
但是我ImgUtil是用prototype模式注入，每次有HTTP连接都会实例化一个新的ImgUtil，重新爬一次，压根没起到缓存的作用_(:з」∠)_

还把oppai换成了Java实现，那作者自称不喜欢Java，也别问他要更多Java程序或者支持，虽然oppai的功能全部搬了过去。
用了一下，我发现他用了一大堆静态内部类，而且要使用它 必须把它和调用它的类放在同一个包里（有个关键东西的构造函数是包访问权限的）。
本来想自己改造，但是想到万一PP算法一改，作者一更新那我不就歇逼了？于是老老实实按他规定的方法来_(:з」∠)_

一开始没掌握正确的使用方法，于是昨晚上漏掉了HR和DT（我把MOD应用之前的star穿进去了，柑橘妖怪作者不提供详细的example）。

再一次体会到了“你以为你写的代码是这样跑的，其实根本不是”的心情。

接下来就是写网站部分，然后还有一个准备咕很久的东西……还有白菜的邀请入群机制也要改改，自动清理文件的机制也要改，不过这两天我有点心力憔悴，先咕着吧……