Java多线程问题实例：死锁与线程优先级

原创浅浅的花香味﹌ 2024-12-13 12:51 15阅读 0赞

在Java中，多线程可能会遇到多种问题，其中两种常见的问题就是死锁和线程优先级。

1. 死锁：
   当两个或更多的线程互相等待对方释放资源时，就会发生死锁。例如：

```java
class Resource {
    boolean locked;

Resource() {
        locked = false;
    }

void lock() {
        if (!locked) {
            locked = true;
        } else {
            System.out.println("Resource is already locked.");
        }
    }

void unlock() {
        if (locked) {
            locked = false;
        } else {
            System.out.println("Resource is not locked to unlock it.");
        }
    }
}

class ThreadA extends Thread {
    Resource resource;

ThreadA(Resource r) {
        resource = r;
    }

@Override
    public void run() {
        resource.lock();
        try {
            // 在这里执行耗时操作
            System.out.println("Thread A is executing a task.");
        } finally {
            resource.unlock();
            System.out.println("Thread A has finished its task and unlocked the resource.");
        }
    }
}

class ThreadB extends Thread {
    Resource resource;

ThreadB(Resource r) {
        resource = r;
    }

@Override
    public void run() {
        resource.lock();
        try {
            // 在这里执行耗时操作
            System.out.println("Thread B is executing a task.");
        } finally {
            resource.unlock();
            System.out.println("Thread B has finished its task and unlocked the resource.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resource = new Resource();

// 创建线程A和线程B
        ThreadA threadA = new ThreadA(resource);
        ThreadB threadB = new ThreadB(resource);

// 启动线程
        threadA.start();
        threadB.start();
    }
}
```

在这个例子中，当`ThreadA`开始执行任务时，它会尝试锁住资源。同时，`ThreadB`也开始尝试锁定资源。

如果`ThreadA`在获取锁之前被中断，那么它会保留对资源的已获得锁状态，而不会释放锁。这时如果`ThreadB`试图获取同一个资源的锁，它将无法成功，从而引发死锁。

要避免这种情况，通常我们会设置线程的优先级，让高优先级的线程在需要时能够抢夺低优先级线程正在使用的资源，从而防止死锁的发生。