JUC

⋯

什么是JUC?它包含了哪些主要的组件

JUC是 java.util.concurrent 的简称,是Java提供的用于并发编程的工具包。包含了大量用于多线程编程的实用组件,主要分为以下几类:

  1. 原子类:AtomicInteger、AtomicLong、AtomicReference,提供线程安全的原子操作。

  2. 锁框架:ReentrantLock、ReentrantReadWriteLock、StampedLock,提供比 synchronized 更灵活的锁机制。

  3. 并发集合:ConcurrentHashMap、CopyOnWriteArrayList、BlockingQueue,支持高并发环境下的线程安全操作。

  4. 线程池:ThreadPoolExecutor、ScheduledThreadPoolExecutor,以及 Executors 工具类,用于管理和复用线程。

  5. 同步工具类:Semaphore、CountDownLatch、CyclicBarrier、Phaser、Exchanger,用于协调多个线程之间的协作。

  6. Fork/Join框架:用于并行计算,将任务拆分成子任务并行执行,最后合并结果。

创建线程有哪几种方式?

  1. 继承Thread类:重写 run() 方法,创建子类对象并调用 start()。

  2. 实现Runnable接口:实现 run() 方法,创建Thread对象时传入Runnable实例。

  3. 实现Callable接口:实现 call() 方法,通过FutureTask包装后提交给Thread或线程池。

  4. 使用线程池:通过 ExecutorService.submit() 提交任务,由线程池创建线程。

  5. 使用匿名内部类或Lambda,本质是Runnable或Callable。

volatile关键字有什么用?

volatile是Java提供的轻量级同步机制,具有两个主要特性:

  • 保证可见性:当一个线程修改了volatile变量的值,新值会立即被写回主内存,其他线程读取该变量时能看到最新值(通过缓存一致性协议)。

  • 禁止指令重排序:volatile变量的读写操作前后会插入内存屏障,防止编译器或处理器对指令进行重排序,从而保证有序性。

但volatile不保证原子性,例如i++操作仍需同步。

  • 悲观锁:假设并发冲突(线程安全问题)严重,每次操作数据前都加锁,阻塞其他线程。例如 synchronized、ReentrantLock。适用场景:写多读少、并发冲突高的场景,如数据库行锁。

  • 乐观锁:假设并发冲突较少,不加锁,但在更新时检查版本是否被修改(CAS、版本号机制)。适用场景:读多写少、冲突概率低的场景,如计数器、库存扣减。

  • 乐观锁通常通过CAS(Compare and Swap,比较并交换)实现。CAS是一种原子操作,包含三个操作数:内存位置V、预期原值A和新值B。执行时,只有当V的值等于A时,才将V更新为B,否则不更新。整个过程是原子的。

  • CAS的实现依赖于硬件指令,由CPU保证原子性。在Java中,Unsafe 类提供了CAS操作,许多并发工具基于它实现。

ReentrantLock和synchronized有什么区别?

synchronized 和 ReentrantLock 都是可重入的互斥锁,都能用于保护共享数据,区别主要有以下几个:

  • 使用方式:synchronized 是关键字,进入同步范围时自动加锁,退出时自动释放;ReentrantLock 是类,需要显式加锁,并在 finally 中解锁。

  • 公平性:synchronized 不保证公平;ReentrantLock 默认非公平,也可以配置为公平锁。

  • 中断和超时:等待进入 synchronized 不能通过中断直接取消;ReentrantLock 的 lockInterruptibly() 支持中断,tryLock(timeout, unit) 支持超时。注意,普通的 lock() 不会因为中断就放弃等待。

  • 等待通知:synchronized 配合对象的 wait()、notify()、notifyAll();ReentrantLock 可以创建多个 Condition,分别管理不同的等待条件。

  • 底层实现:synchronized 由 JVM 实现,涉及对象的锁状态和监视器;ReentrantLock 基于 AQS,利用同步状态、CAS 和等待队列协调线程。

ReentrantLock和synchronized可重入吗?

都可重入。

可重入锁是指同一个线程在获取了锁之后,可以再次重复获取该锁而不会造成死锁或其他问题。当一个线程持有锁时,如果再次尝试获取该锁,就会成功获取而不会被阻塞。

什么是AQS?它的核心原理是什么?

AQS(AbstractQueuedSynchronizer)是Java并发包的基础框架,用于构建锁和同步器。(ReentrantLock、Semaphore)。其核心原理是:

  1. 状态管理。通过一个 volatile int state 变量表示同步状态,子类通过 getState、setState、compareAndSetState 方法修改状态。

  2. CLH队列。AQS内部维护一个FIFO的双向队列,用于存放等待获取锁的线程。当线程获取同步状态失败时,会被封装成Node节点加入队列尾部,并通过自旋和阻塞实现等待。

  3. 独占/共享模式。AQS支持独占模式和共享模式,子类通过实现 tryAcquire、tryRelease 等方法定义资源获取和释放的逻辑。

  4. 条件队列。AQS内部还支持 Condition 对象,每个Condition对应一个条件队列,用于实现线程的等待/通知机制。

ReentrantLock 基于AQS实现,其原理如下:

  • 同步器:内部有一个 Sync 类继承AQS,并实现了公平锁 FairSync 和非公平锁 NonfairSync 两个子类。

  • 加锁:调用 lock() 时,会委托给 Sync 的 lock() 方法。非公平锁直接尝试CAS获取锁,若成功则设置当前线程为独占线程;若失败则进入AQS的 acquire() 流程,再次尝试获取,失败则加入等待队列。

  • 可重入实现: ReentrantLock 通过AQS的 state 变量记录重入次数。当线程第一次获取锁时, state 设为1;如果同一线程再次获取锁, state 递增;释放锁时, state 递减,直到 state=0 才真正释放锁。同时, ReentrantLock 内部记录了当前持有锁的线程,用于判断是否当前线程重入。

  • 区别:

    • 公平锁:多个线程按照请求锁的顺序(FIFO)获取锁,先到先得,不会产生线程饥饿。

    • 非公平锁:允许插队,即新请求的线程可能比等待队列中的线程先获取锁,减少了线程唤醒的开销,但可能导致某些线程长时间获取不到锁(饥饿)。

  • 底层实现:

两者都继承AQS,主要区别在于tryAcquire方法。

  • 非公平锁:在 lock() 时直接尝试CAS获取锁,若成功则设置当前线程;若失败则调用acquire(1),在tryAcquire中再次尝试CAS获取,不考虑队列等待情况。

  • 公平锁:在tryAcquire中,首先检查AQS队列中是否有等待的前驱节点,若有则返回false,进入等待队列;若无才会尝试CAS获取锁。

线程池的底层实现基于 ThreadPoolExecutor 类。

核心参数:

  • corePoolSize:核心线程数,即使空闲也保留的线程数。

  • maximumPoolSize:最大线程数,线程池允许的最大线程数。

  • keepAliveTime:非核心线程空闲存活时间(超过核心线程数的线程)。

  • unit:存活时间单位。

  • workQueue:任务队列,用于存放等待执行的任务。

  • threadFactory:线程工厂,用于创建新线程。

  • handler:拒绝策略,当任务无法提交时执行。

提交一个任务时,处理流程如下:

  1. 当前线程数小于核心线程数,创建一个工作线程来执行新任务。

  2. 当前线程数达到核心线程数,尝试把新任务放进任务队列,等待工作线程领取。

  3. 任务无法入队,尝试继续创建工作线程,但线程总数不能超过最大线程数。

  4. 任务无法入队,也无法继续创建线程,执行拒绝策略。

  5. 当线程空闲时间超过 keepAliveTime,且当前线程数大于核心线程数,多余线程会被终止。

线程池有哪些类型?了解哪些线程池?

Java通过 Executors 工厂类提供了几种预定义的线程池:

  1. FixedThreadPool:固定大小线程池,核心线程数 = 最大线程数,使用无界队列 LinkedBlockingQueue。

  2. CachedThreadPool:缓存线程池,核心线程数为0,最大线程数很大,使用同步队列SynchronousQueue,线程空闲60秒后回收。

  3. SingleThreadExecutor:单线程线程池,使用无界队列,保证任务顺序执行。

  4. ScheduledThreadPool:进程调度线程池,支持定时及周期性任务执行的线程池,使用延迟队列DelayedWorkQueue。

  5. WorkStealingPool:工作窃取线程池,基于ForkJoinPool。

Executors 提供的工厂方法存在以下问题:

  • FixedThreadPool 和 SingleThreadPool:允许的任务队列长度为 Integer.MAX_VALUE,可能导致堆积大量请求,最终内存溢出。

  • CachedThreadPool 和 ScheduledThreadPool:允许的线程数最大为 Integer.MAX_VALUE,可能创建大量线程,导致资源耗尽或OOM。

生产中应通过 ThreadPoolExecutor 直接创建,明确指定核心线程数、最大线程数、队列容量和拒绝策略。

ThreadLocal使用不当可能导致内存泄漏,主要注意事项:

  • 务必在不再使用时调用 remove() 方法,尤其在使用了线程池的环境中,因为线程复用会导致ThreadLocal中的值一直存在,无法被回收。

  • 避免使用ThreadLocal存储大对象,因为其生命周期与线程绑定,可能长期占用内存。

  • ThreadLocal变量应定义为 static,避免创建多个实例。

在项目中防止OOM的做法:

  • 在使用ThreadLocal的代码块结束后,主动调用ThreadLocal.remove()清理。

  • 使用try-finally块确保移除操作一定执行。

  • 对于Web应用,在拦截器或过滤器中统一处理,在请求结束后清除当前线程的ThreadLocal。

  • 因为ThreadLocal的内存泄漏主要发生在ThreadLocalMap中的Entry对value的强引用。每个Thread内部维护一个ThreadLocalMap,其中Entry的key是ThreadLocal实例(弱引用),value是用户设置的值(强引用)。

  • 当ThreadLocal实例被回收后(线程池中的线程长期存活),其对应的Entry的key变为null,但value仍然被Entry强引用,而Entry又被当前线程强引用,导致value无法被回收,除非线程结束或手动remove。

  • 垃圾回收器无法回收这些value,因为它们仍有强引用链可达(线程 -> ThreadLocalMap -> Entry -> value)。

  1. ConcurrentHashMap:线程安全的哈希表,JDK1.7采用分段锁,JDK1.8采用CAS+synchronized对每个桶加锁,支持高并发。读操作无锁,写操作锁住单个桶,允许多线程同时读和写不同桶。还提供了弱一致性迭代器。

  2. CopyOnWriteArrayList:线程安全的ArrayList,采用“写时复制”策略。所有修改操作(add、set)都会复制底层数组,修改后替换原数组,因此读操作无锁且并发读安全。适合读多写少的场景。

CopyOnWriteArrayList 是线程安全的 ArrayList 变体。当执行修改操作时,不直接修改原数组,而是先复制一个新数组,在新数组上进行修改,然后将内部数组引用指向新数组。读操作不加锁,直接读取原数组。

  • 线程安全:写操作通过 ReentrantLock 加锁,保证同一时刻只有一个线程进行写操作,复制过程对读线程无影响。

  • 适用场景:适合读多写少的并发场景,比如说缓存、监听器列表。因为写操作涉及数组复制,开销较大,不适合频繁写。同时,数据最终一致性,读操作是可能读取到旧数据的。


复盘手记

搜索笔记

输入关键词,搜索所有主题与问答。