Java并发编程：锁、条件判断等常见问题

原创以你之姓@ 2024-10-22 12:27 48阅读 0赞

在Java并发编程中，锁（Synchronized）、条件判断（Conditional Variables）是两个重要的工具，用于解决并发环境下的同步和等待问题。

1. 锁（Synchronized）

- `synchronized`关键字：用于修饰类的某个方法，使得这个方法在同一时刻只有一个线程执行。

示例：
```java
class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        }
        throw new IllegalArgumentException("Cannot decrement to negative value");
    }

public synchronized int getCount() {
        return count;
    }
}
```

2. 条件判断（Conditional Variables）

- `java.util.concurrent.Condition`：Java并发库中的一个接口，用于创建和管理线程在等待某个事件发生时的挂起状态。

示例：
```java
import java.util.concurrent.Condition;
import java.util.concurrent.CountDownLatch;

class Signal {
    private Condition signal = new Condition();

public void signal() {
        signal.signal();
    }

public boolean await() throws InterruptedException {
        return signal.await();
    }
}

public class ConditionalExample {
    public static void main(String[] args) {
        Signal signal = new Signal();

// 创建一个计数器
        CountDownLatch countDownLatch = new CountDownLatch(1);

// 两个线程，一个等待信号，另一个发送信号
        Thread thread1 = new Thread(() -> {
            try {
                signal.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            countDownLatch.countDown();
            signal.signal(); // 发送信号
        }));

thread1.start();
        thread2.start();

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Condition example finished");
    }
}
```

以上就是Java并发编程中锁和条件判断的基本使用。理解并熟练运用这些工具，可以帮助你编写更高效、更可靠的并发程序。