多线程并发问题：Java中如何避免竞态条件并实现线程同步？

原创待我称王封你为后i 2024-09-19 15:21 86阅读 0赞

在Java中，避免竞态条件和实现线程同步主要通过以下几种方式：

1. 使用synchronized关键字：
   - synchronized修饰方法：同一时刻只有一个线程执行该方法。
   ```java
   class Counter {
       private int count = 0;

public synchronized void increment() {
           count++;
           notifyAll(); // 唤醒等待的线程
       }

public synchronized int decrement() {
           if (count > 0) {
               count--;
               if (count == 0) { // 当count为0时，唤醒其他等待的线程
                   notifyAll();
               }
               return count;
           } else {
               throw new IllegalStateException("Counter is already zero.");
           }
       }

public synchronized int getCount() {
           return count;
       }
   }
   ```
2. 使用Lock接口：
   - `ReentrantLock`是锁的一种实现，提供了更细粒度的控制。
   ```java
   import java.util.concurrent.locks.Lock;
   import java.util.concurrent.locks.ReentrantLock;

class CounterWithLock {
       private Lock lock = new ReentrantLock();

public void increment() {
           lock.lock(); // 获取锁
           try {
               count++;
               notifyAll();
           } finally {
               lock.unlock(); // 释放锁
           }
       }

// ... 其他方法 ...
   }
   ```
3. 使用原子类：
   - Java提供了一些原子操作的类，如`AtomicInteger`、`AtomicLong`等。
   ```java
   class CounterWithAtomic {
       private AtomicInteger count = new AtomicInteger(0);

public void increment() {
           count.incrementAndGet(); // 原子增加计数
           notifyAll();
       }

// ... 其他方法 ...
   }
   ```

通过以上几种方式，可以在Java中有效地避免竞态条件并实现线程同步。