java并发编程

小阡打工日记

于 2024-06-12 19:51:59 发布

阅读量1.3k

点赞数 58

文章标签： java 数据库开发语言并发编程

本文链接：https://blog.csdn.net/m0_64021225/article/details/139631981

版权

什么是java的并发编程

Java并发编程是利用Java语言提供的多线程机制来编写能够同时执行多个任务的程序，以提高程序执行效率和响应速度。Java并发编程的核心内容包括线程基础、同步机制、并发工具类、高级并发构建块等几个方面。

1. 线程基础

Thread类与Runnable接口：创建线程有两种方式，一是继承Thread类并重写run()方法；二是实现Runnable接口，并同样重写run()方法，然后通过Thread对象来启动。
线程生命周期：线程从创建到死亡会经历新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、等待/计时等待（Waiting/Timed Waiting）和终止（Terminated）等状态。
线程调度：Java线程调度基于优先级和抢占式，但具体的调度策略依赖于操作系统。

2. 同步机制

锁（Lock）：从JDK 5开始引入了java.util.concurrent.locks包下的锁，如ReentrantLock，提供了比synchronized关键字更灵活的锁机制。
synchronized：Java内置的同步关键字，可用于方法或代码块，保证同一时刻只有一个线程可以执行该段代码。
volatile：用于修饰变量，保证了变量的可见性和部分有序性，但不保证原子性。

3. 并发工具类

线程池（Executor框架）：java.util.concurrent.ExecutorService接口及其实现类，如ThreadPoolExecutor，用于管理线程池，提高资源利用率和响应速度。
Future与Callable：Future代表异步计算的结果，Callable类似于Runnable，但可以有返回值。
CountDownLatch、CyclicBarrier、Semaphore：用于线程间的协调，分别用于等待多个线程完成、同步多个线程到某个屏障点后再继续执行、控制同时访问特定资源的线程数量。

4. 高级并发构建块

原子类（Atomic）：如AtomicInteger等，提供了一组线程安全的原子操作类，用于在高并发环境下进行简单数值操作。
并发集合（ConcurrentHashMap、CopyOnWriteArrayList等）：专为高并发场景设计的数据结构，提供线程安全的读写操作。
** Fork/Join框架**：从JDK 7开始引入，用于并行处理大数据集，通过分治策略将大任务拆分成小任务并行处理。

5. 死锁与活锁、饥饿

死锁：两个或多个进程因争夺资源而永久阻塞，无法继续执行。
活锁：线程没有被阻塞，但由于某些条件一直无法继续执行。
饥饿：一个或多个线程因无法获得所需资源而无法执行。

6. 并发编程最佳实践

减少锁的范围和持有时间，避免不必要的同步。
使用并发工具类代替低级别的锁操作。
注意线程安全，避免共享可变数据。
正确使用线程池，合理配置线程数。
利用并发编程模型提高代码的可伸缩性和性能。

Java并发编程是一个复杂且重要的领域，理解并熟练应用上述概念和工具，对于开发高性能、高可靠的多线程应用程序至关重要。

Java的并发编程提供了多种锁机制、线程池机制以及AbstractQueuedSynchronizer（AQS）框架，这些是实现高效并发控制的关键组件。

锁机制

synchronized关键字
- 内部锁：自动加锁解锁，简化编程，保证了同一时刻只有一个线程能执行特定的代码块或方法。
- 可重入：同一个线程可以多次进入同一把锁，不会出现自己把自己锁住的情况。
- 锁升级/降级：Java 6后引入了偏向锁、轻量级锁和重量级锁的概念，根据竞争程度动态调整锁的实现，优化性能。
ReentrantLock（可重入锁）
- 来自java.util.concurrent.locks包，相比synchronized更加灵活，支持公平锁和非公平锁，以及尝试获取锁、超时获取锁等特性。
- Condition：与ReentrantLock搭配使用，提供了比wait/notify更强大的线程间协作能力。
读写锁（ReentrantReadWriteLock）
- 提供了读锁和写锁，允许多个读取者同时访问共享资源，但在写入时会互斥，适用于读多写少的场景。
StampedLock
- 从Java 8引入，提供乐观读锁、悲观读锁、写锁及转换操作，是ReentrantReadWriteLock的升级版，更灵活但也更复杂。

Java中的锁机制是实现线程同步的关键组件，它确保了在多线程环境下对共享资源的正确访问和修改。Java提供了多种锁机制，主要包括隐式锁和显式锁，以下是几种重要锁机制的概述：

隐式锁（synchronized）

关键字synchronized：提供了一种简单的方式来实现同步代码块或方法，确保同一时间只有一个线程可以执行该代码块或方法。
锁升级：从无锁、偏向锁、轻量级锁到重量级锁的自动升级过程，以适应不同程度的线程竞争。
- 偏向锁：默认认为只有一个线程会访问同步块，减少无竞争情况下的开销。
- 轻量级锁：在存在少量竞争时使用，线程通过自旋（忙等待）尝试获取锁，避免了重量级锁的系统开销。
- 重量级锁：当自旋失败，或者存在多个线程竞争时，会膨胀为重量级锁，这时未获取到锁的线程会被阻塞。

显式锁（Lock接口）

java.util.concurrent.locks.Lock：提供了比synchronized更灵活的锁机制，包括可中断锁、定时锁、公平锁等。
ReentrantLock：实现了Lock接口，支持可重入，即线程可以多次获取同一把锁，也支持公平和非公平模式。
ReadWriteLock：为读多写少场景设计，分为读锁和写锁，读锁可以共享，写锁独占，提高了并发效率。

其他同步工具

Semaphore：信号量，用于控制同时访问特定资源的线程数量。
CountDownLatch：允许一个或多个线程等待其他线程完成特定操作。
CyclicBarrier：多个线程相互等待，直到达到某一预定数量后再一起执行后续操作。
Phaser 和 Exchanger：更高级的同步工具，分别用于阶段性的任务同步和线程间数据交换。

锁优化机制

自旋锁：线程在等待锁时不是立即挂起，而是循环检查锁状态，减少上下文切换开销。
锁消除：JVM在运行时检测到某些对象的锁实际上不存在竞争，会自动去掉锁操作。
锁粗化：如果一系列连续操作都是对同一对象加锁解锁，JVM可能会合并这些锁操作，减少开销。
偏向锁的撤销与恢复：当发生竞争时，偏向锁会升级，但在竞争结束后，有可能重新变为偏向锁。

了解和掌握这些锁机制及其应用场景，能够帮助开发者编写出高效、安全的并发程序，避免诸如死锁、活锁和饥饿等问题。

线程池机制

Java通过java.util.concurrent.ExecutorService接口和其实现类（如ThreadPoolExecutor和Executors工具类）来管理线程池。

核心概念：核心线程数、最大线程数、线程空闲时间、任务队列、拒绝策略等。
创建线程池：Executors提供静态方法创建固定大小、可缓存、定时调度等不同类型的线程池。
优势：减少线程创建销毁开销，有效控制系统资源，提高响应速度和可管理性。

线程池机制是Java并发编程中的一个重要概念，用于高效管理线程的创建、执行和回收，以减少线程创建和销毁的开销，提高系统资源利用率和响应速度。Java中的线程池主要通过java.util.concurrent.ExecutorService接口和其实现类，尤其是ThreadPoolExecutor类来实现。下面是线程池机制的关键组成部分和工作原理的详细说明：

关键组件

线程池：线程池由一组预先创建的工作线程组成，这些线程可以重复执行任务。线程池的大小（最小线程数、核心线程数、最大线程数）可以根据需要配置。
任务队列：任务队列用于存储待执行的任务。当线程池中的线程空闲时，它们会从任务队列中获取任务并执行。常见的队列实现有LinkedBlockingQueue（无界或有界）、ArrayBlockingQueue（有界）和SynchronousQueue（直接传递）。
工作线程：工作线程是线程池中的实际执行单元，它们负责从任务队列中获取任务并执行任务的逻辑。线程池管理这些线程的生命周期。
任务：任务是需要线程池执行的单元，通常实现为Runnable接口或Callable接口的对象。Runnable不返回结果，而Callable可以有返回值，并且可以抛出异常。

工作原理

初始化：创建线程池时，会初始化指定数量的核心线程。这些线程会一直存活，即使它们处于空闲状态，除非线程池被显式关闭。
任务提交：当任务通过execute或submit方法提交给线程池时，首先尝试将任务添加到任务队列中。
线程分配：
- 如果当前活动线程数小于核心线程数，即使队列为空也会创建新线程来执行任务。
- 如果核心线程都在忙碌且队列未满，新提交的任务会被添加到队列中等待执行。
- 当队列已满，且当前线程数小于最大线程数，会创建新线程执行任务。达到最大线程数后，超出的任务将根据拒绝策略处理。
线程回收：
- 当线程池中的线程数量超过核心线程数，且有空闲线程超过一定时间（keepAliveTime），这些多余的线程会被回收。
拒绝策略：如果线程池和队列都达到了最大容量，新提交的任务会触发拒绝策略，如AbortPolicy(默认，抛出异常)、CallerRunsPolicy(在调用者线程中执行任务)、DiscardPolicy(静默丢弃任务)、DiscardOldestPolicy(丢弃队列最旧的任务并尝试重新提交当前任务)等。

通过这样的机制，线程池能够有效地管理线程资源，确保系统在高并发场景下也能稳定运行，同时保持良好的性能和资源利用率。

AbstractQueuedSynchronizer（AQS）

AQS是Java并发包中的一个基础框架，用于实现依赖于先进先出（FIFO）等待队列的阻塞锁和相关同步器。

内部结构：维护了一个volatile int state（表示同步状态）和一个双向链表（CLH队列）来管理等待线程。
状态管理：通过CAS操作修改state来实现线程安全状态变更。
同步队列：未获取到锁的线程会被加入队列，等待前驱释放锁后唤醒。
广泛应用于：ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock等并发工具类的内部实现。

AbstractQueuedSynchronizer（AQS）是Java并发包中的一个非常核心的抽象类，位于java.util.concurrent.locks包下，它为实现依赖于先进先出（FIFO）等待队列的阻塞锁和同步器（信号量、事件等）提供了一个框架。AQS简化了同步组件的实现，比如ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch等，都是基于AQS构建的。

核心概念

同步状态（State）：AQS维护一个整型的同步状态state，代表锁的状态。不同的子类可以赋予它不同的意义，如在ReentrantLock中表示重入次数，在Semaphore中表示可用许可的数量。
双向链表（CLH队列）：AQS内部维护了一个双向链表（FIFO队列），用于管理等待获取锁的线程。线程在尝试获取锁失败时，会被构造成一个节点加入到队列中，当锁释放时，会从队列头取出节点对应的线程来唤醒。
CAS操作：AQS大量使用了compareAndSwapInt（或类似方法）来保证状态更新的原子性，这是非阻塞同步的基础。
Condition队列：AQS还支持多个等待条件队列，每个条件都有自己的等待队列，通过ConditionObject实现，用于更精细的线程等待/唤醒控制。

工作原理

获取锁：线程尝试获取锁（或资源）时，会调用acquire(int arg)方法，该方法会尝试修改同步状态并检查是否成功。如果当前状态允许获取锁，则修改状态并返回；否则，线程将构造一个节点加入到等待队列，并阻塞自己。
释放锁：释放锁（或资源）时调用release(int arg)方法，它会修改同步状态并唤醒队列中的头节点所代表的线程（如果有的话），被唤醒的线程会再次尝试获取锁。
公平性与非公平性：AQS允许实现者选择是否公平。公平模式下，线程按照加入队列的顺序获取锁；非公平模式下，线程有机会插队，获取锁前不做检查直接尝试CAS修改状态。