深入理解Java中的同步控制机制：问题与示例解析

原创心已赠人 2024-09-19 03:51 20阅读 0赞

Java中的同步控制主要通过以下几种机制实现：

1. **synchronized关键字**：
   - `synchronized(this)`：对当前类的实例进行锁定，即在同一时间只有一个线程可以执行该对象的方法。
   ```java
   class Counter {
       public synchronized void increment() {
           count++;
       }
       private int count = 0;
   }

Counter counter = new Counter();
   // 多个线程同时调用increment()
   ```

2. **wait/notify**：
   - `synchronized(this)`：锁定后，可以调用`wait()`方法让当前线程进入等待状态。
   ```java
   class Monitor {
       private int count = 0;
       public synchronized void increment() {
           if (count < 10) {
               count++;
               notifyAll(); // 发送通知，唤醒其他等待的线程
           } else {
               System.out.println("Count limit reached.");
           }
       }
   }

Monitor monitor = new Monitor();
   Thread thread1 = new Thread(() -> monitor.increment()));
   Thread thread2 = new Thread(() -> monitor.increment()));

thread1.start(); // 启动第一个线程
   thread2.start(); // 启动第二个线程

// 当thread1完成，调用notify()唤醒monitor
   // thread2在被唤醒后会继续执行increment()方法
```

3. **ReentrantLock**：
   - `java.util.concurrent.locks.ReentrantLock`：提供了更细粒度的锁控制，如公平性、超时时间等。
   ```java
   import java.util.concurrent.locks.ReentrantLock;

class FairnessExample {
       private final ReentrantLock lock = new ReentrantLock(true);

public void fairMethod() throws InterruptedException {
           lock.lock(); // 获取公平锁
           try {
               // 业务代码
               Thread.sleep(2000); // 模拟耗时操作
           } finally {
               lock.unlock(); // 释放公平锁
           }
       }
   }

FairnessExample example = new FairnessExample();
   new Thread(() -> example.fairMethod())).start();

// 这里会等待fairMethod()方法执行完成
```
以上就是Java中同步控制机制的主要理解和示例。