Java并发之线程同步、死锁、多线程编排全面解析

public synchronized void method() { ... } // 实例方法锁（this）
public static synchronized void method() { ... } // 类方法锁（Class 对象）
// 锁实例对象
synchronized (lockObject) {
    // 同步代码块
}

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 同步代码
} finally {
    lock.unlock();
}

Semaphore semaphore = new Semaphore(3); // 初始许可数为3
semaphore.acquire(); // 获取许可
try {
    // 同步代码
} finally {
    semaphore.release(); // 释放许可
}

public class LatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 3;
        CountDownLatch latch = new CountDownLatch(threadCount);
        for (int i = 1; i <= threadCount; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " 初始化完成");
                latch.countDown(); // 子线程完成，计数器减 1
            }, "线程-" + i).start();
        }
        latch.await(); // 主线程等待所有子线程完成
        System.out.println("所有子线程完成，主线程继续执行");
    }
}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CyclicBarrierExample {
    // 总和变量（线程安全）
    private static int sum = 0;
    // 线程池
    private static final ExecutorService executor = Executors.newFixedThreadPool(5);
    public static void main(String[] args) {
        // 定义需要等待的线程数量（5个）
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
            // 所有线程到达屏障后执行的回调（汇总结果）
            System.out.println("所有线程已完成计算，总和为: " + sum);
        });
        // 启动5个线程
        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                try {
                    // 模拟线程计算
                    int value = (int) (Math.random() * 100);
                    System.out.println(Thread.currentThread().getName() + " 计算值: " + value);
                    // 将计算结果累加到总和中
                    sum += value;
                    // 调用await()等待其他线程到达屏障
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
        // 关闭线程池
        executor.shutdown();
    }
}

Phaser phaser = new Phaser(1); // 初始参与线程
phaser.bulkRegister(3);        // 动态注册3个工作线程
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        for (int phase = 0; phase < 2; phase++) {
            phaser.arriveAndAwaitAdvance(); // 阶段1：等待所有线程完成阶段1
            // 执行阶段2任务
        }
        phaser.arriveAndDeregister(); // 完成并注销
    }).start();
}
// 主线程等待所有线程完成
phaser.arriveAndAwaitAdvance();

Error updating database. Cause: ERR-CODE: [TDDL-4614][ERR EXECUTE ON MYSQL]
Deadlock found when trying to get lock;
The error occurred while setting parameters### SQL:
update test_table set updated=now(),type_state = ? where test_num = 123

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("无返回值任务执行中");
});

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "异步任务结果";
});
System.out.println(future.get()); // 输出: 异步任务结果

ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "自定义线程池任务";
}, executor);

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApplyAsync(result -> result + " World");// 运行结果 Hello World

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            return "Hello";
        }).thenRunAsync(() -> {
            System.out.println("after Hello World");
        });

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
.thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " World"));
System.out.println(future.get()); // 输出: Hello World

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
future1.thenCombine(future2, (result1, result2) -> result1 + " " + result2)
       .thenAccept(System.out::println); // 输出: Hello World

CompletableFuture<Void> allFutures = CompletableFuture.allOf(
    CompletableFuture.runAsync(() -> System.out.println("Task 1")),
    CompletableFuture.runAsync(() -> System.out.println("Task 2"))
);
allFutures.get(); // 等待所有任务完成

CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(
    CompletableFuture.supplyAsync(() -> "Task 1"),
    CompletableFuture.supplyAsync(() -> "Task 2")
);
System.out.println(anyFuture.get()); // 输出: Task 1 或 Task 2（取决于哪个先完成）

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) throw new RuntimeException("失败");
    return "成功";
}).exceptionally(ex -> {
    System.out.println("异常处理: " + ex.getMessage());
    return "默认值";
});
System.out.println(future.get());

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) throw new RuntimeException("失败");
    return "成功";
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("异常处理: " + ex.getMessage());
        return "默认值";
    }
    return result;
});

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) throw new RuntimeException("失败");
    return "成功";
}).whenComplete((result, ex) -> {
    if (ex != null) System.out.println("任务失败");
    else System.out.println("任务成功: " + result);
});