并发挑战：Java线程同步和竞态条件示例

原创ゝ一纸荒年。 2024-11-29 23:36 28阅读 0赞

在Java编程中，线程同步和竞态条件是常见的并发挑战。以下是一些具体的示例：

1. **共享资源问题**：
   - **互斥锁（Synchronized）**：
     ```java
     public class Counter {
         private int count = 0;
         private Object lock = new Object();

// 同步方法，确保同一时间只有一个线程访问count属性
         synchronized (lock) {
             count++;
             System.out.println("Count increased by " + count);
         }
     }
     ```
   - **条件变量（Condition Variables）**：
     ```java
     public class SleepyThread {
         private final Object lock = new Object();
         private final Condition cond = new Condition(lock);

// 等待条件满足后才继续执行的代码块
         private void waitUntilCountIsGreaterThanZero() {
             try {
                 cond.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

public void incrementCountAndSleep() {
             synchronized (lock) {
                 if (count == 0) {
                     cond.signalAll(); // 如果条件未满足，触发信号量操作
                 }
                 count++;
                 System.out.println("Count increased by " + count);

// 等待条件满足后才继续执行的代码块
                 waitUntilCountIsGreaterThanZero();
             }
         }
     }
     ```
2. **竞态条件**：
   - **多个线程同时访问共享资源**：
     ```java
     public class Counter {
         private int count = 0;
 
         // 不同步方法，可能导致竞态条件
         public void incrementCount() {
             count++;
             System.out.println("Counter incremented by " + count);
         }
     }
     ```
   - **锁的不当使用**：
     ```java
     public class CounterWithBadLocking {
         private int count = 0;
 
         // 锁的不当使用，可能导致线程安全问题
         public void incrementCount() {
             synchronized (CounterWithBadLocking.class)) { // 注意，错误地将类作为锁对象
                 count++;
                 System.out.println("Counter incremented by " + count);
             }
         }
     }
     ```

通过以上示例，可以看出在并发编程中，理解和正确使用线程同步机制（如互斥锁、条件变量等）以及避免竞态条件是至关重要的。