Java并发编程：线程同步与互斥问题实例

原创男娘i 2024-12-07 01:51 15阅读 0赞

在Java并发编程中，线程同步与互斥问题是核心概念。以下是一些实例和理解：

1. **synchronized关键字**：
   - 互斥：一个线程进入synchronized代码块后，其他线程必须等待该线程执行完毕后才能进入。
   ```java
   // 示例1：两个线程交替打印
   class Counter {
       private int count = 0;
       
       synchronized void increment() {
           count++;
           notifyAll();  // 唤醒所有等待的线程
       }
       
       public synchronized int getCount() {
           return count;
       }
   }

new Thread(() -> {
       Counter counter = new Counter();
       while (true) {  // 无限循环，模拟持续操作
           try {
               if (counter.getCount() % 2 == 0) {
                   System.out.println("Even iteration: " + counter.getCount());
                   counter.increment();  // 增加计数
               } else {
                   System.out.println("Odd iteration: " + counter.getCount()));
               }
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
               break;
           }
       }
   })).start();

new Thread(() -> {
       Counter counter = new Counter();
       while (true) {  // 无限循环，模拟持续操作
           try {
               System.out.println("Waiting for even iteration: " + counter.getCount());
               if (counter.getCount() % 2 == 0) {
                   System.out.println("Found even iteration: " + counter.getCount());
                   counter.increment();  // 增加计数
                   break;
               }
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
               break;
           }
       }
   })).start();

**解释**：这里有两个线程，分别模拟两个操作。第一个操作（线程2）等待找到偶数迭代。第二个操作（线程1）每次循环检查是否为偶数，如果是则增加计数并退出循环。

2. **synchronized方法和块**：
   - 互斥：在多线程环境下，同一个synchronized方法或块只能被一个线程访问。
   ```java
   // 示例2：两个线程同时修改共享对象
   class SharedObject {
       private int count = 0;
       
       synchronized void increment() {
           count++;
           notifyAll();  // 唤醒所有等待的线程
       }
       
       public synchronized int getCount() {
           return count;
       }
   }

new Thread(() -> {
       SharedObject sharedObj = new SharedObject();
       while (true) {  // 无限循环，模拟持续操作
           try {
               if (sharedObj.getCount() % 2 == 0) {
                   System.out.println("Even iteration: " + sharedObj.getCount());
                   sharedObj.increment();  // 增加计数
               } else {
                   System.out.println("Odd iteration: " + sharedObj.getCount()));
               }
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
               break;
           }
       }
   })).start();

new Thread(() -> {
       SharedObject sharedObj = new SharedObject();
       while (true) {  // 无限循环，模拟持续操作
           try {
               System.out.println("Working on object: " + sharedObj.getCount());
               if (sharedObj.getCount() % 2 == 0) {
                   sharedObj.increment();  // 增加计数
                   break;
               }
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
               break;
           }
       }
   })).start();

**解释**：这里有两个线程，分别模拟两个操作。第一个操作（线程1）每次循环检查共享对象的计数是否为偶数，如果是则增加计数并退出循环。第二个操作（线程2）等待找到一个满足条件（即计数是偶数）的对象，然后进行工作。

通过这两个例子，我们可以理解synchronized关键字如何实现多线程环境下的互斥。