Java并发编程中的锁实现：互斥锁与读写锁的区别示例

原创桃扇骨 2024-12-10 15:33 8阅读 0赞

在Java的并发编程中，锁是一种同步机制，用于控制对共享资源的访问。常见的锁类型包括互斥锁（Synchronized Lock）和读写锁（Reentrant Read/Write Lock）。

1. 互斥锁：
互斥锁是典型的独占锁，即一次只有一个线程可以获取并释放锁。例如：

```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 IllegalArgumentException("Can't decrement count below zero");
        }
    }

public synchronized int getCount() {
        return count;
    }
}
```
2. 读写锁：
读写锁允许多个线程同时进行读操作，但只允许一个线程进行写操作。这样可以提高并发效率。

示例代码：

```java
import java.util.concurrent.locks.ReadWriteLock;

public class RWCounter {
    private int count = 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();

public synchronized void increment() {
        lock.readLock().acquire();
        try {
            count++;
        } finally {
            lock.readLock().release();
        }
    }

public synchronized int decrement() {
        lock.writeLock().acquire();
        try {
            if (count > 0) {
                count--;
                return count;
            } else {
                throw new IllegalArgumentException("Can't decrement count below zero");
            }
        } finally {
            lock.writeLock().release();
        }
    }

public synchronized int getCount() {
        lock.readLock().acquire();
        try {
            return count;
        } finally {
            lock.readLock().release();
        }
    }
}
```
总结，互斥锁用于独占访问资源，而读写锁则允许对共享资源的并发读取，但一次只有一个线程可以进行写操作。