2024 java大厂面试复习总结（一）（持续更新）

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 虚拟机会阻
  塞加锁失败的线程，并且在目标锁被释放的时候，唤醒这些线程。

线程池

核心参数

执行原理

ConcurrentHashMap

实现原理

并发工具类

原文地址：https://blog.csdn.net/cyljbq/article/details/144022433

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！