并发编程难题：Java线程同步问题

原创古城微笑少年丶 2024-09-20 00:39 161阅读 0赞

Java线程同步是多线程编程中常见的难点。主要涉及以下几种同步机制：

1. **synchronized关键字**：
   - 修饰整个方法或代码块，使得在同一时刻只有一个线程可以执行该部分代码。
   ```java
   // 修饰方法
   synchronized void myMethod() {
       // 方法体
   }

// 修饰代码块
   synchronized {
       // 代码块
   }
   ```

2. **wait/notify**：
   - 主要用于无限循环或者阻塞等待条件满足的场景。
   ```java
   // 对象实现wait和notify机制
   private Object lock = new Object();
   private boolean condition = false;

public void waitCondition() {
       synchronized (lock) {
           while (!condition) {
               lock.notifyAll();  // 发送通知，唤醒等待条件的线程
               try {
                   // 线程休眠
                   Thread.sleep(100);  // 每次休眠100ms
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   // 如果中断，恢复线程状态
                   Thread.currentThread().interrupt();
               }
           }
           condition = true;  // 条件满足，唤醒等待的线程
       }
   }

public void notifyCondition() {
       synchronized (lock) {
           lock.notifyAll();  // 发送通知，唤醒等待条件的线程
       }
   }
   ```

3. **Semaphore**：
   - 用于控制同时访问特定资源的数量。
   ```java
   // 使用Semaphore实现并发控制
   Semaphore semaphore = new Semaphore(1);  // 初始化允许的最大并发数为1

public void task1() throws InterruptedException {
       semaphore.acquire();  // 请求获得锁，如果当前没有锁可用（已获取），则阻塞

// 执行任务1
       // ...

semaphore.release();  // 释放锁，表示当前有锁可供使用
   }

public void task2() throws InterruptedException {
       semaphore.acquire();  // 同理，请求获得锁并等待

// 执行任务2
       // ...

semaphore.release();  // 释放锁，完成任务执行
   }
   ```

理解这些同步机制，并在实际项目中恰当使用，是解决Java线程同步问题的关键。