java常识

⚡ JVM核心机制深度解析

JVM(Java Virtual Machine)作为Java语言的运行环境,是理解Java技术栈的基石。它不仅负责字节码的执行,还管理内存分配、垃圾回收、类加载等关键任务。掌握JVM原理,是成为高级Java工程师的必经之路。

Java程序源码经编译后生成字节码(.class文件),这些字节码由JVM解释或即时编译为机器码执行。HotSpot虚拟机采用混合模式:解释执行 + JIT(Just-In-Time)编译。JIT将高频执行的“热点代码”编译为本地机器码,大幅提升执行效率。

〔1〕类加载机制与双亲委派模型

类加载过程分为加载、验证、准备、解析、初始化五个阶段:

  • 加载:通过类的全限定名获取二进制字节流,转为方法区的运行时数据结构,并在堆中生成Class对象。
  • 验证:确保字节码符合JVM规范,防止恶意代码破坏虚拟机安全。
  • 准备:为类变量(static字段)分配内存并设置默认初始值(如int→0,引用→null)。
  • 解析:将常量池内的符号引用替换为直接引用。
  • 初始化:执行类构造器()方法,完成静态变量赋值与静态代码块执行。

双亲委派模型(Parent Delegation Model)是JVM类加载的核心策略。当一个类加载器收到加载请求时,它首先不会自己尝试加载,而是委派给父类加载器完成;仅当父加载器无法完成时,子加载器才尝试加载。

Java内置三大类加载器:

类加载器 职责 加载路径示例
Bootstrap ClassLoader 加载JRE核心类库(如java.lang.*、java.util.*) $JAVA_HOME/jre/lib/rt.jar等
Extension ClassLoader 加载扩展类库 $JAVA_HOME/jre/lib/ext/*.jar
Application ClassLoader 加载应用classpath路径下的类 项目依赖的jar与class文件

自定义类加载器可通过继承ClassLoader并重写findClass()方法实现,常用于热部署、插件化、模块隔离等场景。例如,OSGi框架通过自定义类加载器实现模块间的类隔离。

〔2〕内存模型与对象布局

JVM内存分为五大区域:

  • 程序计数器:线程私有,记录当前执行的字节码指令地址;线程切换后能恢复到正确位置。
  • 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈、动态链接、返回地址)。
  • 本地方法栈:为Native方法服务。
  • 堆:线程共享,存放对象实例;是GC的主要区域。
  • 方法区(JDK8后为元空间Metaspace):存储类信息、常量、静态变量、即时编译器编译后的代码。

对象在堆中的内存布局分为三部分:

  1. 对象头(Header):包含两部分——
    • Mark Word(8字节):存储哈希码、GC分代年龄、锁状态标志、线程持有的锁等。
    • Klass Pointer(4字节,32位)或(8字节,64位):指向类元数据的指针。
  2. 实例数据:对象真正存储的有效信息,包括父类字段与子类字段。
  3. 对齐填充:非必须,仅起占位作用,确保对象大小为8字节的倍数。

示例:在64位JVM中,一个空对象(无字段)大小为16字节(对象头12字节 + 对齐填充4字节)。

〔3〕垃圾回收机制与GC算法

GC(Garbage Collection)自动回收不再使用的对象内存,避免内存泄漏。主流GC算法包括:

  • 标记-清除(Mark-Sweep):标记存活对象,清除未标记对象;缺点是产生内存碎片。
  • 复制(Copying):将内存分为两块,每次只用一块,存活对象复制到另一块;无碎片,但空间利用率低。
  • 标记-整理(Mark-Compact):标记后将存活对象向一端移动,清理边界外内存;避免碎片,但移动成本高。

HotSpot虚拟机采用分代收集思想:新生代(Young Generation)与老年代(Old Generation)采用不同GC策略。

新生代:Eden区 + 2个Survivor区(From/To),默认比例为8:1:1。对象优先在Eden分配;Minor GC回收频繁,速度快。

老年代:存放长期存活对象或大对象(通过-XX:PretenureSizeThreshold设置)。Major GC / Full GC回收老年代,速度慢,常伴随Stop-The-World。

常见GC日志分析示例(G1 GC):

[GC pause (G1 Humongous Allocation) (young) (initial-mark), 0.0123456 secs] [Parallel Time: 1.2 ms, GC Workers: 4] [GC Worker Start (ms): 123.4 123.4 123.4 123.4] [Ext Root Scanning (ms): 0.8] [Update RS (ms): 0.2] [Processed Buffers: 4] [Scan RS (ms): 0.1] [Code Root Scanning (ms): 0.0] [Object Copy (ms): 0.1] [Termination (ms): 0.0] [Termination Attempts: 1] [Code Root Fixup: 0.0 ms] [Code Root Purge: 0.0 ms] [Clear CT: 0.1 ms] [Other: 0.9 ms] [Choose CSet: 0.0 ms] [Ref Proc: 0.5 ms] [Ref Enq: 0.0 ms] [Redirty Cards: 0.2 ms] [Humongous Register: 0.0 ms] [Humongous Reclaim: 0.0 ms] [Free CSet: 0.1 ms] [Eden: 2048K(2048K)->0K(2048K) Survivors: 256K->256K Heap: 3072K(4096K)->1024K(4096K)] [Times: user=0.01 sys=0.00, real=0.01 secs]

关键字段说明:

  • G1 Humongous Allocation:触发原因,大对象分配(>Eden区25%)。
  • (young) (initial-mark):GC类型(年轻代)+ 触发阶段。
  • Heap: 3072K(4096K)->1024K(4096K):GC前后堆使用量及堆容量。

调优建议:通过-XX:+PrintGCDetails -Xlog:gc*:file=gc.log:time,uptime,level,tags 分析GC行为;关注Full GC频率与暂停时间。

⚙️ 并发编程与线程安全

并发编程是Java高级开发的核心能力。从Thread到ExecutorService,从synchronized到java.util.concurrent包,Java提供了丰富而强大的并发工具。

〔1〕线程状态与生命周期

Java线程六种状态(Thread.State):

  • NEW:线程刚创建,尚未start()。
  • RUNNABLE:包括Running与Ready状态;线程正在执行或等待CPU时间片。
  • BLOCKED:等待进入synchronized同步块/方法。
  • WAITING:调用Object.wait()、Thread.join()、LockSupport.park()后进入无限期等待。
  • TIMED_WAITING:调用Thread.sleep()、Object.wait(timeout)、LockSupport.parkNanos()等进入有限期等待。
  • TERMINATED:线程执行完毕。

典型阻塞场景:多个线程竞争同一把锁(monitor),导致线程进入BLOCKED状态;使用CountDownLatch.await()进入WAITING状态。

〔2〕synchronized底层原理

关键字synchronized实现互斥同步,其底层依赖JVM的monitor指令实现:

  • 同步代码块:使用monitorenter与monitorexit指令。
  • 同步方法:方法体隐式添加ACC_SYNCHRONIZED标志。

monitor本质是进入对象头的Mark Word中锁状态的切换。JDK6起引入锁优化机制:

  1. 偏向锁:适用于单线程重复获取锁场景。通过CAS将线程ID记录在Mark Word,避免CAS开销。
  2. 轻量级锁:无竞争时,通过自旋替代阻塞。线程在栈帧中创建Lock Record,用CAS替换对象头Mark Word。
  3. 重量级锁:竞争激烈时升级为操作系统互斥量(Mutex),线程阻塞挂起。

锁升级流程:无锁 → 偏向锁 → 轻量级锁 → 重量级锁(单向升级,不可逆)。

示例:以下代码在JDK8中可能触发偏向锁优化:

public class LockExample { private static final Object lock = new Object(); public static void main(String[] args) { for (int i = 0; i < 100; i++) { new Thread(() -> { synchronized (lock) { System.out.println(Thread.currentThread().getName() + " acquired lock"); } }).start(); } } }

可通过-XX:-UseBiasedLocking关闭偏向锁(高并发场景下减少锁撤销开销)。

〔3〕volatile关键字与happens-before规则

volatile确保变量的可见性与禁止指令重排序,但不保证原子性。

内存可见性原理:读取volatile变量时,强制从主内存加载;写入时立即刷新到主内存;其他线程读取时可见最新值。

禁止重排序:通过内存屏障(Memory Barrier)实现。写屏障(StoreLoad)在写操作后插入,确保写结果对其他线程可见。

典型使用场景:

  • 状态标志:public volatile boolean running = true;
  • 双重检查锁单例:
public class Singleton { private static volatile Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }

若无volatile,new Singleton()可能被重排序为:分配内存 → 设置instance引用 → 初始化对象;导致其他线程获取未初始化对象。

〔4〕线程池与Executor框架

线程池通过复用线程减少创建/销毁开销,提升响应速度。核心类ThreadPoolExecutor构造参数如下:

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

参数详解:

  • corePoolSize:核心线程数(常驻线程)。
  • maximumPoolSize:最大线程数。
  • workQueue:阻塞队列(如LinkedBlockingQueue、ArrayBlockingQueue、SynchronousQueue)。
  • handler:拒绝策略(AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy)。

线程池任务提交流程:

  1. 当前线程数 < corePoolSize:直接创建新线程处理任务。
  2. 当前线程数 ≥ corePoolSize:任务加入workQueue。
  3. workQueue满且线程数 < maximumPoolSize:创建新线程处理任务。
  4. 线程数 ≥ maximumPoolSize:执行拒绝策略。

常见线程池创建方式:

ExecutorService fixedPool = Executors.newFixedThreadPool(4); // 固定线程数 ExecutorService cachedPool = Executors.newCachedThreadPool(); // 可缓存线程池 ExecutorService scheduledPool = Executors.newScheduledThreadPool(2); // 定时任务

但阿里开发手册强制要求:禁止使用Executors创建线程池!应手动new ThreadPoolExecutor,明确参数意义,避免资源耗尽风险(如CachedThreadPool无界队列导致OOM)。

〔5〕并发工具类实战

java.util.concurrent包提供丰富工具:

  • CountDownLatch:倒计时门闩,等待多个线程完成。
  • CyclicBarrier:循环栅栏,线程到达屏障后继续执行。
  • Semaphore:信号量,控制并发访问数量。
  • ConcurrentHashMap:线程安全Map,JDK8采用CAS+synchronized优化。
  • AtomicXXX:基于CAS实现原子操作(AtomicInteger、LongAdder)。

LongAdder vs AtomicInteger性能对比(高并发场景):

指标 AtomicInteger LongAdder
并发性能 随竞争加剧,性能急剧下降 高并发下性能更优
内存占用 低 高(分段累加)
适用场景 低竞争或中等竞争 高竞争统计场景(如计数器)

LongAdder通过分段累加(Striped64)减少CAS竞争:多个Cell分别累加,最终求和。适合写多读少的场景。

〔Spring生态与容器原理〕

Spring作为Java企业级开发事实标准,其核心是IoC(控制反转)与AOP(面向切面编程)。深入理解Spring原理,是构建高性能、可维护应用的前提。

〔1〕IoC容器初始化流程

以AnnotationConfigApplicationContext为例,初始化过程包括:

  1. 创建ApplicationContext:实例化容器对象。
  2. 注册配置类:将@Configuration标注的类作为Bean定义注册。
  3. 刷新容器(refresh()):
    1. prepareRefresh():准备刷新,设置启动时间、激活标志。
    2. obtainFreshBeanFactory():获取BeanFactory,创建DefaultListableBeanFactory。
    3. prepareBeanFactory(beanFactory):配置BeanFactory标准特性(类加载器、表达式语言等)。
    4. postProcessBeanFactory(beanFactory):子类扩展点。
    5. invokeBeanFactoryPostProcessors(beanFactory):执行BeanFactory后处理器(如ConfigurationClassPostProcessor)。
    6. registerBeanPostProcessors(beanFactory):注册Bean后处理器(如AutowiredAnnotationBeanPostProcessor)。
    7. initMessageSource():初始化国际化资源。
    8. initApplicationEventMulticaster():初始化事件广播器。
    9. onRefresh():子类初始化特殊Bean(如WebServer)。
    10. registerListeners():注册事件监听器。
    11. finishBeanFactoryInitialization(beanFactory):实例化所有非懒加载单例Bean。
    12. finishRefresh():发布ContextRefreshedEvent事件。

关键点:ConfigurationClassPostProcessor解析@Configuration类,通过BeanDefinitionReader注册Bean定义;最终在finishBeanFactoryInitialization中调用beanFactory.preInstantiateSingletons()实例化Bean。

〔2〕Bean生命周期与作用域

Bean生命周期(单例):

  1. 实例化(Instantiation):通过反射或CGLIB创建对象。
  2. 属性赋值(Populate):依赖注入(@Autowired、@Value等)。
  3. 初始化(Initialization):
    • Aware接口回调(BeanNameAware、BeanFactoryAware等)。
    • InitializingBean.afterPropertiesSet()。
    • 自定义init-method。
  4. 使用(Usage)。
  5. 销毁(Destruction):
    • DisposableBean.destroy()。
    • 自定义destroy-method。

Bean作用域:

  • singleton(默认):容器中仅一个实例。
  • prototype:每次请求创建新实例。
  • request:HTTP请求范围(Web应用)。
  • session:HTTP会话范围。
  • application:ServletContext范围。
  • websocket:WebSocket会话范围。

示例:@Scope("prototype")标注的Bean,每次注入都会创建新实例;而singleton Bean在容器启动时已实例化。

〔3〕AOP实现原理与代理机制

AOP通过代理模式实现横切逻辑织入。Spring AOP默认使用JDK动态代理(基于接口)或CGLIB代理(基于继承)。

代理选择策略:

  • 目标类有接口 → JDK动态代理。
  • 目标类无接口 → CGLIB代理。

JDK动态代理原理:生成代理类实现目标接口,在invoke()方法中织入增强逻辑。

public interface UserService { void save(); } public class UserServiceImpl implements UserService { public void save() { System.out.println("Saving user..."); } } public class JDKProxyExample { public static void main(String[] args) { UserService target = new UserServiceImpl(); UserService proxy = (UserService) Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), (proxy, method, args) -> { System.out.println("Before: " + method.getName()); Object result = method.invoke(target, args); System.out.println("After: " + method.getName()); return result; } ); proxy.save(); } }

CGLIB通过继承目标类生成子类,在重写方法中织入逻辑,适用于无接口场景。但final类、final方法无法代理。

Spring AOP增强类型:

  • Before:前置通知(@Before)
  • AfterReturning:后置通知(@AfterReturning)
  • AfterThrowing:异常通知(@AfterThrowing)
  • After:最终通知(@After,无论是否异常都执行)
  • Around:环绕通知(@Around,最强大)

〔4〕Spring Boot自动装配原理

Spring Boot通过@EnableAutoConfiguration启用自动装配,核心是@Import(AutoConfigurationImportSelector.class)。

加载流程:

  1. 读取META-INF/spring.factories文件中的org.springframework.boot.autoconfigure.EnableAutoConfiguration键值对。
  2. 排除@Conditional注解不满足条件的配置类(如@ConditionalOnClass、@ConditionalOnMissingBean)。
  3. 将符合条件的配置类注册为Bean定义。

典型自动配置类:DataSourceAutoConfiguration、WebMvcAutoConfiguration、RedisAutoConfiguration。

自定义starter需提供:

  • 自动配置类(META-INF/spring.factories中配置)。
  • 配置属性类(@ConfigurationProperties)。
  • 条件判断(@Conditional系列注解)。

示例:mybatis-spring-boot-starter自动配置SqlSessionFactoryBean。

〔性能优化与调优实践〕

性能优化是Java工程师的核心竞争力。从代码层、框架层到系统层,需建立系统性优化思维。

〔1〕JVM调优关键参数

参数 说明 典型值
-Xms -Xmx 堆初始/最大大小 -Xms2g -Xmx2g(避免扩容)
-Xmn 新生代大小 通常为堆的1/4~1/3
-XX:MetaspaceSize 元空间初始大小 256m(JDK8+)
-XX:+UseG1GC 使用G1垃圾回收器 JDK9+默认
-XX:MaxGCPauseMillis GC最大暂停时间目标 200ms

G1调优要点:

  • 避免Humnongous Allocation:大对象(>50% Region)直接进入老年代,建议拆分对象。
  • 合理设置-XX:InitiatingHeapOccupancyPercent(IHOP):默认45%,过低导致过早Mixed GC。
  • 关注Region数量:默认2048个,可通过-XX:G1HeapRegionSize调整(1~32MB)。

〔2〕数据库与缓存优化

常见性能瓶颈点:

  • 慢SQL:通过EXPLAIN分析执行计划;建立联合索引(最左前缀);避免SELECT *。
  • 缓存穿透:缓存空值(短期TTL)或布隆过滤器。
  • 缓存击穿:热点Key加互斥锁(Redis分布式锁)。
  • 缓存雪崩:设置随机过期时间(TTL±随机值)。

示例:布隆过滤器防止缓存穿透:

public class BloomFilterExample { private static final int EXPECTED_INSERTIONS = 1000000; private static final double FPP = 0.01; // 误判率1% private static BloomFilter bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.forName("UTF-8")), EXPECTED_INSERTIONS, FPP); public static void main(String[] args) { bloomFilter.put("user:1001"); System.out.println(bloomFilter.mightContain("user:1001")); // true System.out.println(bloomFilter.mightContain("user:9999")); // 可能false(有误判率) } }

〔3〕JMH基准测试实战

JMH(Java Microbenchmark Harness)是Java官方基准测试工具,避免常见陷阱(如JIT编译、分支预测、死代码消除)。

示例:测试HashMap vs ConcurrentHashMap性能:

@BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.NANOSECONDS) @State(Scope.Thread) public class MapBenchmark { private Map hashMap; private ConcurrentHashMap concurrentHashMap; @Setup public void setup() { hashMap = new HashMap<>(); concurrentHashMap = new ConcurrentHashMap<>(); for (int i = 0; i < 1000; i++) { hashMap.put("key" + i, "value" + i); concurrentHashMap.put("key" + i, "value" + i); } } @Benchmark public String hashGet() { return hashMap.get("key500"); } @Benchmark public String concurrentGet() { return concurrentHashMap.get("key500"); } }

运行命令:mvn clean install && java -jar target/benchmarks.jar

典型结果:HashMap读性能≈20ns,ConcurrentHashMap≈35ns(单线程);多线程下ConcurrentHashMap优势明显。

〔面试高频考点与真题解析〕

深入理解原理是通过技术面试的关键。以下为高频考点与深度解析。

〔1〕Java基础

Q:final、finally、finalize区别?

  • final:修饰类(不可继承)、方法(不可重写)、变量(不可变)。
  • finally:try-catch-finally结构,确保代码块执行(即使异常)。
  • finalize:Object方法,GC前调用(已废弃!JDK9标记为deprecated)。

Q:==与equals区别?

  • ==:基本类型比较值,引用类型比较内存地址。
  • equals:默认同==,String、Integer等重写为比较内容。

正确重写equals需同时重写hashCode:

@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return Objects.equals(name, person.name) && age == person.age; } @Override public int hashCode() { return Objects.hash(name, age); }

〔2〕集合框架

Q:ArrayList与LinkedList区别?

特性 ArrayList LinkedList
底层结构 动态数组 双向链表
随机访问 O(1) O(n)
插入/删除 O(n)(需移动元素) O(1)(仅修改指针)
内存占用 低(仅存储元素) 高(存储节点+前后指针)

Q:HashMap JDK7 vs JDK8差异?

  • JDK7:数组+链表;哈希冲突时链表头插法(多线程易形成环形链表)。
  • JDK8:数组+链表/红黑树;链表长度≥8且数组长度≥64时转红黑树;尾插法避免环形链表。

〔3〕并发编程

Q:CAS原理与ABA问题?

  • CAS:Compare-And-Swap,通过CPU指令实现原子操作(如AtomicInteger)。
  • ABA问题:值从A→B→A,CAS认为未变化;解决方案:AtomicStampedReference(版本戳)。

Q:线程池拒绝策略选择?

  • AbortPolicy:抛出RejectedExecutionException(默认)。
  • CallerRunsPolicy:调用者线程执行(限流降级)。
  • DiscardPolicy:静默丢弃(不推荐)。
  • DiscardOldestPolicy:丢弃队列最老任务(如日志队列)。