做网站哪家,网站建设qinnet,对网站分析,河北邯郸永利ktv视频文章目录 一、概述二、volatile 可见性/有序性三、synchronized 互拆锁/排他锁/非观锁四、DCL#xff08;Double-Checked Locking#xff09;五、CAS#xff08;Compare and Set#xff09;六、ReentrantLock 可重入锁/公平/非公平锁七、ReentrantReadWriteLock 读写锁/共享… 文章目录 一、概述二、volatile 可见性/有序性三、synchronized 互拆锁/排他锁/非观锁四、DCLDouble-Checked Locking五、CASCompare and Set六、ReentrantLock 可重入锁/公平/非公平锁七、ReentrantReadWriteLock 读写锁/共享锁/排他锁八、CountDownLatch 计数等待/同步辅助类九、CyclicBarrier 并行任务/数据加载/同步辅助类十、Phaser 多阶段任务/同步辅助类十一、StampedLock 读写锁共享锁/排他锁十二、Semaphore 信号量/限流/同步辅助类十三、Exchanger 数据交换同步辅助类十四、LockSupport 阻塞和唤醒线程 一、概述
要实现线程同步原理就是加锁。只是看什么情况使用什么锁以及锁的粒度问题。
二、volatile 可见性/有序性 详细使用说明请看Java 多线程之 volatile。 提供可见性保证有序性。虽然提供了可见性和有序性的保证但它并不能保证原子性。对于复合操作如递增或递减操作仍然需要使用其他机制如锁或原子类来保证原子性。 使用方法 volatile int count1 1;
private volatile int count2 2;
volatile boolean flag1 false;
private volatile boolean flag2 false;三、synchronized 互拆锁/排他锁/非观锁 详细使用说明请看Java 多线程之 synchronized。 synchronized 提供了一种简单而强大的机制来控制多个线程之间的并发访问确保共享资源的安全性和一致性。它解决了多线程环境中的竞态条件、数据竞争和内存模型等问题是实现线程安全的重要手段之一。 作用在代码上相当于给代码块加锁Lock public void performTask() {// synchronized 作用于代码块synchronized (lock) {// 业务逻辑同步代码块对共享资源进行操作}}作用在方法上相当于给整个方法加锁Lock // synchronized 作用在方法上public synchronized void increment() {// 业务逻辑同步代码块对共享资源进行操作}四、DCLDouble-Checked Locking 详细使用说明请看Java 多线程之 DCL。 DCL 是 Double-Checked Locking 的缩写是一种用于在多线程环境下延迟初始化对象的技术。它的目标是在保持高性能的同时确保只有一个线程执行对象的初始化过程。 DCL 的实现通常基于以下步骤 检查对象是否已经被创建。如果已经创建则直接返回对象。如果对象尚未创建则尝试获取锁。获取锁后再次检查对象是否已经被创建在获取锁之前的检查只是为了避免不必要的同步。如果对象尚未创建则进行对象的创建和初始化。释放锁。返回对象。 使用方法如下Singleton 是一个在高并发下多线要使用的延迟初始化单例类 public class Singleton {private static volatile Singleton instance;private Singleton() {// 私有构造函数}public static Singleton getInstance() {if (instance null) { // 1.检查对象是否已经被创建synchronized (Singleton.class) { // 2.尝试获取锁if (instance null) { // 3.再次检查对象是否已经被创建instance new Singleton();// 4.如果对象尚未创建则进行对象的创建和初始化}}// 5.释放锁synchronized 语句块结束自动释放锁}return instance; // 6.返回对象}
}需要注意的是 Singleton instance 对象的定义需要使用 volatile 关键字。
五、CASCompare and Set 详细使用说明请看Java 多线程之 CAS 。 实现无锁优化是自旋锁/乐观锁的实现方式。 CAS 是 Compare and Set比较并设置的缩写是一种并发算法用于实现多线程环境下的原子操作。 CAS 操作涉及三个操作数内存位置或称为变量的值、期望值和新值。它的执行过程是将内存位置的当前值与期望值进行比较。如果相等则将新值写入内存位置如果不相等则说明其他线程已经修改了内存位置的值操作失败。 CAS只能检测到预期值是否相等无法感知到变量值的修改过程中是否发生了其他的并发修改可能会引发ABA问题。 java.util.concurrent.atomic.Atomic* 开头的类都用 CAS 实现无锁优化因此在多线程环境中能用这些类就尽量不用悲观锁相关类。 AtomicBoolean atomicBoolean new AtomicBoolean();AtomicInteger atomicInteger new AtomicInteger();AtomicLong atomicLong new AtomicLong();AtomicIntegerArray atomicIntegerArray new AtomicIntegerArray(new int[5]);AtomicLongArray atomicLongArray new AtomicLongArray(new long[5]);//AtomicIntegerFieldUpdater atomicIntegerFieldUpdater new AtomicIntegerFieldUpdater();// 等等 ...六、ReentrantLock 可重入锁/公平/非公平锁 详细使用说明请看Java 多线程之 ReentrantLock。 ReentrantLock 是一个可重入锁与 synchronized 关键字相比ReentrantLock 提供了更灵活、更强大的功能同时也更复杂。 公平锁/非公平锁 直接使用 ReentrantLock 的 lock 和 unlcok 方法基本功能同 synchronized 关键字。但是他比 synchronized 强大的地方在于他可以设置为公平锁和非公平锁以及使用可中断获取锁和超时获取锁方法。 class XXXXXX {private ReentrantLock lock new ReentrantLock(true); // 公平锁//private ReentrantLock lock new ReentrantLock(false); // 非公平锁public void increment() {lock.lock(); // 获取锁// lock.lockInterruptibly(); // 获取可中断的锁// lock.tryLock(3000, TimeUnit.SECONDS);// 在指时间内获取锁try {// 业务逻辑} finally {lock.unlock();// 释放锁}}
}条件变量 Condition ReentrantLock 的条件变量Condition的使用实现线程等待/通知机制。 class BoundedQueueT {private QueueT queue new LinkedList();private int capacity;private ReentrantLock lock new ReentrantLock();private Condition notFull lock.newCondition();private Condition notEmpty lock.newCondition();public BoundedQueue(int capacity) {this.capacity capacity;}public void enqueue(T item) throws InterruptedException {lock.lock();try {while (queue.size() capacity) {// 条件1达到 业务逻辑1等待notFull.await();}queue.add(item);// 通知业务逻辑2执行notEmpty.signalAll();} finally {lock.unlock();}}public T dequeue() throws InterruptedException {lock.lock();try {while (queue.isEmpty()) {// 条件2达到业务逻辑2等等notEmpty.await();}T item queue.poll();// 通知业务逻辑1执行notFull.signalAll();return item;} finally {lock.unlock();}}
}七、ReentrantReadWriteLock 读写锁/共享锁/排他锁 详细使用说明请看Java 多线程之 ReentrantReadWriteLock。 ReentrantReadWriteLock 是Java中提供的一种读写锁实现它允许多个线程同时读取共享资源但在写操作时需要独占访问。它是对传统互斥锁的一种改进可以提高并发性能。 读写锁的主要目的是在读多写少的场景下提供更高的并发性能。当多个线程只需读取共享资源时可以同时获得读锁从而实现并发读取。而当有线程需要对共享资源进行写操作时它必须独占地获取写锁在此期间其他线程无法获取读锁或写锁从而确保数据的一致性和完整性。 获取读锁 rwLock.readLock().lock();
try {// 访问共享资源的读操作
} finally {rwLock.readLock().unlock();
}获取写锁 rwLock.writeLock().lock();
try {// 访问共享资源的写操作
} finally {rwLock.writeLock().unlock();
}八、CountDownLatch 计数等待/同步辅助类 详细使用说明请看Java 多线程之 CountDownLatch。 CountDownLatch 是Java中提供的一种同步工具类用于控制多个线程之间的执行顺序和协调。 CountDownLatch 通过一个计数器来实现该计数器初始化为一个正整数表示需要等待的线程数目。每个线程执行完一定的任务后会调用countDown()方法将计数器减1。当计数器减到0时表示所有线程已经完成任务等待在await()方法处的线程被唤醒继续执行后续操作。 使用方法 int threadCount 3;
CountDownLatch latch new CountDownLatch(threadCount);for (int i 0; i threadCount; i) {// 启动一些子线程来执行任务Thread thread new Thread(() - {// 子线程执行任务System.out.println(执行业务逻辑);// 子线程任务完成计数器减1latch.countDown();});thread.start();
}// 主线程 等待所有线程完成任务
latch.await();
// 所有子线程完成任务后 主线程继续执行后续操作
System.out.println(执行后续业务);
九、CyclicBarrier 并行任务/数据加载/同步辅助类 详细使用说明请看Java 多线程之 CyclicBarrier。 CyclicBarrier循环屏障是Java并发编程中的一种同步辅助工具。它允许一组线程相互等待直到所有线程都到达一个共同的屏障点然后继续执行后续操作。CyclicBarrier可以用于解决多线程任务的协调和同步问题。 CyclicBarrier 的主要作用是使多个线程在某个点上进行同步等待所有线程都到达该点后再一起继续执行。 它类似于一组线程开始跑步跑到3000米时停下等待其他线程跑完全全部到后裁判统计分数然后再同时开始启跑。我感觉有点像三峡大坝的船过闸一样的假如一些船开到三峡大坝的闸内这里他们不能过闸但等一定数量的船后闸门打开这些船只开始继续航行。实际应用如下载N个文件碎片都完成后按顺序合成一个然后再进行分析。 使用方法 import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;public class CyclicBarrierExample {private static final int THREAD_COUNT 3;public static void main(String[] args) {CyclicBarrier barrier new CyclicBarrier(THREAD_COUNT, () - {// 执行屏障动作最后一个到达的线程执行该动作。// 特别说明能执行到这里说明规定数量的线程THREAD_COUNT都执行了 barrier.await(); });for (int i 0; i THREAD_COUNT; i) {Thread thread new Thread(() - {try {// 执行业务逻辑barrier.await(); // 线程到达屏障点等待其他线程// 所以线程都到达屏障点并且已经执行屏障作用后才会执行这里的代码} catch (InterruptedException | BrokenBarrierException e) {e.printStackTrace();}});thread.start();}}
}十、Phaser 多阶段任务/同步辅助类 详细使用说明请看Java 多线程之 Phaser。 Phaser 也是Java并发编程中的一种同步辅助工具用于线程之间的协调和同步。它提供了比CyclicBarrier和CountDownLatch更灵活和强大的功能可以用于更复杂的多线程协作场景。 Phaser的主要用途是将多个线程分为多个阶段并在每个阶段进行同步。每个线程可以独立运行但在特定的阶段需要等待其他线程到达屏障点。Phaser可以动态地适应线程的注册和注销可以处理可变数量的参与者。 使用方法 import java.util.concurrent.Phaser;public class MultiPhaseTask {private static final int NUM_THREADS 3;public static void main(String[] args) {// 注册线程可以通过构造函数的参数指定也可以通过 phaser.register(); 方法注册线程。Phaser phaser new Phaser(NUM_THREADS) {Overrideprotected boolean onAdvance(int phase, int registeredParties) {System.out.println(第 phase 阶段完成);return false; // 返回 true 会终止 phaser}};for (int i 0; i NUM_THREADS; i) {// phaser.register(); // 如果上面造函数的参数没有指定则启用这句话来注册线程Thread thread new Thread(() - {// 使用 for 循环来模拟3个阶段for (int phase 1; phase 3; phase) {// 这是第 phase 阶段System.out.println(执行第 phase 阶段 任务...); phaser.arriveAndAwaitAdvance(); // 等待其他线程到达屏障点}System.out.println(完成所有阶段);// 解除线程的注册phaser.arriveAndDeregister();});thread.start();}}
}十一、StampedLock 读写锁共享锁/排他锁 详细使用说明请看Java 多线程之 StampedLock。 StampedLock是Java 8引入的一种读写锁的实现它提供了一种乐观的读锁Optimistic Read Lock和悲观的读锁Pessimistic Read Lock和写锁Write Lock以及对读-写冲突的解决方案。StampedLock的设计目标是在读多写少的场景下提供更高的并发性能。与传统的读写锁相比StampedLock更加灵活和高效。 与前面的 ReentrantReadWriteLock 相比StampedLock 在某些情况下可以提供更高的性能但并不是在所有情况下都表现更好。StampedLock 的优势主要表现在支持乐观读取机制和条件等待。所以在写操作频繁而读操作较少和存在大量的锁竞争的情况下直接使用悲观读锁性能跟ReentrantReadWriteLock是相差不大的。 使用方法 import java.util.concurrent.locks.StampedLock;public class StampedLockExample {private Object SharedData;private final StampedLock lock new StampedLock();public void write(Object obj) {//获取写锁long stamp lock.writeLock();try {// 执行写业务逻辑如下SharedData obj;} finally {// 释放写锁lock.unlockWrite(stamp);}}// 完全使用乐观读锁public Object read1() {while(true){Object result null;// 获取乐观读锁long stamp lock.tryOptimisticRead(); // 执行读业务逻辑如下result SharedData;// 验证共享数据是否被修改如果没有被修改过则直接返回。否则重新读if (lock.validate(stamp)) {return result;}}}// 使用乐观读锁 非观读锁public Object read2() {Object result null;// 获取乐观读锁long stamp lock.tryOptimisticRead(); // 执行读业务逻辑这里先读一次如下result SharedData;// 验证共享数据是否被修改if (lock.validate(stamp)) {// 如果共享数据没有被修改过则直接使用return result;}// 获取悲观读锁stamp lock.readLock();try {// 执行读业务逻辑重新读result SharedData;} finally {// 释放写锁lock.unlockRead(stamp);}return result;}
}十二、Semaphore 信号量/限流/同步辅助类 详细使用说明请看Java 多线程之 Semaphore。 Semaphore信号量是一种并发控制机制用于控制对共享资源的访问。它维护了一个计数器可以限制同时访问某个资源的线程数量。常用于限制同时访问某个资源的线程数量例如控制数据库连接池的并发访问、控制线程池的并发任务数、生产者-消费者问题、读者-写者问题等。 使用方法 public class SemaphoreExample {private Semaphore semaphore new Semaphore(5); // 允许同时访问资源的线程数量这里设置为5表示可以有5个线程同时访问public void accessResource() {try {semaphore.acquire(); // 获取许可证如果有许可证则计数器减1如果没有可用许可证则阻塞// 访问共享资源的代码} catch (InterruptedException e) {// 处理中断异常} finally {semaphore.release(); // 释放资源计数器加1}}
}十三、Exchanger 数据交换同步辅助类 详细使用说明请看Java 多线程之 Exchanger。 Exchanger交换器是Java并发包中的一个工具类用于两个线程之间交换数据。它提供了一个同步点当两个线程都到达该点时它们可以交换数据并且在交换完成后继续执行。 使用方法 import java.util.concurrent.Exchanger;public class ExchangerExample {private ExchangerString exchanger new Exchanger();// 线程1public void thread1() {try {// 执行线程1的业务逻辑String data1 线程1的业务数据;String exchangedData exchanger.exchange(data1);// exchangedData 是线程2的业务数据在这里可以继续处理交换后的数据// 执行线程1的业务逻辑} catch (InterruptedException e) {}}// 线程2public void thread2() {try {// 执行线程2的业务逻辑String data2 线程2的业务数据;String exchangedData exchanger.exchange(data2);// exchangedData 是线程1的业务数据在这里可以继续处理交换后的数据// 执行线程2的业务逻辑} catch (InterruptedException e) {}}
}十四、LockSupport 阻塞和唤醒线程 详细使用说明请看Java 多线程之 LockSupport。 LockSupport 是Java并发包中的一个工具类用于线程的阻塞和唤醒。它提供了一种基于线程的许可permit的方式来实现线程的阻塞和唤醒而不需要显式地使用锁。例如某个条件满足后阻塞线程然后等待某个条件满足后再继续执行、实现线程间的协作等。 使用方法 import java.util.concurrent.locks.LockSupport;public class LockSupportExample {public static void main(String[] args) {Thread thread1 new Thread(() - {// 执行业务逻辑LockSupport.park(); // 阻塞当前线程// 继续执行业务逻辑});thread1.start();try {Thread.sleep(2000); // 等待2秒钟} catch (InterruptedException e) {e.printStackTrace();}LockSupport.unpark(thread1); // 唤醒 thread1 线程}
}
