10年java程序员，2024年正好35岁，2024年11月公司裁员，记录自己找工作时候复习的一些要点。
java基础
hashCode()与equals()的相关规定
- 如果两个对象相等，则hashcode一定也是相同的
- 两个对象相等，对两个对象分别调用equals方法都返回true
- 两个对象有相同的hashcode值，它们也不一定是相等的
“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode
方法？”
BIO,NIO,AIO 有什么区别?
-
简答
-
BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方
便，并发处理能力低。 -
NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）
通讯，实现了多路复用。 -
AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操
作基于事件和回调机制。 -
详细回答
-
BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完
成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让
每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问
题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当
面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高
效的 I/O 处理模型来应对更高的并发量。 -
NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应
java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Nonblocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统
BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和
ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模
式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模
式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和
更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发 -
AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它
是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接
返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO
是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是
同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个
线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO
的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。
java集合框架
常用的集合类有哪些？
- Map接口和Collection接口是所有集合框架的父接口：
1、 Collection接口的子接口包括：Set接口和List接口；
2、 Map接口的实现类主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等；
3、 Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等；
4、 List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等；
List，Set，Map三者的区别？
-
Java 容器分为 Collection 和 Map 两大类，Collection集合的子接口有Set、List、Queue三种子接
口。我们比较常用的是Set、List，Map接口不是collection的子接口。 -
Collection集合主要有List和Set两大接口
-
List：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多
个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。 -
Set：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一
个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及TreeSet。 -
Map是一个键值对集合，存储键、值和之间的映射。 Key无序，唯一；value 不要求有序，允许重
复。Map没有继承于Collection接口，从Map集合中检索元素时，只要给出键对象，就会返回对应
的值对象。 -
Map 的常用实现类：HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap
集合框架底层数据结构
- Collection
1、 List；
* Arraylist： Object数组
* Vector： Object数组
* LinkedList： 双向循环链表
2、 Set；
* HashSet（无序，唯一）：基于 HashMap 实现的，底层采用 HashMap 来保存元素
* LinkedHashSet： LinkedHashSet 继承与 HashSet，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 Hashmap 实现一样，不过还是有一点点区别的。
* TreeSet（有序，唯一）： 红黑树(自平衡的排序二叉树。)
-
Map
-
HashMap： JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是
主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8以后在解决哈希冲突时有了较
大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间 -
LinkedHashMap：LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散
列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加
了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的
操作，实现了访问顺序相关逻辑。 -
HashTable： 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突
而存在的 -
TreeMap： 红黑树（自平衡的排序二叉树）
哪些集合类是线安全的？
- Vector：就比Arraylist多了个 synchronized （线程安全），因为效率较低，现在已经不太建议使
用。 - hashTable：就比hashMap多了个synchronized (线程安全)，不建议使用。
- ConcurrentHashMap：是Java5中支持高并发、高吞吐量的线程安全HashMap实现。它由Segment数组结构和HashEntry数组结构组成。Segment数组在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键-值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构；一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素；每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。（推荐使用）
说一下 ArrayList 的优缺点
-
ArrayList的优点如下：
-
ArrayList 底层以数组实现，是一种随机访问模式。ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。
-
ArrayList 在顺序添加一个元素的时候非常方便。
-
ArrayList 的缺点如下：
-
删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较耗费性能。
-
插入元素的时候，也需要做一次元素复制操作，缺点同上。
-
ArrayList 比较适合顺序添加、随机访问的场景。
说一下 HashSet 的实现原理？
- HashSet 是基于 HashMap 实现的，HashSet的值存放于HashMap的key上，HashMap的value统一为present，因此 HashSet 的实现比较简单，相关 HashSet 的操作，基本上都是直接调用底层HashMap 的相关方法来完成，HashSet 不允许重复的值。
HashSet如何检查重复？HashSet是如何保证数据不可重复的？
- 向HashSet 中add ()元素时，判断元素是否存在的依据，不仅要比较hash值，同时还要结合equles 方法比较。
- HashSet 中的add ()方法会使用HashMap 的put()方法。
- HashMap 的 key 是唯一的，由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key，并且在HashMap中如果K/V相同时，会用新的V覆盖掉旧的V，然后返回旧的V。所以不会重复（HashMap 比较key是否相等是先比较hashcode 再比较equals ）。
说一下HashMap的实现原理？
jdk1.7 数组+链表
jdk1.8 数组+链表+红黑树
| 不同 | JDK 1.7 | JDK 1.8 |
|---|---|---|
| 存储结构 | 数组 + 链表 | 数组 + 链表 + 红黑树 |
| 初始化方式 | 单独函数： inflateTable() | 直接集成到了扩容函数 resize() 中 |
| hash值计算方式 | 扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算 | 扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算 |
| 存放数据的规则 | 无冲突时，存放数组；冲突时，存放链表 | 无冲突时，存放数组；冲突 & 链表长度 <8：存放单链表；冲突 & 链表长度 > 8：树化并存放红黑树 |
| 插入数据方式 | 头插法（先讲原位置的数据移到后1位，再插入数据到该位置） | 尾插法（直接插入到链表尾部/红黑树） |
| 扩容后存储位置的计算方式 | 全部按照原来方法进行计算（即hashCode ->> 扰动函数 ->> (h&length-1)） | 按照扩容后的规律计算（即扩容后的位置=原位置 or 原位置 + 旧容量） |
put
get
扩容
并发编程
三个必要因素
- 原子性：原子，即一个不可再被分割的颗粒。原子性指的是一个或多个操作要么全部执行成功要么
全部执行失败。 - 可见性：一个线程对共享变量的修改,另一个线程能够立刻看到。（synchronized,volatile）
- 有序性：程序执行的顺序按照代码的先后顺序执行。（处理器可能会对指令进行重排序）
Java 程序中怎么保证多线程的运行安全？
-
出现线程安全问题的原因一般都是三个原因：
-
线程切换带来的原子性问题 解决办法：使用多线程之间同步synchronized或使用锁(lock)。
-
缓存导致的可见性问题 解决办法：synchronized、volatile、LOCK，可以解决可见性问题
-
编译优化带来的有序性问题 解决办法：Happens-Before 规则可以解决有序性问题
形成死锁的四个必要条件是什么
- 互斥条件：在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，就只能等
待，直至占有资源的进程用毕释放。 - 占有且等待条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进
程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。 - 不可抢占条件：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过
来。 - 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。（比如一个进程集合，A在
等B，B在等C，C在等A）
创建线程的四种方式
- 继承 Thread 类；
public class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " run()方法正在执行...");
}
- 实现 Runnable 接口；
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " run()方法执行中...");
}
- 实现 Callable 接口；
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() {
System.out.println(Thread.currentThread().getName() + " call()方法执行中...");
return 1;
}
}
- 使用匿名内部类方式
public class CreateRunnable {
public static void main(String[] args) {
//创建多线程创建开始
Thread thread = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("i:" + i);
}
}
});
thread.start();
}
}
18. 说一下 runnable 和 callable 有什么区别
相同点：
- 都是接口
- 都可以编写多线程程序
- 都采用Thread.start()启动线程
主要区别： - Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，是个泛型，和Future、
FutureTask配合可以用来获取异步执行的结果 - Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出
异常，可以获取异常信息 注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，
此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
线程的 run()和 start()有什么区别？
- 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，run()方法称为线程
体。通过调用Thread类的start()方法来启动一个线程。 - start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start()
只能调用一次。 - start()方法来启动一个线程，真正实现了多线程运行。调用start()方法无需等待run方法体代码执
行完毕，可以直接继续执行其他的代码； 此时线程是处于就绪状态，并没有运行。 然后通过此
Thread类调用方法run()来完成其运行状态， run()方法运行结束， 此线程终止。然后CPU再调度
其它线程。 - run()方法是在本线程里的，只是线程里的一个函数，而不是多线程的。 如果直接调用run()，其实
就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕才能执行下
面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用
start()方法而不是run()方法。
什么是 Callable 和 Future?
- Callable 接口类似于 Runnable，从名字就可以看出来了，但是 Runnable 不会返回结果，并且无
法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以返回值，这个返回值
可以被 Future 拿到，也就是说，Future 可以拿到异步执行任务的返回值。 - Future 接口表示异步任务，是一个可能还没有完成的异步任务的结果。所以说 Callable用于产生
结果，Future 用于获取结果。
线程状态
sleep() 和 wait() 有什么区别？
两者都可以暂停线程的执行
- 类的不同：sleep() 是 Thread线程类的静态方法，wait() 是 Object类的方法。
- 是否释放锁：sleep() 不释放锁；wait() 释放锁。
- 用途不同：Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。
- 用法不同：wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify()
或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒。或者可以使用wait(long
timeout)超时后线程会自动苏醒。
为什么线程通信的方法 wait(), notify()和 notifyAll()被定义在 Object 类里？
- 因为Java所有类的都继承了Object，Java想让任何对象都可以作为锁，并且 wait()，notify()等方法
用于等待对象的锁或者唤醒线程，在 Java 的线程中并没有可供任何对象使用的锁，所以任意对象
调用方法一定定义在Object类中。 - 有的人会说，既然是线程放弃对象锁，那也可以把wait()定义在Thread类里面啊，新定义的线程继
承于Thread类，也不需要重新定义wait()方法的实现。然而，这样做有一个非常大的问题，一个线
程完全可以持有很多锁，你一个线程放弃锁的时候，到底要放弃哪个锁？当然了，这种设计并不是
不能实现，只是管理起来更加复杂。
为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用？
- 当一个线程需要调用对象的 wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这
个对象锁并进入等待状态直到其他线程调用这个对象上的 notify()方法。同样的，当一个线程需要
调用对象的 notify()方法时，它会释放这个对象的锁，以便其他在等待的线程就可以得到这个对象
锁。由于所有的这些方法都需要线程持有对象的锁，这样就只能通过同步来实现，所以他们只能在
同步方法或者同步块中被调用。
重排序遵守的规则
- as-if-serial：
1、 不管怎么排序，结果不能改变；
2、 不存在数据依赖的可以被编译器和处理器重排序；
3、 一个操作依赖两个操作，这两个操作如果不存在依赖可以重排序；
4、 单线程根据此规则不会有问题，但是重排序后多线程会有问题；
as-if-serial规则和happens-before规则的区别
- as-if-serial语义保证单线程内程序的执行结果不被改变，happens-before关系保证正确同步的多
线程程序的执行结果不被改变。 - as-if-serial语义给编写单线程程序的程序员创造了一个幻境：单线程程序是按程序的顺序来执行
的。happens-before关系给编写正确同步的多线程程序的程序员创造了一个幻境：正确同步的多
线程程序是按happens-before指定的顺序来执行的。 - as-if-serial语义和happens-before这么做的目的，都是为了在不改变程序执行结果的前提下，尽
可能地提高程序执行的并行度。
多线程中 synchronized 锁升级的原理是什么？
- synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候
threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断
threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为
轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的
对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。
锁的升级的目的：锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方
式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。
- 偏向锁，顾名思义，它会偏向于第一个访问锁的线程，如果在运行过程中，同步锁只有一个线程访
问，不存在多线程争用的情况，则线程是不需要触发同步的，减少加锁／解锁的一些CAS操作（比
如等待队列的一些CAS操作），这种情况下，就会给线程加一个偏向锁。 如果在运行过程中，遇
到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会消除它身上的偏向锁，将锁恢复到标
准的轻量级锁。 - 轻量级锁是由偏向所升级来的，偏向锁运行在一个线程进入同步块的情况下，当第二个线程加入锁
争用的时候，轻量级锁就会升级为重量级锁； - 重量级锁是synchronized ，是 Java 虚拟机中最为基础的锁实现。在这种状态下，Java 虚拟机会阻
塞加锁失败的线程，并且在目标锁被释放的时候，唤醒这些线程。
