加载类的过程？

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载7个阶段。

  1. 加载：通过一个类的全限定名来获取定义此类的二进制字节流，将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构，在内存中生成一个代表这个类的Class对象，作为方法区这个类的各种数据的访问入口
  2. 验证：验证是连接阶段的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟自身的安全。
  3. 准备：准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。这时候进行内存分配的仅包括类变量（static），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中。
  4. 解析：解析阶段是虚拟机将常量池内的符号（Class文件内的符号）引用替换为直接引用（指针）的过程。
  5. 初始化：初始化阶段是类加载过程的最后一步，开始执行类中定义的Java程序代码（字节码）。

HashMap底层为什么使用红黑树？

好处就是避免在最极端的情况下链表变得很长很长，在查询的时候，效率会非常慢。
红黑树查询：其访问性能近似于折半查找，时间复杂度 O(logn)；

  • 链表查询：这种情况下，需要遍历全部元素才行，时间复杂度 O(n)；
  • 简单的说，红黑树是一种近似平衡的二叉查找树，其主要的优点就是“平衡“，即左右子树高度几乎一致，以此来防止树退化为链表，通过这种方式来保障查找的时间复杂度为 log(n)。

红黑树的特点：

  1. 每个节点要么是红色，要么是黑色，但根节点永远是黑色的；
  2. 每个红色节点的两个子节点一定都是黑色；
  3. 红色节点不能连续（也即是，红色节点的孩子和父亲都不能是红色）；
  4. 从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点；
  5. 所有的叶节点都是是黑色的（注意这里说叶子节点其实是上图中的 NIL 节点）；

如果你的应用中，搜索的次数远远大于插入和删除，那么选择AVL树，
如果搜索，插入删除次数几乎差不多，应选择红黑树

值传递和引用传递

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量.
引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。

AQS独占锁和共享锁

ReentrantLock会保证执行do something在同一时间有且只有一个线程获取到锁，其余线程全部挂起，直到该拥有锁的线程释放锁，被挂起的线程被唤醒重新开始竞争锁。

共享功能的主要实现为CountDownLatch，CountDownLatch是一种灵活的闭锁实现，它可以使一个或多个线程等待一组事件发生。闭锁状态包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件数量。countDown递减计数器，表示有一个事件已经发生了，而await方法等待计数器达到零，这表示所有需要等待的时间都已经发生。如果计数器值非零，那么await会一直阻塞直到计数器为零，或者等待线程中断，或者等待超时。

ReentrantLock中lock和tryLock的区别

1: lock拿不到锁会一直等待。tryLock是去尝试，拿不到就返回false，拿到返回true。
2: tryLock是可以被打断的，被中断 的，lock是不可以。

Synchronized和ReentrantLock的区别

image.png

Synchronized锁升级的过程

无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁
大多数时候是不存在锁竞争的，常常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。

一开始是无锁状态。此时第一个线程进来了，在对象头Mark Word中看到此时是无锁状态，就把此时的锁升级为偏向锁，并将自己的线程id用CAS的方式赋值到Mark Word中。然后就进入到了该线程的同步块中。
如果此时有第二个线程进来，它会去查看当前偏向锁的线程id是否是自己，结果发现不是，但是此时还是会去CAS尝试修改线程id指向自己，去赌一下第一个线程此时是否已经释放了。如果释放了，它会将锁状态改为无锁状态，将线程id置空。然后第二个线程拿到这个资源，将线程id赋值给自己，锁升级为偏向锁。如果第一个线程没有释放，JVM会在第一线程到达安全点的时候撤销当前的偏向锁。拷贝Mark Word到锁记录中。然后两个线程用CAS的方式去修改Mark Word中的指针指向自己，假如说第一个线程修改成功了，然后将锁升级为轻量级锁，去执行同步语句块中的内容。修改失败的第二个线程会进入自旋状态，自旋结束后会继续去尝试CAS修改指针指向自己。如果自旋失败超过一定次数的时候，会请求JVM将此时的锁状态升级为重量级锁，这是依赖于底层操作系统的调度库实现的。

悲观锁和乐观锁

每次读取数据的时候，都会担心数据被修改，所以每次查询数据的时候都会加锁，确保自己在读取数据的时候不会被别人修改。使用完成后对数据经行解锁，由于数据经行加锁，期间对该数据进行读写的其他线程都会进行等待。

每次获取数据的时候，都不会担心数据被修改，所以每次获取数据的时候都不会进行加锁。但是在更新数据的时候需要判断该数据是否被别人修改过。如果数据被其他线程修改，则不进行数据更新，如果数据没有被其他线程修改，则进行数据更新。由于数据没有进行加锁，期间该数据可以被其他线程进行读写操作。

悲观锁：比较适合写入操作比较频繁的场景，如果出现大量的读取操作，每次读取的时候都会进行加锁，这样会增加大量的锁的开销，降低了系统的吞吐量。

乐观锁：比较适合读取操作比较频繁的场景，如果出现大量的写入操作，数据发生冲突的可能性就会增大，为了保证数据的一致性，应用层需要不断的重新获取数据，这样会增加大量的查询操作，降低了系统的吞吐量。

CountDownLatch和Semaphore的区别和底层原理

image.png

MySQL的执行流程

image.png


RPC和Restful的区别

1.restfull和rpc都是client/server模式的，都是在 Server端 把一个个函数封装成接口暴露出去
2.restful使用http协议实现，而rpc则不一定使用http，一般比较常用的是tcp， RPC 可以获得更好的性能（省去了 HTTP 报头等一系列东西）,TCP更加高效，而HTTP在实际应用中更加的灵活。
3.从使用上来说：Http接口只关注服务提供方（服务端），对于客户端怎么调用，调用方式怎样并不关心；而RPC服务则需要客户端接口与服务端保持一致，服务端提供一个方法，客户端通过接口直接发起调用。

面向对象


什么是面向对象？对比面向过程，是两种不同的处理问题的角度，面向过程更注重事情的每一个步骤及顺序，面向对象更注重事情有哪些参与者（对象）、及各自需要什么，面向过程比较直接高效，而面向对象更易于复用、扩展和维护。
封装：封装的意义，在于明确标识出允许外部使用的所有成员函数和数据项，内部细节对外部调用透明，外部调用无需修改或者关心内部实现
继承：继承基类的方法，并做出自己的改变和/或扩展，子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的
多态：基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同

JDK、JRE、JVM之间的区别

JDK：Java Develpment Kit java 开发工具
JRE：Java Runtime Environment java运行时环境
JVM：java Virtual Machine java 虚拟机
2022面试题 - 图5

==和equals方法之前的区别

==：对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址
equals：object中默认也是采用==比较，通常会重写
Ojbect

  1. public boolean equals(Object obj) {
  2.     return (this == obj);
  3. }

String

  1. public boolean equals(Object anObject) {
  2.     if (this == anObject) {
  3.         return true;
  4.     }
  5.     if (anObject instanceof String) {
  6.         String anotherString = (String)anObject;
  7.         int n = value.length;
  8.         if (n == anotherString.value.length) {
  9.             char v1[] = value;
  10.             char v2[] = anotherString.value;
  11.             int i = 0;
  12.             while (n-- != 0) {
  13.                 if (v1[i] != v2[i])
  14.                     return false;
  15.                 i++;
  16.             }
  17.             return true;
  18.         }
  19.     }
  20.     return false;
  21. }

上述代码可以看出，String类中被复写的equals()方法其实是比较两个字符串的内容。

  1. public class StringDemo {
  2.       public static void main(String args[]) {
  3.           String str1 = "Hello";
  4.           String str2 = new String("Hello");
  5.           String str3 = str2; // 引用传递
  6.           System.out.println(str1 == str2); // false
  7.           System.out.println(str1 == str3); // false
  8.           System.out.println(str2 == str3); // true
  9.           System.out.println(str1.equals(str2)); // true
  10.           System.out.println(str1.equals(str3)); // true
  11.           System.out.println(str2.equals(str3)); // true
  12.      }
  13.  }

hashCode()与equals()之间的关系

HashCode介绍：hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，Java中的任何类都包含有hashCode() 函数。
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

以“HashSet如何检查重复”为例子来说明为什么要有hashCode
对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，看该位置是否有值，如果没有、HashSet会假设对象没有重复出现。但是如果发现有值，这时会调用equals()方法来检查两个对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样就大大减少了equals的次数，相应就大大提高了执行速度。

  • 如果两个对象相等，则hashcode一定也是相同的
  • 两个对象相等,对两个对象分别调用equals方法都返回true
  • 两个对象有相同的hashcode值，它们也不一定是相等的
  • 因此，equals方法被覆盖过，则hashCode方法也必须被覆盖
  • hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

final关键字的作用是什么？

修饰类：表示类不可被继承
修饰方法：表示方法不可被子类覆盖，但是可以重载
修饰变量：表示变量一旦被赋值就不可以更改它的值。
修饰成员变量：

  • 如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值。
  • 如果final修饰的是成员变量，可以在非静态初始化块、声明该变量或者构造器中执行初始值。

修饰局部变量：
系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时，即可以在定义时指定默认值（后面的代码不能对变量再赋值），也可以不指定默认值，而在后面的代码中对final变量赋初值（仅一次）

  1. public class FinalVar {
  2.     final static int a = 0;//再声明的时候就需要赋值 或者静态代码块赋值
  3.     /**
  4.     static{
  5.         a = 0;
  6.     }
  7.     */
  8.     final int b = 0;//再声明的时候就需要赋值 或者代码块中赋值   或者构造器赋值
  9.     /*{
  10.         b = 0;
  11.     }*/
  12.     public static void main(String[] args) {
  13.         final int localA;   //局部变量只声明没有初始化，不会报错,与final无关。
  14.         localA = 0;//在使用之前一定要赋值
  15.         //localA = 1;  但是不允许第二次赋值
  16.     }
  17. }

修饰基本类型数据和引用类型数据：

  • 如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；

  • 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的

    1. public class FinalReferenceTest{
    2.   public static void main(){
    3.       final int[] iArr={1,2,3,4};
    4.       iArr[2]=-3;//合法 
    5.       iArr=null;//非法，对iArr不能重新赋值
    7.       final Person p = new Person(25);
    8.       p.setAge(24);//合法
    9.       p=null;//非法 
    10.   }   
    11. }

    为什么局部内部类和匿名内部类只能访问局部final变量？
    编译之后会生成两个class文件，Test.class Test1.class ```java public class Test { public static void main(String[] args) {
    }
    //局部final变量a,b public void test(final int b) {//jdk8在这里做了优化, 不用写,语法糖，但实际上也是有的，也不能修改

    1.   final int a = 10;
    2.   //匿名内部类
    3.   new Thread(){
    4.       public void run() {
    5.           System.out.println(a);
    6.           System.out.println(b);
    7.       };
    8.   }.start();

    } }

class OutClass { private int age = 12;

  1.     public void outPrint(final int x) {
  2.             class InClass {
  3.                     public void InPrint() {
  4.                             System.out.println(x);
  5.                             System.out.println(age);
  6.                     }
  7.             }
  8.             new InClass().InPrint();
  9.     }

} ``` 首先需要知道的一点是: 内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁。
这里就会产生问题：当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在(只有没有人再引用它时，才会死亡)。这里就出现了一个矛盾：内部类对象访问了一个不存在的变量。为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的”copy”。这样就好像延长了局部变量的生命周期
将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？
就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致。

aop和aspectj的区别

aspectj是编译的时候通过对注解@before，@after等注解的解析，对目标类进行增强。
spring aop使用aspectj的一套注解，使用动态代理的方式，通过代码解析注解，生成代理类，对方法进行增加。

[

](https://blog.csdn.net/qq_43370771/article/details/111353046)