mei_you_ni_dong/doc: 小孙的笔记 @ b920b61c398f2621df1b9da127a57fa9723d3a4a

为什么重写 equals() 时必须重写 hashCode() 方法？

根据Java规范的规定，如果两个对象相等，那么它们的哈希值必须相等。也就是说如果 equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。如果重写 equals() 时没有重写 hashCode() 方法的话就可能会导致 equals 方法判断是相等的两个对象，hashCode 值却不相等。

例如hashset集合中插入的对象重写 equals()但是没有重写 hashCode() 就会导致插入重复的元素。

在java中，mian线程中申请某一个线程，main线程运行结束，申请的新线程为什么还会继续运行？

在 Java 中，与其他操作系统一样，线程是通过调度器来管理执行的。当一个进程中所有的非守护线程都执行完毕后，该进程会自动结束并终止所有守护线程。因此，如果在 main 线程中创建了一个新线程，main 线程结束之后，该新线程仍然会继续运行。

这是因为在Java中，除了守护线程以外，每个线程都是独立执行的，并且拥有自己独立的执行堆栈和执行上下文。在 main 线程中创建一个新线程后，该新线程会被 JVM 调度器分配 CPU 时间片，并独立运行。这时即使 main 线程结束，该新线程仍然可以继续运行，直到执行完毕或者被显式地终止。

需要注意的是，如果该新线程是守护线程，那么在所有非守护线程执行完毕后，JVM 会自动终止所有守护线程并退出进程。因此，如果该新线程是守护线程，则在 main 线程结束之后可能会被强制终止，而不会继续运行。

java线程生命周期

Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态：

NEW: 初始状态，线程被创建出来但没有被调用 start() 。
RUNNABLE: 运行状态，线程被调用了 start()等待运行的状态。
BLOCKED：阻塞状态，需要等待锁释放。
WAITING：等待状态，表示该线程需要等待其他线程做出一些特定动作（通知或中断）。
TIME_WAITING：超时等待状态，可以在指定的时间后自行返回而不是像 WAITING 那样一直等待。
TERMINATED：终止状态，表示该线程已经运行完毕。

线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换

JMM内存管理

Java 内存模型（JMM） 抽象了线程和主内存之间的关系，就比如说线程之间的共享变量必须存储在主内存中。

主内存：所有线程创建的实例对象都存放在主内存中，不管该实例对象是成员变量还是方法中的本地变量(也称局部变量)

本地内存：每个线程都有一个私有的本地内存来存储共享变量的副本，并且，每个线程只能访问自己的本地内存，无法访问其他线程的本地内存。本地内存是 JMM 抽象出来的一个概念，存储了主内存中的共享变量副本。

object类包含哪些方法

Object 类是一个特殊的类，是所有类的父类。它主要提供了以下 11 个方法：

/**
 * native 方法，用于返回当前运行时对象的 Class 对象，使用了 final 关键字修饰，故不允许子类重写。
 */
public final native Class<?> getClass()
/**
 * native 方法，用于返回对象的哈希码，主要使用在哈希表中，比如 JDK 中的HashMap。
 */
public native int hashCode()
/**
 * 用于比较 2 个对象的内存地址是否相等，String 类对该方法进行了重写以用于比较字符串的值是否相等。
 */
public boolean equals(Object obj)
/**
 * native 方法，用于创建并返回当前对象的一份拷贝。
 */
protected native Object clone() throws CloneNotSupportedException
/**
 * 返回类的名字实例的哈希码的 16 进制的字符串。建议 Object 所有的子类都重写这个方法。
 */
public String toString()
/**
 * native 方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
 */
public final native void notify()
/**
 * native 方法，并且不能重写。跟 notify 一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
 */
public final native void notifyAll()
/**
 * native方法，并且不能重写。暂停线程的执行。注意：sleep 方法没有释放锁，而 wait 方法释放了锁 ，timeout 是等待时间。
 */
public final native void wait(long timeout) throws InterruptedException
/**
 * 多了 nanos 参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 毫秒。。
 */
public final void wait(long timeout, int nanos) throws InterruptedException
/**
 * 跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
 */
public final void wait() throws InterruptedException
/**
 * 实例被垃圾回收器回收的时候触发的操作
 */
protected void finalize() throws Throwable { }

finalize会不会立即清理和释放资源

对 finalize 方法进行处理的核心逻辑位于 java.lang.ref.Finalizer 类中，它包含了名为 unfinalized 的静态变量（双向链表结构），Finalizer 也可被视为另一种引用对象（地位与软、弱、虚相当，只是不对外，无法直接使用）
当重写了 finalize 方法的对象，在构造方法调用之时，JVM 都会将其包装成一个 Finalizer 对象，并加入 unfinalized 链表中

Finalizer 类中还有另一个重要的静态变量，即 ReferenceQueue 引用队列，刚开始它是空的。当狗对象可以被当作垃圾回收时，就会把这些狗对象对应的 Finalizer 对象加入此引用队列
但此时 Dog 对象还没法被立刻回收，因为 unfinalized -> Finalizer 这一引用链还在引用它嘛，为的是【先别着急回收啊，等我调完 finalize 方法，再回收】
FinalizerThread 线程会从 ReferenceQueue 中逐一取出每个 Finalizer 对象，把它们从链表断开并真正调用 finallize 方法

由于整个 Finalizer 对象已经从 unfinalized 链表中断开，这样没谁能引用到它和狗对象，所以下次 gc 时就被回收了

finalize 缺点

无法保证资源释放：FinalizerThread 是守护线程，代码很有可能没来得及执行完，线程就结束了
无法判断是否发生错误：执行 finalize 方法时，会吞掉任意异常（Throwable）
内存释放不及时：重写了 finalize 方法的对象在第一次被 gc 时，并不能及时释放它占用的内存，因为要等着 FinalizerThread 调用完 finalize，把它从 unfinalized 队列移除后，第二次 gc 时才能真正释放内存

设计模式的原则

单一职责原则（Single Responsibility Principle，SRP）：一个类应该只有一个引起它变化的原因。一个类应该只负责完成单一的职责或功能，这样可以提高代码的可读性和可维护性。
开放封闭原则（Open Closed Principle，OCP）：软件实体（类、模块等）应该对扩展开放，对修改关闭。通过使用抽象和接口，可以使得系统容易进行扩展，而不需要修改已有的代码。
里氏替换原则（Liskov Substitution Principle，LSP）：子类应该能够替换其父类并且保持程序的逻辑正确性。子类应该遵守父类定义的接口和规范。
依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不应该直接依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于具体实现细节，而是应该依赖于抽象。
接口隔离原则（Interface Segregation Principle，ISP）：客户端不应该依赖于它不需要的接口。一个类或模块应该只有与其相关的接口，而不应该依赖于不需要的接口。
迪米特法则（Law of Demeter，LoD）：一个对象应该对其他对象有尽可能少的了解。减少对象之间的直接依赖关系可以提高代码的可维护性和灵活性。
组合/聚合复用原则（Composition/Aggregation Reuse Principle，CARP）：优先使用组合或聚合关系，而不是继承关系，来实现代码复用。组合和聚合关系更加灵活，避免了类之间的紧耦合。

基础.md 8.5 KB Cronologia Originale