线程同步：Java多线程并发问题案例展示

原创港控/mmm° 2024-09-13 12:39 105阅读 0赞

线程同步在Java多线程编程中是非常重要的，它能解决由于多个线程同时访问共享资源导致的问题。以下是一些具体的案例：

1. **锁（Synchronized）案例**：
   ```java
   // 共享资源
   class SharedResource {
       int count = 0;
       synchronized count++ { // 同步访问count
           System.out.println("Thread " + Thread.currentThread().getId() + " increment count to " + count);
         }
       }
   }

public class TestSync {
       public static void main(String[] args) {
           new Thread(() -> syncTest(0))).start();
           new Thread(() -> syncTest(1))).start();
       }

private static void syncTest(int threadIndex) {
           // 获取共享资源
           SharedResource sharedResource = new SharedResource();
           try {
               // 线程访问共享资源，这里模拟操作count
               if (threadIndex == 0) { // 第一个线程操作count
                   sharedResource.count++;
                   System.out.println("Thread " + threadIndex + " set count to " + sharedResource.count));
                 } else { // 第二个线程操作count
                   sharedResource.count--;
                   System.out.println("Thread " + threadIndex + " decrement count to " + sharedResource.count)));
                 }
               // 线程睡眠，模拟耗时操作
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           } finally {
               // 在线程退出前清理资源
               sharedResource = null;
           }
       }
   }
   ```
   运行这段代码，你会看到两个线程交替打印出操作count的逻辑。

2. **条件变量（Condition Variables）案例**：
   当多线程需要等待某个条件满足时，可以使用Java提供的`Condition`和`Reactor`类。例如：
   ```java
   import java.util.concurrent.locks.Condition;
   import java.util.concurrent.locks.ReentrantLock;

class WaitingTask {
       private final ReentrantLock lock = new ReentrantLock();
       private final Condition ready = lock.newCondition();

public void waitForReady() throws InterruptedException {
           // 请求资源
           lock.acquire();
           try {
               // 确认资源可用后设置条件为true
               ready.signal();
               // 在等待期间可以执行其他操作
               Thread.sleep(1000);
           } finally {
               // 无论是否成功获取资源，都要释放锁并清空信号
               lock.unlock();
               ready.clear();
           }
       }
   }

public class TestWaitingTask {
       public static void main(String[] args) {
           new WaitingTask().waitForReady(); // 请求等待任务
       }
   }
   ```
   运行这段代码，你会看到`WaitingTask`会等待其`ready`条件变为真（即资源可用），然后才会执行`Thread.sleep(1000);`。

这些例子展示了Java多线程编程中常见的同步问题以及对应的解决方案。