【JavaSE】Callable/ReentrantLock/Atomic/Semaphore/CountDownLatch && 线程安全的集合类 && 死锁

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

public static void main(String[] args) throws Exception {
    Callable<String> cable = () -> {
        Thread.sleep(1000);
        return "使用Callable执行完成";
    };

    // 使用FutureTask包装Callable
    FutureTask<String> ft = new FutureTask<>(cable);

    // 传给Thread进行构造
    Thread thread = new Thread(ft);
    thread.start();

    // 使用get()方法获取返回值
    String ret = ft.get();
    System.out.println("结果：" + ret);
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService pool = Executors.newFixedThreadPool(5);

    // submit一个Callable任务，然后返回Future<String>类型，需要强转
    Future<String> ft = pool.submit(() -> {
        try {
            Thread.sleep(1000);
            return "使用Callable执行完成";
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    });

    String ret = ft.get();
    System.out.println("结果：" + ret);
}

if (lock.tryLock()) {
    try {
        // 获取锁成功
    } finally {
        lock.unlock();
    }
} else {
    // 获取失败，降级处理；也可以搞个计数重新trylock，直到次数达到某个上限就退出
}

try {
    lock.lockInterruptibly(); // 被唤醒的话，会抛出InterruptedException，然后进行特殊处理即可
    try {
        // 临界区
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    // 响应中断逻辑（释放资源等）
}

Condition condition = lock.newCondition();

lock.lock();
try {
    while (!条件成立) {
        condition.await(); // 相当于 wait()
    }
    // 继续执行
    condition.signal(); // 相当于 notify()
} finally {
    lock.unlock();
}

Semaphore semaphore = new Semaphore(100); // 允许 100 个并发请求
public void handleRequest() {
    semaphore.acquire();
    try {
        // 处理请求
    } finally {
        semaphore.release();
    }
}

// 限制同时处理的任务数为 5
Semaphore taskSemaphore = new Semaphore(5);
for (int i = 0; i < 100; i++) {
    new Thread(() -> {
        taskSemaphore.acquire();
        try {
            processTask();
        } finally {
            taskSemaphore.release();
        }
    }).start();
}

Semaphore emptySlots = new Semaphore(10); // 缓冲区容量 10
Semaphore filledSlots = new Semaphore(0);
 
// 生产者
void produce() throws InterruptedException {
    emptySlots.acquire();
    addToBuffer();
    filledSlots.release();
}
 
// 消费者
void consume() throws InterruptedException {
    filledSlots.acquire();
    removeFromBuffer();
    emptySlots.release();
}

CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        // 子线程执行任务
        latch.countDown();
    }).start();
}
latch.await(); // 主线程等待所有子线程完成
System.out.println("所有子线程已完成，主线程继续执行");

ountDownLatch serviceLatch = new CountDownLatch(3);
// 启动数据库服务
new Thread(() -> {
    startDatabase();
    serviceLatch.countDown();
}).start();
// 启动缓存服务
new Thread(() -> {
    startCache();
    serviceLatch.countDown();
}).start();
serviceLatch.await(); // 等待所有服务启动
startMainService();

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread-A 持有 lock1");
                try {
                    Thread.sleep(100); // 模拟操作耗时，增加死锁概率
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread-A 等待获取 lock2...");
                synchronized (lock2) {
                    System.out.println("Thread-A 成功获取 lock2");
                }
            }
        });

        Thread threadB = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread-B 持有 lock2");
                try {
                    Thread.sleep(100); // 模拟操作耗时，增加死锁概率
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread-B 等待获取 lock1...");
                synchronized (lock1) {
                    System.out.println("Thread-B 成功获取 lock1");
                }
            }
        });

        threadA.start();
        threadB.start();
    }
}

// 程序会输出以下内容后卡住（死锁）：
Thread-A 持有 lock1
Thread-B 持有 lock2
Thread-A 等待获取 lock2...
Thread-B 等待获取 lock1...

Lock lock = new ReentrantLock();
if (lock.tryLock()) {
   try {
       // 临界区
   } finally {
       lock.unlock(); // 主动释放
   }
}

// 定义锁的顺序
private static final Object[] locks = {lockA, lockB, lockC};
 
public void doWork() {
   Arrays.sort(locks); // 按对象哈希值排序
   synchronized (locks[0]) {
       synchronized (locks[1]) {
           synchronized (locks[2]) {
               // 临界区
           }
       }
   }
}

if (lock1.tryLock(1, TimeUnit.SECONDS)) {
   try {
       if (lock2.tryLock(1, TimeUnit.SECONDS)) {
           try {
               // 执行任务
           } finally {
               lock2.unlock();
           }
       }
   } finally {
       lock1.unlock();
   }
}