Java并发编程中的锁竞争问题实例

原创朴灿烈づ我的快乐病毒、 2024-10-07 01:57 44阅读 0赞

锁竞争问题在Java并发编程中是一种常见的性能瓶颈情况。当多个线程同时尝试获取一个共享资源的锁时，就可能发生锁竞争。

以下是一个简单的实例：

```java
// 假设我们有一个共享的计数器count
public class Counter {
    private int count = 0;

public synchronized int increment() {
        count++;
        notifyAll(); // 触发所有等待者
        return count;
    }

// 等待锁释放的线程
    public static class Waiter extends Thread {
        private Counter counter;

public Waiter(Counter counter) {
            this.counter = counter;
        }

@Override
        public void run() {
            synchronized (counter) {
                while (!counter.increment())) {
                    try {
                        // 等待锁被释放，计数器加1
                        counter.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Count: " + counter.count);
            }
        }
    }

public static void main(String[] args) {
        Counter counter = new Counter();

// 创建多个等待锁释放的线程
        for (int i = 0; i < 10; i++) {
            Waiter waiter = new Waiter(counter);
            waiter.start();
        }

// 主线程执行计数操作，试图获取锁并增加计数器
        Thread countThread = new Thread(() -> {
            System.out.println("Counter thread started");

try {
                counter.increment(); // 尝试获取锁并增加计数器
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        countThread.start();

try {
            countThread.join(); // 等待主线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Counter thread ended");
    }
}
```

在这个例子中，`Counter`类有一个共享的计数器。多个线程同时尝试获取这个锁来增加计数器。这就导致了锁竞争问题，可能会引发性能下降甚至死锁。