并发控制难题：多线程场景下的锁竞争实例

原创梦里梦外; 2024-12-01 20:21 12阅读 0赞

在多线程编程中，锁竞争（Lock Contention）是一个常见的并发控制难题。以下是一个简单的实例来说明这个问题：

```java
// 线程1
public class Thread1 extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        synchronized (lock) {
            // 执行一些操作，可能会需要加锁
            for (int i = 0; i < 10_000; i++) {
                // 假设这里有一个耗时的操作
                Thread.yield(); // 模拟耗时操作
            }

// 在任务完成后解锁
            lock.notifyAll();
        }
    }
}

// 线程2
public class Thread2 extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        synchronized (lock) {
            // 直接尝试获取锁，可能会遇到竞争
            lock.lock();
            try {
                // 这里假设这是一个需要加锁的操作
                for (int i = 0; i < 1_000; i++) {
                    Thread.yield(); // 模拟耗时操作
                }

// 在任务完成后解锁
                lock.unlock();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 不论是否发生异常，最后都应该释放锁
                lock.notifyAll();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

thread1.start(); // 启动线程1
        thread2.start(); // 同理启动线程2

// 等待所有线程完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，`Thread1` 和 `Thread2` 同时尝试获取一个共享的锁。如果一个线程成功获得了锁，那么其他线程将无法获得相同的锁，从而产生锁竞争问题。

解决这种问题的方法包括使用互斥锁（Mutex）、条件变量（Condition Variable）等机制进行同步控制。