Java多线程同步问题：互斥锁示例

原创偏执的太偏执、 2024-11-23 00:30 9阅读 0赞

在Java中，互斥锁是一种用于实现线程互斥的机制。当一个线程获得了互斥锁后，其他尝试获取该锁的线程将被阻塞，直到原线程释放锁。

以下是一个使用互斥锁的简单示例：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private Lock lock = new ReentrantLock();

public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

private int count = 0; // Shared variable
}

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

Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
                System.out.println(counter.getCount()); // Prints the incremented count
            }
        }));

Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment(); // Without lock, this can lead to race condition
                System.out.println(counter.getCount()); // Results might not be expected
            }
        }));

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

// Wait for threads to finish
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个示例中，我们使用了ReentrantLock，这是一种可重入的锁，可以防止多个线程同时访问临界区。如果没有互斥锁（如在`counter.increment();`行），那么就可能出现数据不一致或竞争问题。