Java线程同步问题：死锁、资源竞争及实例分析

原创亦凉 2024-12-02 08:24 37阅读 0赞

在Java编程中，线程同步主要涉及到死锁、资源竞争和实例分析。

1. 死锁：
   死锁是指两个或多个并发进程在执行过程中因争夺资源而造成的一种相互等待的现象。其典型的四个必要条件：互斥（资源每次只被一个进程使用）、占有并请求（每个进程已占有某些资源，并正努力去获得其他资源以完成其任务）、循环等待（若干个进程形成一个环，互相等待释放对方占用的资源）。

2. 资源竞争：
   在多线程环境下，多个线程同时访问共享资源或执行相同的代码块。如果这些线程对资源的使用没有合理的控制和同步，就可能导致资源争抢、数据不一致等问题。

3. 实例分析：
   以下是一个简单的Java死锁例子：

```java
// 创建两个共享资源
public class SharedResource {
    private int count;

// 获取资源计数
    public synchronized int getCount() {
        return count;
    }

// 增加资源计数
    public synchronized void incrementCount(int delta) {
        count += delta;
    }
}

// 线程A和B，分别获取和增加资源
public class DeadlockExample {

private SharedResource sharedResource;

public DeadlockExample() {
        this.sharedResource = new SharedResource();
    }

// 线程A：获取资源
    public void threadA() {
        while (true) { // 无限循环
            try {
                if (sharedResource.getCount() == 0) {
                    System.out.println("Thread A: Obtained resource");
                    break; // 取得资源后退出循环
                }
                else {
                    System.out.println("Thread A: Resource already in use");
                    continue; // 资源已使用，继续循环
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                return; // 异常中断线程
            }
        }
    }

// 线程B：增加资源
    public void threadB() {
        while (true) { // 无限循环
            try {
                if (sharedResource.getCount() == 0) {
                    System.out.println("Thread B: Added resource to shared pool");
                    break; // 添加资源后退出循环
                }
                else {
                    System.out.println("Thread B: Resource already in use");
                    continue; // 资源已使用，继续循环
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                return; // 异常中断线程
            }
        }
    }

public static void main(String[] args) {
        DeadlockExample deadlockExample = new DeadlockExample();
        Thread threadA = new Thread(deadlockExample::threadA));
        Thread threadB = new Thread(deadlockExample::threadB));

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

// 等待所有线程执行完毕
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
在这个例子中，线程A获取资源并无限循环，而线程B增加资源到共享池并无限循环。两个线程相互等待对方释放资源，从而形成死锁。