Java多线程中的死锁问题：实例展示与解决

原创刺骨的言语ヽ痛彻心扉 2024-09-12 16:15 135阅读 0赞

死锁是多线程编程中的一种严重问题，当两个或更多的线程互相等待对方释放资源时，就会出现死锁。

下面是一个简单的死锁例子：

```java
// 线程A，持有资源1
class ThreadA extends Thread {
    private Resource resource1;

public ThreadA(Resource resource1) {
        this.resource1 = resource1;
    }

@Override
    public void run() {
        System.out.println("Thread A acquire resource 1");
        resource1.lock();
        // 线程B，持有资源2
        class ThreadB extends Thread {
            private Resource resource2;

public ThreadB(Resource resource2) {
                this.resource2 = resource2;
            }

@Override
            public void run() {
                System.out.println("Thread B acquire resource 2");
                resource2.lock();
                // 线程A等待资源2，线程B等待资源1
                if (resource1.isHeldBy(ThreadA.class)) &&
                        resource2.isHeldBy(ThreadB.class)) {

System.out.println("Thread A acquire resource 2 from Thread B");
                    resource2.unlock();

System.out.println("Thread A release resource 1");
                    resource1.unlock();

System.out.println("Thread A acquire resource 1 from itself");
                    resource1.lock();
                }
            }

ThreadB b = new ThreadB(resource2);
            b.start();
        }

public Resource getResource() {
            return resource1;
        }

@Override
        public void unlockResource() {
            resource1.unlock();
        }
    }

public class Resource {
        private Lock lock;

public Resource() {
            lock = new Lock();
        }

public synchronized void lock() {
            if (lock.isHeld()) {
                throw new RuntimeException("Resource is already locked by another thread.");
            }
            lock.lock();
        }

public synchronized void unlock() {
            if (!lock.isHeld()) {
                throw new RuntimeException("Resource is not locked by this thread.");
            }
            lock.unlock();
        }

private class Lock {
            private boolean isHeld;

public Lock() {
                isHeld = false;
            }

public synchronized boolean isHeld() {
                return isHeld;
            }

public synchronized void lock() {
                if (isHeld) {
                    throw new RuntimeException("Resource is already locked by another thread.");
                }
                isHeld = true;
            }

public synchronized void unlock() {
                if (!isHeld) {
                    throw new RuntimeException("Resource is not locked by this thread.");
                }
                isHeld = false;
            }
        }
    }

public class Main {
        public static void main(String[] args) {
            ThreadA a = new ThreadA(new Resource()));
            a.start();

try {
                // 这里等待ThreadB释放资源2
                a.getResource().unlock();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
```

在这个例子中，线程A持有资源1，线程B持有资源2。当线程B先获取资源2并锁定后，线程A试图获取资源2但被阻塞。

为了解决这个问题，我们可以在释放资源之前添加一个检查，确保当前线程确实拥有该资源。这样可以避免死锁的发生：

```java
public class Main {
    public static void main(String[] args) {
        ThreadA a = new ThreadA(new Resource()));
        a.start();

try {
            // 这里等待ThreadB释放资源2
            while (!a.getResource().isHeldBy(ThreadA.class))) {
                Thread.sleep(10); // 阻塞一定时间，模拟线程等待
            }
            
            // 释放资源后检查当前线程是否拥有该资源
            a.getResource().unlock();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

通过这种方式，我们可以在避免死锁的同时保证程序的正确执行。