探讨Java多线程并发问题实例

原创小灰灰 2024-09-11 23:06 21阅读 0赞

Java多线程并发问题主要体现在资源竞争、死锁、活锁、同步屏障等。

实例1：资源竞争
```java
public class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
        notifyAll(); // 等待的线程被唤醒
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            notifyAll(); // 等待的线程被唤醒
            return count;
        } else {
            throw new RuntimeException("Counter underflow");
        }
    }
}
```
在这个例子中，多个线程同时调用`increment()`和`decrement()`方法。由于synchronized关键字的作用，同一时间只有一个线程可以执行这些操作。

实例2：死锁
```java
public class DeadLockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

public void deadlock() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) { // 线程1等待锁1
                while (!lock2.hasLock())) { // 此时线程2拥有锁2
                    try {
                        lock2.wait(); // 线程2释放锁2，线程1获得锁1
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }));

Thread thread2 = new Thread(() -> {
            synchronized (lock2) { // 线程2等待锁2
                while (!lock1.hasLock())) { // 此时线程1拥有锁1
                    try {
                        lock1.wait(); // 线程1释放锁1，线程2获得锁2
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }));

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

thread1.join();
        thread2.join();
    }
}
```
在这个例子中，两个线程（thread1和thread2）同时请求锁1和锁2。由于Java的并发机制，如果没有特别的同步措施，可能会导致死锁。

实例3：活锁
活锁是指线程在等待某个资源时，却因为其他原因无法获取到这个资源而陷入无限循环的现象。

要避免活锁，通常需要使用超时、信号量等机制来防止线程无休止地等待。