Java多线程同步问题：锁与条件判断

原创以你之姓@ 2024-10-07 11:12 57阅读 0赞

在Java中，多线程的同步主要依赖于两种机制：锁（synchronized）和条件判断（Conditional Statements）。

1. 锁（synchronized）
   - synchronized关键字用于修饰类、方法或代码块，使得在同一时刻只有一个线程能够进入被锁定的代码区域。
   - 示例：
       ```java
       class Counter {
           private int count = 0;
       
           public synchronized void increment() {
               count++;
               notifyAll(); // 唤醒等待锁的所有线程
           }
       
           public synchronized void decrement() {
               if (count > 0) {
                   count--;
                   if (count == 0) { // 如果计数为0，触发条件判断
                       // 这里可以执行一些业务逻辑
                       notifyAll(); // 唤醒等待锁的所有线程
                   }
               }
           }
       
       public static void main(String[] args) {
           Counter counter = new Counter();
       
           new Thread(() -> { // 创建一个新的线程，用于操作counter的increment方法
               for (int i = 0; i < 5; i++) {
                   try {
                       counter.increment(); // 向counter对象增加计数
                       if (i == 2) { // 当循环到第3步时，执行条件判断
                           System.out.println("Condition met, decrementing by 2..."); // 输出条件满足的消息
                           counter.decrement(); // 取消当前计数，并重新开始
                           break; // 跳出本次循环，直接进入下一次循环
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                           Thread.currentThread().interrupt();
                       }
                   } catch (Exception ex) {
                       ex.printStackTrace();
                   }
               }
           }, "IncrementerThread").start(); // 启动名为"IncrementerThread"的线程，用于执行increment方法

new Thread(() -> { // 创建另一个新的线程，用于操作counter的decrement方法
               for (int i = 0; i < 3; i++) {
                   try {
                       counter.decrement(); // 从counter对象中减去计数
                       if (i == 1) { // 当循环到第2步时，执行条件判断
                           System.out.println("Condition met, incrementing by 1..."); // 输出条件满足的消息
                           counter.increment(); // 向counter对象增加计数
                           break; // 跳出本次循环，直接进入下一次循环
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                           Thread.currentThread().interrupt();
                       }
                   } catch (Exception ex) {
                       ex.printStackTrace();
                   }
               }
           }, "DeincrementerThread").start(); // 启动名为"DeincrementerThread"的线程，用于执行decrement方法
       })
     }
   }
```

在这个例子中，Counter类有两个方法：increment和decrement。它们都通过synchronized关键字进行了同步，确保同一时刻只有一个线程能够访问这些方法。

在decrement方法后，添加了一个条件判断，当循环到第3步时，执行条件判断。如果条件满足（例如，计数减为0），则会改变当前计数，并重新开始循环。