死锁(实现)

public class DeadLock {

    static StringBuffer sb1 = new StringBuffer();
    static StringBuffer sb2 = new StringBuffer();


    public static void main(String[] args) {
        new Thread(()->{
            synchronized(sb1){
                sb1.append("A");
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(sb2){
                    sb2.append("B");
                    System.out.println(sb1.toString());
                    System.out.println(sb2.toString());
                }
            }
        }).start();

        new Thread(()->{
            synchronized(sb2){
                sb1.append("C");
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(sb1){
                    sb2.append("D");
                    System.out.println(sb1.toString());
                    System.out.println(sb2.toString());
                }
            }
        }).start();
    }
}

 

转载于:https://www.cnblogs.com/kaibing/p/9233382.html

### Java 中死锁实现方式及原理 #### 死锁的概念 死锁是指两个或多个线程互相持有对方所需的资源,从而导致这些线程都处于无限期等待的状态。这种情况通常发生在多线程环境中,当线程试图获取已被其他线程占用的资源时发生[^2]。 #### 死锁产生的必要条件 要形成死锁,必须满足以下四个条件: 1. **互斥**:资源只能由一个线程独占使用。 2. **占有并等待**:某个线程已持有一个资源的同时又申请新的资源。 3. **非抢占**:已分配的资源不能强制剥夺,只有拥有者主动释放。 4. **循环等待**:存在一组线程{A, B},其中 A 等待 B 的资源,而 B 同时也等待 A 的资源[^3]。 #### 示例代码展示死锁现象 下面是一个典型的死锁场景示例: ```java public class DeadlockExample { private static final Object lock1 = new Object(); private static final Object lock2 = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(() -> { synchronized (lock1) { // 获取第一个锁 System.out.println("Thread 1: Holding lock 1..."); try { Thread.sleep(100); // 让另一个线程有机会运行 } catch (InterruptedException e) {} System.out.println("Thread 1: Waiting for lock 2..."); synchronized (lock2) { // 尝试获取第二个锁 System.out.println("Thread 1: Holding lock 1 & 2"); } } }); Thread thread2 = new Thread(() -> { synchronized (lock2) { // 获取第二个锁 System.out.println("Thread 2: Holding lock 2..."); try { Thread.sleep(100); } catch (InterruptedException e) {} System.out.println("Thread 2: Waiting for lock 1..."); synchronized (lock1) { // 尝试获取第一个锁 System.out.println("Thread 2: Holding lock 1 & 2"); } } }); thread1.start(); // 启动线程 1 thread2.start(); // 启动线程 2 } } ``` 在这个例子中,`thread1` 和 `thread2` 都尝试按相反顺序锁定相同的两把锁 (`lock1` 和 `lock2`)。这会导致它们陷入相互等待的状态,最终造成死锁[^5]。 --- #### 解决方案 ##### 方法一:避免嵌套锁 通过确保所有线程按照一致的顺序获取锁来消除潜在的死锁风险。例如,在上述代码中可以修改为始终先获取 `lock1` 再获取 `lock2`。 ```java synchronized(lock1){ synchronized(lock2){ // 执行操作... } } ``` 这种方法能够打破“占有并等待”的条件。 ##### 方法二:设置超时机制 利用 `Lock` 接口提供的带时间限制的方法(如 `tryLock()`),可以在一定时间内未能成功获得锁时放弃当前请求。 ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TimeoutDeadlockSolution { private static final Lock lock1 = new ReentrantLock(); private static final Lock lock2 = new ReentrantLock(); public static void main(String[] args) { Thread t1 = new Thread(() -> { boolean lockedFirst = false; boolean lockedSecond = false; try { lockedFirst = lock1.tryLock(100, TimeUnit.MILLISECONDS); if (!lockedFirst) return; // 如果未得到锁则退出 lockedSecond = lock2.tryLock(100, TimeUnit.MILLISECONDS); if (!lockedSecond) { lock1.unlock(); // 若第二把锁失败,则解锁第一把 return; } // 成功加锁后的逻辑处理... } catch (Exception ex) {} finally { if (lockedFirst && lockedSecond) { lock1.unlock(); lock2.unlock(); } } }); t1.start(); } } ``` 此方法可防止因长时间阻塞而导致的死锁情况[^4]。 ##### 方法三:引入死锁检测与恢复机制 借助外部工具(如 `jstack` 或 `VisualVM`)监控线程状态,及时发现问题所在,并采取措施解除僵局。例如定期检查是否有线程长期停滞不前,一旦发现异常即刻中断部分线程以恢复正常运作流程。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值