Java多线程同步工具Lock、Synchronized及ReentrantLock的对比实例

原创 ╰+哭是因爲堅強的太久メ 2024-11-28 20:45 1阅读 0赞

在Java中，多线程同步主要通过Lock接口实现，包括Lock（旧锁）、LockSupport.lock()（原生锁定）和ReentrantLock（重入锁）等。

下面以一个简单的生产者消费者场景来对比这些工具：

1. 使用synchronized关键字：
```java
public class SimpleSync {
    private int count = 0;
    
    public synchronized void producer() {
        count++;
        System.out.println("Producer: Count " + count);
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public synchronized void consumer() {
        System.out.println("Consumer: Will consume " + count);
        if (count > 0) {
            count--;
            producer();
            notifyAll();
        }
    }
}
```
2. 使用Lock接口：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SimpleLock {
    private int count = 0;
    private Lock lock;

public SimpleLock() {
        lock = new ReentrantLock();
    }

public void producer() {
        lock.lock();
        try {
            count++;
            System.out.println("Producer: Count " + count);
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

public void consumer() {
        lock.lock();
        try {
            System.out.println("Consumer: Will consume " + count);
            if (count > 0) {
                count--;
                producer();
                notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
```
对比示例中，synchronized关键字用于实现线程同步，而Lock接口提供了更细粒度的控制。

ReentrantLock是Lock接口的一个具体实现，它支持重入（即同一个线程再次进入相同锁代码块）这一特性。