在多线程环境中，请阐述Java的synchronized关键字以及Lock接口的使用场景，并举个例子。

原创 ╰+哭是因爲堅強的太久メ 2025-03-10 01:00 13阅读 0赞

`synchronized`关键字和Lock接口是Java中用于管理线程同步的关键工具。

1. `synchronized`关键字：
- 简单锁：作用于一个对象，使同一时刻只有一个线程访问该对象。
```java
public class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
    }

public synchronized int getCount() {
        return count;
    }
}
```
- 非公平锁（默认）：线程的等待、获取顺序不定，可能导致饥饿或活锁。
2. `Lock`接口：
- 提供了更细粒度的控制，包括加锁、解锁、尝试加锁等操作。
- 使用`ReentrantLock`作为实现，它提供了`lock()`、`unlock()`和`tryLock()`方法。

示例：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SynchronizedAndLockExample {
    private Lock lock = new ReentrantLock();

public void thread1() {
        try {
            // 获取锁
            lock.lock();
            System.out.println("Thread 1 is executing a critical section.");
            // 释放锁
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void thread2() {
        try {
            // 尝试获取锁，如果当前线程未持有锁，则会立即返回false
            if (!lock.tryLock())) {
                System.out.println("Thread 2 couldn't acquire the lock.");
                return;
            }
            System.out.println("Thread 2 is executing a critical section, but it's allowed to do so because it holds the lock.");
            // 释放锁
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void startThreads() {
        new Thread(thread1)).start();
        new Thread(thread2)).start();
    }

public static void main(String[] args) {
        SynchronizedAndLockExample example = new SynchronizedAndLockExample();
        example.startThreads();
    }
}
```
在这个例子中，`thread1`和`thread2`是两个线程。`ReentrantLock`提供了一种机制来同步这些线程的执行。

当一个线程试图获取锁时，如果当前持有锁的线程还没有释放锁，那么尝试获取锁的线程会立即返回false，从而避免了竞争状态。