Java并发问题：线程安全和死锁示例

原创谁践踏了优雅 2024-12-10 05:15 2阅读 0赞

在Java中，线程安全主要涉及到同步机制，如synchronized关键字、wait/notify方法等。下面是一些线程安全的示例以及死锁的示例：

1. 线程安全示例（使用synchronized关键字）：
```java
public class Counter {
    private int count = 0;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalStateException("Counter underflow!");
        }
    }

// 获取当前计数
    public synchronized int getCount() {
        return count;
    }
}
```
2. 线程安全示例（使用wait/notify方法）：
```java
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class WaitNotifyExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

public void countDown() {
        lock.lock();
        try {
            if (count > 0) {
                count--;
                condition.signalAll();
            } else {
                throw new IllegalStateException("Counter underflow!");
            }
        } finally {
            lock.unlock();
        }
    }

public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }

// 启动计数器示例
    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();
        example.countDown();
        while (example.getCount() > 0) {
            System.out.println("Count: " + example.getCount());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
3. 死锁示例：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
    private Lock lockA = new ReentrantLock();
    private Lock lockB = new ReentrantLock();

public void methodA() throws InterruptedException {
        lockA.lock();
        try {
            System.out.println("Method A: Locking A");

// 这里模拟锁B的需要，但没有获取到锁
            lockB.lock();
            System.out.println("Method A: Locking B, but not yet acquired!");

// 模拟释放锁B，然后尝试获取锁B
            lockB.unlock();
            System.out.println("Method A: Unlocking B after waiting");

// 由于锁B已经在释放状态，此时再次尝试获取锁B会失败
            lockB.lock();
            throw new IllegalStateException("Failed to acquire lock B despite unlock attempt!");

} finally {
            lockA.unlock();
            System.out.println("Method A: Unlocking A");
        }
    }

public void methodB() throws InterruptedException {
        lockB.lock();
        try {
            System.out.println("Method B: Locking B");

// 在这里模拟调用methodA，会因为锁B未释放而失败
            methodA();
            throw new IllegalStateException("Failed to call method A despite lock B held!");

} finally {
            lockB.unlock();
            System.out.println("Method B: Unlocking B");
        }
    }

public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        example.methodB(); // 这里会抛出异常，因为死锁存在
    }
}
```
以上示例展示了线程安全（如使用synchronized关键字和wait/notify机制）以及死锁的处理。