面试题-基础篇

面试题-基础篇

一 JVM篇

JVM内存区域有哪些

区域	存取的数据
程序计数器	当前线程所执行的字节码的行号指示器
虚拟机栈	方法运行时创建的栈帧，用于存储局部变量表，操作数栈，动态链接，方法出口等信息，
本地方法栈	与虚拟机栈一样，调用本地Native方法服务的
堆	存放new的对象实例，所有的线程共享
方法区	永生代，存储虚拟机加载的类信息，常量，静态变量，即时编译后的代码等数据

垃圾回收算法有哪些

名称	原理	优点	缺点
复制算法	将内存划分2个相等的区域，垃圾回收时，把存活的对象复制到另一个区域中，最后回收当前使用的区域	实现简单，运行高效，不用考虑内存碎片	消耗内存，对象存活率高时，频繁复制
标记-清除算法	标记出可回收的对象，然后回收被标记的对象所占的空间	实现简单，不需要对象移动	标记清除效率低，会产生大量不连续的内存碎片，提升了垃圾回收的频率
标记整理	在标记可回收的对象后将所有存活的对象压缩到内存的一端，然后对端边界以外的内存进行回收	解决内存碎片的问题	需要局部对象移动，降低效率
分代收集算法	根据对象存活周期将内存分为几块	更加高效，新生代用复制算法，老生代用标记整理算法	实现复杂

垃圾回收器

名称	过程	算法	作用域
Serial	需要GC时，直接暂停其他线程，GC完了再继续 ，只是适用于几十兆内存空间	复制算法	新生代
ParNew	是Serial多线程版本，可以控制线程数量	复制算法	新生代
Parallel	也是多线程垃圾回收器，更关注吞吐量	复制算法	新生代
Serial Old	单线程的收集器	标记整理算法	老年代
Paraller Old	多线程的收集器	标记整理算法	老年代
CMS	1.初始标记，STW只标记根对象直接引用的对象；2.并发标记：继续标记其他对象，并行执行；3.重新标记：STW对并发执行阶段的对象进行重新标记；4、并发清除：并行垃圾清除	标记清除	老年代
G1	1、初始标记：标记出GCRoot直接引用的对象STW;2、标记Region：通过RSet标记上一阶段标记的Region引用到的Old区Region ；3、并发标记：遍历第二步标记出来的Region；4、最终标记，和cms一样；5、筛选回收：回收垃圾，复制算法回收	整体标记整理算法，局部复制算法	新生代和老年代

jvm调优参数

参数	含义
-Xmx	最大堆内存大小
-Xms	初始化堆内存大小
-Xmn	年轻代内存大小
-Xss	每个线程堆栈大小
-XX:NewSize	年轻代初始化内存大小
-XX:MaxNewSize	年轻代最大内存大小
-XX:MaxPermSize	老年代最大内存大小
-XX:PermSize	老年代初始化内存大小
-XX:+UseG1GC	G1垃圾回收器
-XX:MetaspaceSize	原空间的初始内存大小
-XX:MaxMetaspaceSize=N	元空间最大内存大小

内存泄漏OOM

原因

情况	报错信息	原因	解决方案
堆内存泄漏	java heap space	可能存在大对象分配未被释放	1.检查代码是否存在大对象分配；2.通过jmap命令，把堆内存dump下来分析；3.没有找到明显的内存泄漏使用-Xmx加大堆内存
永生代/元空间溢出	PermGen space/metaspace	生成大量的代理类导致方法区被撑爆；应用长时间运行未重启	1.检查永生代或者元空间内存大小是否过小；2.检查代码是否有大量反射操作；3.重启jvm
虚拟机方法栈溢出	unable to create new native Thread	大量创建线程导致	1.通过-Xss降低每个线程栈大小的容量2.线程总数受到系统空间内存和操作系统的限制

问题排查

内存泄漏排查的步骤：
1.jps命令查询所有的java进程
2.jstat命令查询异常进程的运行状态信息
3.jmap命令生成堆内存信息的快照
4.jhat命令是分析jmap生成的dump文件具体的堆内存信息

cpu占用过高问题排查

1、top命令，查询实时的cpu使用情况，找出异常的进程
2、ps命令，查询进程中线程的cpu使用情况，找出异常线程
3、jstack命令，查询异常线程的运行情况，再根据本地代码定位问题。

类加载

双亲委派机制

含义：一种任务委派模式，把请求交由父类处理；
工作原理：类加载器收到加载请求，先委托父类加载器执行，父类加载器还存在其父类加载器，则进一步向上委托，最终到达启动类加载器；如果父类加载器完成任务则返回成功，失败则子类加载器才会尝试加载。向上委托查询，向下委托加载。
作用：防止重复加载同一个类，加载过了就不会重新加载；为了安全防止核心类不被篡改，不同的加载器加载同一个类也不是同一个class对象。

破坏双亲委派机制举例

1、所有涉及SPI的加载动作都破坏了，如JNDI，JDBC，JCE，JAXB，JBI
2、tomact类加载

类加载过程

加载：把java的字节码数据加载到JVM内存当中，并映射成JVM认可的数据结构。
连接：1.验证，检查加载的字节码信息是否符合JVM规范；2.准备，创建类或者接口的静态变量，并赋初始值；3.解析，把静态变量的符合引用转成直接引用
初始化:对静态变量和静态代码块执行初始化工作

JAVA基础

对象

存储数据

名称	内容
对象头	包括二部分Mard Word和Klass Word。Mard Word：用于存储对象自身运行时数据，如哈希码，GC分代年龄，锁状态标记，线程持有的锁，偏向锁ID，偏向时间戳，64位虚拟机占用内存64位，Klass word:类型指针指向对象所属的指针
对象实例数据	对象实例数据
对齐填充	jvm要求对象占用空间为8的倍数，不够用该空间补足

JVM锁升级过程

1. 如果没有当成锁就是一个普通对象，锁标记位位01，是否偏向锁改为0；
2. 当对象当成同步锁并有线程A抢到锁时，锁标记位位01，是否偏向锁改为1，并记录锁的线程ID，表示进入偏向锁状态；
3. 当线程A再次试图获取锁，由于偏向锁记录的ID就是线程A，表示A已经获取到锁，直接执行同步锁的代码；
4. 当线程B试图获取锁时，发现锁是偏向锁，但是偏向锁线程ID不是B,那么线程B先用CAS操作试图获取锁，如果抢锁成功，偏向锁ID改成线程B的id，然后可以执行同步锁代码；
5. 如果抢锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。JVM会在当前线程栈中开辟一块单独的空间，通过CAS保存对象锁Mark Word指针同时在对象锁Mark word中保存指向这片空间的指针。如果成功代表线程抢锁成功，Mark word中锁标记位改成0，可以执行同步锁代码。如果保存失败，代表抢锁失败，竞争太激烈了。
6. 轻量级锁抢锁失败，JVM使用自旋锁+CAS不断尝试获取锁，自旋次数有JVM决定。
7. 如果自旋锁重试之后还是失败，同步锁升级为重量级锁，标记位改为10，该状态下的锁线程都会被堵塞。

集合

名称	数据结构	特点
ArrayList	数组	查询快,增删慢，线程不安全,效率高
LinkedList	双向链表	查询慢,增删快，线程不安全,效率高
Vector	数组	查询快,增删慢，线程安全,效率低
CopyOnWriteArrayList	数组	写操作加锁，读操作不加锁，安全
HashSet	HashMap	不可重复，线程安全
LinkedHashSet	链表+HashMap	由链表保证元素有序，由哈希表保证元素唯一
TreeSet	红黑树	元素排序，唯一
HashMap	数组+链表+红黑树	不安全，效率高
LinkedHashMap	双向链表和哈希	元素有序，唯一
HashTab	HashMap	线程安全，效率低
TreeMap	红黑树	元素排序和唯一
ConcurrentHashMap	hashmap	线程安全

hashcode与equals重写原因

因为 Set 存储的是不重复的对象，依据 hashCode 和 equals 进行判断，所以 Set 存储的对象必须重写这两个方法；
如果自定义对象做为 Map 的键，那么必须重写 hashCode 和 equals。为了保证相同的对象存储在相同的位置上。

接口和抽象类的区别

类型	抽象类	接口
方法	可以存在普通方法	方法都是抽象的
成员变量	可以存在各种类型的	只能是public static final类型的
多个实现	只能继承一个	可以实现多个
设计目的	代码复用，当不同类用相同的行为，且一部分行为的实现不一致时，使用抽象类	对类的行为进行约束，要求不同的类具有相同的行为，只约束行为有无，不对如何实现行为进行限制
关系	is a关系	like a关系
使用场景	当你关注事物的本质的时候，使用	当你关注操作的时候，用接口

HashMap原理

数据结构：
1.7 数组+链表
1.8 数据+链表+红黑树

put方法：

链表插入方式不同：
1.7 头插法，会导致查询死循环
1.8 尾插法

扩容后计算数组下标不同：
1.7 直接hash和需要扩容的最大二进制数&异或计算新的值
1.8 直接hash和扩容后容量-1异或，可能在原始位置上，也有可能原始位置加上扩容大小值

长度为什么是2的N次方？
减少hash碰撞

初始长度为什么是16？
需要在效率和内存使用上做一个权衡，太大浪费空间太小频繁发生扩容影响效率，16是一个经验值。

ConcurrentHashMap底层原理

底层实现和HashMap相同。
锁的实现：
1.7 segment分段式锁,ReentrantLock,cas
1.8 通过对table元素使用synchronize加锁实现，CAS

CAS是什么，有什么问题

CAS,比较并替换，当且仅当内存地址和预期值相等时，将内存地址修改成其他值。否则不操作，整个操作是一个原子操作

问题：
ABA问题，通过原子类AtomicStampedReference，增加版本的校验解决

循环时间长开销大，延迟cpu执行时间

只能保证一个共享变量的原子操作，只能使用锁

volatile

可见性通过lock前缀指令在多核处理器引发二件事，第一写volatile时会将缓存写会到主内存，第二是使其他cpu缓存该内存地址的数据无效
禁止重排序是通过加内存屏障实现的。

synchronized

原理

monitorenter指令是编译后插入到同步代码块的开始位置，而monitorexit指令是插入到方法结束处和异常处。JVM保证了每个monitorenter都有对应的monitorexit。任何一个对象都有一个monitor与之关联，当且一个monitor被持有后，对象将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象对应monitor的所有权，即尝试获得对象的锁

synchronized的核心组件

1、Wait set：那些调用wait方法被堵塞的线程存放位置；
2、Contention list:竞争队列，所有请求锁的线程首先放入该队列中；
3、Entry list：竞争队列中那些有资格成为候选资源的线程；
4、OnDeck：任意时刻最多只有一个线程正在竞争锁资源，该线程称为OnDeck;
5、Owner：当前已经获取到资源的线程
6、非Owner：当前释放锁的线程。

synchronized的实现

1、等待的线程会先尝试自旋获取锁，如果获取不到进入竞争队列。
2、当Owner释放锁时，将竞争队列的部分线程迁移到Entry list中，并制定Entry list中某一个线程为Ondeck线程（一般为最先进入的那个线程）；
3、OnDeck线程需要重新竞争锁，只有当获取到锁资源后才会变成Owner线程，而没有获取得到锁的仍然停留在EntryList
4、如果Owner被wait方法堵塞，则转移到WaitSet队列，直到通过notify或者notiyAll唤醒，会重新进去EntryList中
5、处于ContentionList，EntryList，WaitSet中的线程都是处于堵塞状态。

参考文档

synchronized和reentrantlock区别

reentrantlock流程：
先通过CAS尝试获取锁，
如果锁被占用，该线程加入AQS队列并等待
如果锁被释放，挂在队列为首的线程会被唤醒，然后继续CAS尝试获取锁，
非公平锁，其他线程尝试获取锁，可能会被抢占；
公平锁，只有在队列头的线程才可以获取锁，新来的线程只能插入队尾

synchronized 是java关键词，JVM层面的锁，底层是锁的升级，锁的是对象，锁信息保持在对象头中
reentrantlock是java类，API层面的锁，底层是int类型的state标识来标识锁的状态。

AQS的理解

• AQS是一个集同步状态管理，线程释放，线程堵塞，及队列管理与一身的同步框架。
• 在AQS中，维护了一个信号量state和一个线程组成的双向链表队列。其中这个线程队列就是给线程排队而state就是一个红绿灯，用来控制线程排队或者放行的。
• 在可重入锁场景下，state表示加锁的次数，0表示无锁，没加一次锁，state就加1，释放锁state就减1.

线程

线程状态

状态	含义
新建	新创建一个线程对象
就绪	调用start方法，等待获取cpu的使用权
运行	获取cpu，执行程序代码
堵塞	因为某种原因放弃cpu的使用权，暂停运行
死亡	线程执行完或者因异常退出

线程池状态

状态	含义
RUNNING	能接受新提交的任务，并且也能处理阻塞队列中的任务
SHUTDOWN	关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown()方法会使线程池进入到该状态
STOP	不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态
TIDYING	如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态
TERMINATED	在terminated() 方法执行完后进入该状态，默认terminated()方法中什么也没有做
线程池的生命周期流程图：

线程关键字

类型	sleep	wait
方法	Thread类的静态本地方法	object类的本地方法
是否释放锁	不会	会
是否依赖Synchronized	否	是
是否需要唤醒	否，休眠后退出堵塞	是，需要别人中断
作用	用于线程休眠，或者轮询暂停操作	用于多线程之间的通信
cpu	让出put时间且强制上下文切换	还有机会重新竞争到锁继续执行

yieid()执行后线程进入就绪状态，马上释放cpu执行权，但是保留cpu的执行资格。

join()执行后线程进入堵塞状态，例如线程B调用线程A的Join()，线程B进入堵塞状态，直到线程A结束或中断线程。

wait方法：告诉当前线程，释放锁，然后开始睡眠等待，此时的状态为Watting，直到有线程进入一样的监视器调用notify或者notifyAll唤醒它
notify方法：随机唤醒一个在一样的对象监视器上等待的线程
notifyAll方法：唤醒所有的在一样对象监视器上等待的线程

守护线程

守护线程：为所有用户线程提供服务的线程，任何一个守护线程都是整个JVM所有非守护线程的保护。他的生死无关重要，却依赖整个进程运行，当其他线程运行结束，守护进程会直接中断。
作用：为其他线程提供服务支持；在任何情况下，程序结束时，这个线程必须正常且立即关闭，

线程池

好处

1、降低资源消耗，提升线程利用率，降低创建和销毁效率
2、提高响应速度，任务来了直接有线程可用可执行；
3、提高线程的管理性，线程是稀缺的，统一分配调优监控。

线程池的参数

字段	含义
corePoolSize	线程池的核心线程数
maximumPoolSize	线程池允许创建的最大线程数
keepAliveTime	线程活动保持时间
unit	参数 keepAliveTime 的时间单位
workQueue	任务队列，用来存放待执行的任务
threadFactory	创建线程的工厂
handler	饱和策略

堵塞队列

队列	含义
ArrayBlockingQueue	是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
LinkedBlockingQueue	一个基于链表结构的有界阻塞队列，此队列按 FIFO （先进先出） 排序元素，吞吐量通常要高于 ArrayBlockingQueue。
SynchronousQueue	一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 LinkedBlockingQueue，静态工厂方法 Executors.newCachedThreadPool 使用了这个队列。当不想使用堵塞队列的时候使用它
PriorityBlockingQueue	一个具有优先级的无限阻塞队列。

超时怎么释放线程

public class ThreadPoolTimeoutExample {

public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(10);

    Future<String> future = executor.submit(new Callable&lt;String&gt;() {
        @Override
        public String call() throws Exception {
            Thread.sleep(3000); // 模拟耗时任务
            return &quot;任务执行结果&quot;;
        }
    });

    try {
        String result = future.get(5, TimeUnit.SECONDS); // 设置超时时间为5秒
        System.out.println(&quot;任务执行结果：&quot; + result);
    } catch (TimeoutException e) {
        System.out.println(&quot;任务执行超时&quot;);
        future.cancel(true); // 取消任务的执行
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
    executor.shutdown();
}

}

饱和策略

名称	含义
AbortPolicy	直接抛出异常。
CallerRunsPolicy	只用调用者所在线程来运行任务。
DiscardOldestPolicy	丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy	不处理，丢弃掉。
RejectedExecutionHandler	自定义策略如记录日志或持久化不能处理的任务。

线程池执行示意图

ThreadLocal

ThreadLocal是什么

含义：
叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

底层原理

每一个Thread对象均含有一个ThreadLocalMap类型的成员变量ThreadLocals,它存储本线程所有的Threadlocal对象及其对应的值。
ThreadlocalMap中由Entry对象数组构成，Entry继承自WeakReference<ThreadLocal<?>>,一个Entry有ThreadLocal对象和object构成。Entry的key是由ThreadLocal对象并且是一个弱引用，当没有指向key的强引用后该key就会被垃圾回收器回收。
当执行set方法时，会先获取当前线程对象，然后获取当前线程的ThreadLocalMap对象，如果有值，再以当前的ThreadLocal对象为key。将值存储到ThreadLocalMap对象中。如果没有值，则新建一个ThreadLocalMap对象。
当执行get方法时，会先获取当前线程对象，然后获取当前线程的ThreadLocalMap对象，再以当前的ThreadLocal对象为key获取对应的value。没找到ThreadLocalMap对象，则新建一个ThreadLocalMap对象并返回null，根据key没有找到value，则把null作为value。

使用场景

1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。
2、线程间数据隔离
3、进行事务操作，用于存储线程事务信息。
4、数据库连接，Session会话管理。

导致内存泄漏的原因和解决方案

hreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null， 而value还存在着强引用，只有thead线程退出以后,value的强引用链条才会断掉。但如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

解决方案：
每次使用完ThreadLocal都调用它的remove()方法清除数据；
数据将ThreadLocal变量定义成private static，这样就一直存在ThreadLocal的强引用，也就能保证任何时候都能通过ThreadLocal的弱引用访问到Entry的value值，进而清除掉 。

key使用弱引用的原因

当ThreadLocalMap的key为强引用回收ThreadLocal时，因为ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal就不会被回收，导致Entry内存泄漏。
当ThreadLocalMap的key为弱引用回收ThreadLocal时，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收，当key为null时，下次调用set，get，remove方法时就会清除value。

所有的锁

名称	含义
悲观锁	每次去拿数据的时候都认为别人会修改，因此每次在拿数据的时候都会上锁
乐观锁	每次拿数据都认为别人不会修改，所以读不会上锁，更新数据时，会检查数据是否被修改过，修改过重新读取，基础CAS
自旋锁	不停地循环判断锁是否能够被成功获取
偏向锁	执行到synchronized代码块的时候，锁对象变成偏向锁
轻量级锁	一旦有第二个线程加入锁竞争，偏向锁就升级为轻量级锁（自旋锁）
重量级锁	锁竞争情况严重，某个达到最大自旋次数的线程，会将轻量级锁升级为重量级锁
可重入锁	允许同一个线程多次获取同一把锁，synchronized和lock都是
公平锁	当锁释放的时候，先申请的先得到
非公平锁	后申请的线程可能先获取到锁，是随机或者按照其他优先级排序的。ReentrantLock类而言，通过构造函数传参可以指定该锁是否是公平锁，默认是非公平锁
可中断锁	可以响应中断的锁
读写锁	一个读锁（共享锁）和一个写锁（互斥锁、排他锁）

死锁

由于二个或者多个线程互相持有对方所需的资源，导致这些线程处于等待状态，无法前往执行。

public class JavaTest {
    @Test
    public void test() {
        final Object lockA = new Object();
        final Object lockB = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockA) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lockB) {
                    }
                    System.out.println("finish A");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockB) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lockA) {
                    }
                    System.out.println("finish B");
                }
            }
        }).start();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

分布式锁

1.synchronize单机版ok，分布式不行
2.nginx分布式，单机锁不行
3.取消单机锁上redis分布式锁setnx
4.只加锁，没有释放锁，出异常的话无法释放锁必须在finally释放锁
5.宕机了，没有走到finally，没办法保证解锁，需要增加过期时间
6.setnx+设置过期时间必须同一行
7.不能删除别人的锁，先判断是否是自己的锁
8.redlock之redisson实现

线程安全

线程和进程的区别

进程是操作系统进行资源分配的最小单元
线程是操作系统进行任务分配的最小单元，线程隶属于进程

开启线程方式

继承Thread类，重写run方法；
实现Runnable接口，实现run方法；
实现Callable接口，实现call方法，通过Future创建一个线程，获取到线程执行的返回值；
通过线程池来开启线程。

保证线程安全发方式

JVM提供的锁，Synchronized关键字；
JDK提供的各种锁lock；

日常工作

代码review看那些

功能性: 检查代码是否实现了预期的功能，逻辑是否正确无误。确认边界条件、异常处理是否完善，确保代码在各种情况下都能正常工作。
代码风格和规范: 遵守项目的编码规范，包括命名约定（变量名、函数名、类名等）、缩进、空格、括号使用等。一致的代码风格可以提升代码的可读性和可维护性。
可读性: 代码应当易于阅读和理解。复杂的逻辑应有适当的注释说明，函数和模块应职责清晰，避免过长的函数或类。
复用性和模块化: 评估代码是否有效地利用了现有的库和组件，以及是否合理地抽象和封装功能以促进代码的复用。
性能: 分析代码是否存在性能瓶颈，如不必要的循环、过度的数据库查询、内存泄漏等。考虑是否可以优化算法或数据结构以提高效率。
安全性: 检查代码中是否存在安全漏洞，如SQL注入、跨站脚本(XSS)、不当的数据验证、权限控制不足等安全问题。
测试覆盖率: 评估是否有足够的单元测试、集成测试覆盖代码的关键路径和边界条件，确保修改或新增代码后，既有功能不受影响。
可维护性: 代码结构是否清晰，是否容易理解和修改。长期来看，易于维护的代码能够大大降低项目的成本。
资源管理: 检查资源（如数据库连接、文件流、线程等）是否被正确地打开和关闭，避免资源泄露。
重构建议: 提出改进代码结构、设计模式或算法的建议，使代码更加简洁、高效。

下一篇文章spring篇