Java中常见并发问题实例

原创电玩女神 2024-09-24 16:33 75阅读 0赞

在Java编程中，常见的并发问题包括线程安全、死锁、活锁、饥饿等问题。下面提供几个实例来说明：

1. 线程安全：
```java
// 示例：共享变量counter的线程安全使用
public class Counter {
    private int count;

public synchronized void increment() {
        count++;
    }

public synchronized int decrementIfPositive() {
        if (count > 0) {
            count--;
            return count;
        }
        return count; // 如果count为0，则直接返回count
    }

public synchronized int getCount() {
        return count;
    }
}
```
2. 死锁：
```java
// 示例：两个线程互相等待对方释放资源，导致死锁
public class DeadLockExample {
    private Object resource1 = new Object();
    private Object resource2 = new Object();

public void startThreads() {
        Thread thread1 = new Thread(() -> acquireResource(resource1)));
        Thread thread2 = new Thread(() -> acquireResource(resource2)));

thread1.start();
        thread2.start();
    }

private synchronized void acquireResource(Object resource) {
        // 确保资源释放后可以再次获得
        System.out.println("Thread " + Thread.currentThread().getName() + " acquired resource: " + resource);
        try {
            // 模拟资源获取需要的时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 确保释放资源，避免死锁
        releaseResource(resource);
    }

private synchronized void releaseResource(Object resource) {
        System.out.println("Thread " + Thread.currentThread().getName() + " released resource: " + resource);
    }

public static void main(String[] args) {
        DeadLockExample example = new DeadLockExample();
        example.startThreads();
    }
}
```
3. 活锁和活锁预防：
```java
// 示例：线程A和B互相等待对方释放资源，导致活锁
public class LivingLockExample {
    private Object resource1 = new Object();
    private Object resource2 = new Object();

public void startThreads() {
        Thread thread1 = new Thread(() -> acquireResource(resource1)));
        Thread thread2 = new Thread(() -> acquireResource(resource2)));

// 线程A和B互相等待对方释放资源
        thread1.start();
        try {
            // 确保线程A释放资源后，线程B可以继续执行
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }

private synchronized void acquireResource(Object resource) {
        System.out.println("Thread " + Thread.currentThread().getName() + " acquired resource: " + resource);
        try {
            // 模拟资源获取需要的时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private synchronized void releaseResource(Object resource) {
        System.out.println("Thread " + Thread.currentThread().getName() + " released resource: " + resource);
    }

public static void main(String[] args) {
        LivingLockExample example = new LivingLockExample();
        example.startThreads();
    }
}
```
以上实例分别展示了Java中常见的并发问题，包括线程安全、死锁、活锁等。在实际开发中，理解并妥善处理这些并发问题是至关重要的。