登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›技术面：Java并发（线程同步、死锁、多线程编排） ...

技术面：Java并发（线程同步、死锁、多线程编排）

丧血槌 6 小时前
线程同步的方式有哪些？

线程同步

线程同步，是多线程编程中的一种机制，用于协调多个线程的执行顺序，确保它们在共享资源或关键操作上按照预定的规则运行，避免因并发访问导致的数据不一致、竞态条件（Race Condition）等问题。
线程同步的方式有哪些？


  • synchronized 关键字，通过 JVM 内置的锁机制实现线程同步，确保同一时刻只有一个线程访问共享资源。既可以修饰实例方法也可以修饰静态方法，也可以锁代码块和锁住某个具体的实例对象。
  1. public synchronized void method() { ... } // 实例方法锁（this）
  2. public static synchronized void method() { ... } // 类方法锁（Class 对象）
  3. // 锁实例对象
  4. synchronized (lockObject) {
  5.     // 同步代码块
  6. }
复制代码

  • ReentrantLock 基于 java.util.concurrent.locks.Lock 接口实现的可重入互斥锁，需显式调用 lock() 和 unlock()进行加锁和解锁。
    支持公平锁、可中断锁、超时锁以及多条件变量（Condition），相比 synchronized 提供了更高的灵活性。
  1. ReentrantLock lock = new ReentrantLock();
  2. lock.lock();
  3. try {
  4.     // 同步代码
  5. } finally {
  6.     lock.unlock();
  7. }
复制代码

  • Semaphore（信号量），允许多个线程同时访问资源，但是限制访问线程的数量。
  1. Semaphore semaphore = new Semaphore(3); // 初始许可数为3
  2. semaphore.acquire(); // 获取许可
  3. try {
  4.     // 同步代码
  5. } finally {
  6.     semaphore.release(); // 释放许可
  7. }
复制代码

  • CountDownLatch，允许多个线程等待其他线程执行完毕之后再执行，用于线程间的协作。
  1. public class LatchDemo {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         int threadCount = 3;
  4.         CountDownLatch latch = new CountDownLatch(threadCount);
  6.         for (int i = 1; i <= threadCount; i++) {
  7.             new Thread(() -> {
  8.                 System.out.println(Thread.currentThread().getName() + " 初始化完成");
  9.                 latch.countDown(); // 子线程完成，计数器减 1
  10.             }, "线程-" + i).start();
  11.         }
  13.         latch.await(); // 主线程等待所有子线程完成
  14.         System.out.println("所有子线程完成，主线程继续执行");
  15.     }
  16. }
复制代码

  • CyclicBarrier，多个线程互相等待，所有线程都到到屏障点后，再继续执行。线程计数器可重置。
  1. import java.util.concurrent.BrokenBarrierException;
  2. import java.util.concurrent.CyclicBarrier;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  6. public class CyclicBarrierExample {
  7.     // 总和变量（线程安全）
  8.     private static int sum = 0;
  9.     // 线程池
  10.     private static final ExecutorService executor = Executors.newFixedThreadPool(5);
  12.     public static void main(String[] args) {
  13.         // 定义需要等待的线程数量（5个）
  14.         CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
  15.             // 所有线程到达屏障后执行的回调（汇总结果）
  16.             System.out.println("所有线程已完成计算，总和为: " + sum);
  17.         });
  19.         // 启动5个线程
  20.         for (int i = 0; i < 5; i++) {
  21.             executor.execute(() -> {
  22.                 try {
  23.                     // 模拟线程计算
  24.                     int value = (int) (Math.random() * 100);
  25.                     System.out.println(Thread.currentThread().getName() + " 计算值: " + value);
  26.                     // 将计算结果累加到总和中
  27.                     sum += value;
  29.                     // 调用await()等待其他线程到达屏障
  30.                     cyclicBarrier.await();
  31.                 } catch (InterruptedException | BrokenBarrierException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             });
  35.         }
  37.         // 关闭线程池
  38.         executor.shutdown();
  39.     }
  40. }
复制代码

  • Phaser，和CyclicBarrier类似，但是支持更灵活的屏障操作，适用于复杂多阶段任务，支持动态注册/注销参与者，并可控制各参与者的阶段进度，并可以控制各个参与者的到达和离开。
  1. Phaser phaser = new Phaser(1); // 初始参与线程
  2. phaser.bulkRegister(3);        // 动态注册3个工作线程
  4. for (int i = 0; i < 3; i++) {
  5.     new Thread(() -> {
  6.         for (int phase = 0; phase < 2; phase++) {
  7.             phaser.arriveAndAwaitAdvance(); // 阶段1：等待所有线程完成阶段1
  8.             // 执行阶段2任务
  9.         }
  10.         phaser.arriveAndDeregister(); // 完成并注销
  11.     }).start();
  12. }
  14. // 主线程等待所有线程完成
  15. phaser.arriveAndAwaitAdvance();
复制代码

  • 其他，另外还有volatile，这种能保证可见性和有序性，但不能保证原子性的关键字。以及基于CAS实现的Atomic 类（无锁同步），但是仅适用于简单数据类型和部分操作（如 getAndAdd）。
死锁

死锁，通常是指在两个或多个进程（或线程、事务）在执行过程中，因争夺资源而陷入相互等待的状态，导致所有进程都无法继续执行。
什么情况下会产生死锁？

产生死锁的四个必要条件

  • 互斥（Mutual Exclusion），一个资源只能被一个进程占用，其他进程必须等待其释放。
  • 占有并等待（Hold and Wait），进程在持有资源的同时，申请新的资源。
  • 不可剥夺（No Preemption），资源只能由持有它的进程主动释放，不能被强制剥夺。
  • 循环等待（Circular Wait），存在一个进程环，每个进程都在等待下一个进程所持有的资源。
1.png

如何解决死锁？

上面我们已经知道产生死锁有四个必要条件，那解决死锁，只需要破坏死锁的这些必要条件即可。
一般从以下几方面入手即可：

  • 破坏“占有并等待”条件

    • 进程或线程一次性申请所需的所有资源，否则不分配任何资源。（可能导致资源利用率低，进程长期等待资源）
    • 进程或线程申请资源时，必须释放已持有的所有资源。（可能导致频繁的资源释放和重新申请，增加系统开销）

  • 破坏“不可剥夺”条件，允许系统强制回收资源。（可能中断进程的正常执行，导致数据不一致）
  • 破坏“循环等待”条件，要求进程或线程按顺序申请资源。保证多个进程(线程)的执行顺序相同即可避免循环等待。这是最常用的解决死锁的方法。
    例如：事务1的执行顺序是：A->B->C，事务2的执行顺序是：C->D->A，这种情况下就容易产生死锁。因为事务1占用了A，等待C，但是事务2占用了C但是等待A。因此只需要把事务2的执行顺序改成：A->D->C，这样事务2在执行时，会发现事务1占用着A呢，因此事务会先不执行，等待事务1释放A。
    2.png

死锁如何恢复？


  • 回滚进程或线程，可以执行一个或多个进程（或线程）回滚到安全状态，释放资源。一般回滚时，要遵循按优先级选择（优先级低的进程先回滚） 。按资源占用时间选择（占用时间短的进程先回滚）。
  • 终止进程或线程，直接终止全部或部分死锁进程（或线程），释放资源。（可能导致数据丢失或事务不完整）
  • 资源剥夺，从某些进程或线程中强制回收资源分配给其他进程。
  • 超时机制，为进程或线程设置等待资源的超时时间，若超时则自动放弃请求并释放已占资源。
数据库中的死锁

在操作数据库时，如果有多个事务并发执行，也是可能发生死锁的。当事务1持有资源A的锁，但是尝试获取资源B的锁，而事务2持有资源B的锁，尝试获取资源A的锁的时候，这时候就会发生死锁的情况。
当数据库发生死锁的时候，会报出来如下的错误：
  1. Error updating database. Cause: ERR-CODE: [TDDL-4614][ERR EXECUTE ON MYSQL]
  2. Deadlock found when trying to get lock;
  4. The error occurred while setting parameters### SQL:
  6. update test_table set updated=now(),type_state = ? where test_num = 123
复制代码
数据库操作中如何避免死锁？

一般对于数据库的死锁，主要是避免发生并发更新同一资源的操作。或者可以考虑保证操作的顺序，比如多个事务都是先操作资源A、再操作资源B，这样就能有效的避免死锁。
还有一些其他优化措施：
减少事务持有锁的时间：尽快提交或回滚事务。
锁粒度控制：使用行级锁而非表级锁，减少资源竞争。
避免嵌套事务：减少循环等待的可能性。
多线程编排

在 Java 中，多线程的编排可以通过多种方式实现，主要涉及 线程池、同步机制、并发工具类 以及 任务协调工具（如 Future、CompletableFuture）等。
CompletableFuture怎么实现多线程异步编排？

CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。
我在【上一篇文章】提过CompletableFuture底层就是用ForkJoinPool来实现，那么CompletableFuture如何使用来实现多线程任务编排的呢？
单个任务

runAsync：无返回值
  1. CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
  2.     System.out.println("无返回值任务执行中");
  3. });
复制代码
supplyAsync：有返回值
  1. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
  2.     return "异步任务结果";
  3. });
  4. System.out.println(future.get()); // 输出: 异步任务结果
复制代码
指定线程池

因为CompletableFuture默认底层是使用的ForkJoinPool.commonPool()，但是也是可以自定义线程池，配置线程的一些指定信息。
  1. ExecutorService executor = Executors.newFixedThreadPool(2);
  2. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
  3.     return "自定义线程池任务";
  4. }, executor);
复制代码
两个任务编排

thenApplyAsync：能接收上一次的执行结果，还可以有返回值
  1. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
  2.     .thenApplyAsync(result -> result + " World");// 运行结果 Hello World
复制代码
thenRunAsync：不能接收上一次的执行结果，并且也没返回值
  1. CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
  2.             return "Hello";
  3.         }).thenRunAsync(() -> {
  4.             System.out.println("after Hello World");
  5.         });
复制代码
组合多个任务编排


  • 串行组合（thenCompose），可以将前一个任务的结果传递给下一个任务（链式依赖）
  1. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
  2. .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " World"));
  3. System.out.println(future.get()); // 输出: Hello World
复制代码

  • 并行组合（thenCombine），将两个独立任务的结果进行合并
  1. CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
  2. CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
  3. future1.thenCombine(future2, (result1, result2) -> result1 + " " + result2)
  4.        .thenAccept(System.out::println); // 输出: Hello World
复制代码

  • 多任务并行（allOf / anyOf）


  • allOf：等待所有任务完成
  1. CompletableFuture<Void> allFutures = CompletableFuture.allOf(
  2.     CompletableFuture.runAsync(() -> System.out.println("Task 1")),
  3.     CompletableFuture.runAsync(() -> System.out.println("Task 2"))
  4. );
  5. allFutures.get(); // 等待所有任务完成
复制代码

  • anyOf：任一任务完成即触发
  1. CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(
  2.     CompletableFuture.supplyAsync(() -> "Task 1"),
  3.     CompletableFuture.supplyAsync(() -> "Task 2")
  4. );
  5. System.out.println(anyFuture.get()); // 输出: Task 1 或 Task 2（取决于哪个先完成）
复制代码
任务编排异常处理


  • 捕获异常（exceptionally），在任务抛出异常时提供默认信息。
  1. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
  2.     if (Math.random() > 0.5) throw new RuntimeException("失败");
  3.     return "成功";
  4. }).exceptionally(ex -> {
  5.     System.out.println("异常处理: " + ex.getMessage());
  6.     return "默认值";
  7. });
  8. System.out.println(future.get());
复制代码

  • 全局处理（handle / whenComplete）


  • handle：处理异常并返回新结果
  1. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
  2.     if (Math.random() > 0.5) throw new RuntimeException("失败");
  3.     return "成功";
  4. }).handle((result, ex) -> {
  5.     if (ex != null) {
  6.         System.out.println("异常处理: " + ex.getMessage());
  7.         return "默认值";
  8.     }
  9.     return result;
  10. });
复制代码

  • whenComplete：无论成功或失败均执行（不可中断）
  1. CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
  2.     if (Math.random() > 0.5) throw new RuntimeException("失败");
  3.     return "成功";
  4. }).whenComplete((result, ex) -> {
  5.     if (ex != null) System.out.println("任务失败");
  6.     else System.out.println("任务成功: " + result);
  7. });
复制代码
3.png

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
丧血槌
6 小时前

0

粉丝关注

14

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫