并发编程问题：Java多线程同步控制问题实例展示

原创末蓝、 2024-09-22 04:51 99阅读 0赞

在Java中，多线程的同步控制主要通过以下几种方式实现：

1. **synchronized关键字**：
   - 对方法或代码块进行锁定。
   - 示例：
     ```java
       // 对类锁住
       class Example {
           public synchronized void method() {
               // 这里是线程安全的代码
               // 同一个时刻只有一个线程能访问method方法
             }
         }
       Example example = new Example();
       example.method(); // 调用前需要获取到同步锁
     ```

2. **wait/notify**：
   - 睡眠和唤醒机制，适合用于线程间的通信。
   - 示例：
     ```java
       // 对类的锁住
       class Counter {
           private int count = 0;
           private Lock lock = new ReentrantLock();

public synchronized void increment() {
               count++;
               // 需要通知到等待的线程
               lock.notify();
           }

public synchronized int decrement() {
               if (count > 0) {
                   count--;
                   // 如果是减1，需要进行确认操作（防止负数）
                   if (count < 0) {
                       count = 0; // 调整回0，防止死循环
                       lock.wait(); // 等待通知后重新进入同步方法
                       return 0; // 返回值，表示成功调用减1方法
                   }
                   return count; // 返回当前计数值，表示成功调用增1方法
               } else {
                   throw new IllegalArgumentException("Count cannot be negative!"); // 当count为负数时抛出异常
               }
           }
       }

Counter counter = new Counter();
       Thread thread1 = new Thread(() -> {
           try {
               counter.increment(); // 增加计数值
               System.out.println("Thread 1 incremented to " + counter.getCount()); // 打印当前计数值
               counter.decrement(); // 减少计数值
               System.out.println("Thread 1 decremented to " + counter.getCount()); // 打印当前计数值
           } catch (IllegalArgumentException e) {
               System.out.println("Error: " + e.getMessage()); // 输出错误信息
           }
           // 等待通知后重新进入同步方法
           lock.wait();
           System.out.println("Thread 1 woke up after decrement operation"); // 打印醒来后的信息
           } catch (InterruptedException e) {
               System.out.println("Error: " + e.getMessage()); // 输出错误信息
               Thread.currentThread().interrupt(); // 强制中断当前线程
           }
       }));

Thread thread2 = new Thread(() -> {
           try {
               counter.decrement(); // 减少计数值，注意这里和thread1中减操作的顺序相反
               System.out.println("Thread 2 decremented to " + counter.getCount()); // 打印当前计数值
           } catch (IllegalArgumentException e) {
               System.out.println("Error: " + e.getMessage()); // 输出错误信息
           }
           // 等待通知后重新进入同步方法
           lock.wait();
           System.out.println("Thread 2 woke up after decrement operation"); // 打印醒来后的信息
           } catch (InterruptedException e) {
               System.out.println("Error: " + e.getMessage()); // 输出错误信息
               Thread.currentThread().interrupt(); // 强制中断当前线程
           }
       }));

// 启动计数线程
       counter.increment();
       thread1.start();

// 等待所有计数操作完成和线程唤醒后打印结果
       try {
           lock.await(); // 等待锁被通知，表示线程已经调用了wait()方法
           System.out.println("All counting operations completed and all threads woke up"); // 打印最终结果
         } catch (InterruptedException e) {
             System.out.println("Error: " + e.getMessage()); // 输出错误信息
             Thread.currentThread().interrupt(); // 强制中断当前线程
         }
       finally {
           // 关闭计数器
           counter.close();
       }
   }
```

这个例子展示了Java多线程同步控制，通过synchronized关键字对方法进行锁住，保证同一时刻只有一个线程能访问该方法。这里还涉及到wait/notify机制，用于线程间的通信和同步。