ReentrantLock lock = new ReentrantLock();

Thread thread = new Thread(() -> {
    try {
        lock.lockInterruptibly(); // 可中斷獲取鎖
        try {
            System.out.println("線程獲取鎖并執(zhí)行任務(wù)");
            Thread.sleep(5000); // 模擬耗時(shí)操作
        } finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        System.out.println("線程被中斷，放棄獲取鎖");
    }
});

lock.lock(); // 主線程先獲取鎖
try {
    thread.start();
    Thread.sleep(1000); // 確保子線程開始等待鎖
    thread.interrupt(); // 中斷子線程
} finally {
    lock.unlock();
}

ReentrantLock lockA = new ReentrantLock();
ReentrantLock lockB = new ReentrantLock();

Thread thread1 = new Thread(() -> {
    try {
        if (lockA.tryLock(1, TimeUnit.SECONDS)) { // 嘗試獲取lockA
            try {
                if (lockB.tryLock(1, TimeUnit.SECONDS)) { // 嘗試獲取lockB
                    System.out.println("Thread1完成任務(wù)");
                }
            } finally {
                if (lockB.isHeldByCurrentThread()) lockB.unlock();
            }
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (lockA.isHeldByCurrentThread()) lockA.unlock();
    }
});

Thread thread2 = new Thread(() -> { /* 類似邏輯，先嘗試lockB再lockA */ });
thread1.start();
thread2.start();

ReentrantLock lock = new ReentrantLock();
Condition notEmpty = lock.newCondition(); // 非空條件
Condition notFull = lock.newCondition();  // 非滿條件
Queue<Integer> queue = new LinkedList<>();
int maxSize = 10;

// 生產(chǎn)者
new Thread(() -> {
    lock.lock();
    try {
        while (queue.size() == maxSize) {
            notFull.await(); // 等待隊(duì)列非滿
        }
        queue.add(1);
        notEmpty.signal(); // 通知消費(fèi)者
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}).start();

// 消費(fèi)者
new Thread(() -> {
    lock.lock();
    try {
        while (queue.isEmpty()) {
            notEmpty.await(); // 等待隊(duì)列非空
        }
        queue.poll();
        notFull.signal(); // 通知生產(chǎn)者
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}).start();