如何让 Java 方法阻塞118

在 Java 中，阻塞方法是指在执行完成后等待特定条件满足的方法。这通常用于协调并发线程或等待外部资源可用。Java 提供了多种方法来实现阻塞，包括：

1. join() 方法

join() 方法用于等待线程完成执行。调用线程将阻塞，直到目标线程完成执行或达到给定的超时。语法如下：```java
public final void join() throws InterruptedException
```

例如：```java
Thread thread = new Thread(() -> {
// 执行一些任务
});
();
(); // 等待线程完成
```

2. wait() 和 notify() 方法

wait() 和 notify() 方法用于线程之间的协调。wait() 方法使调用线程进入等待状态，直到另一个线程调用其关联的 notify() 或 notifyAll() 方法。语法如下：```java
public final void wait() throws InterruptedException
public final void notify()
public final void notifyAll()
```

例如：```java
Object lock = new Object();
Thread thread1 = new Thread(() -> {
synchronized (lock) {
(); // 等待其他线程调用 notify()
// 继续执行
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock) {
(); // 通知等待的线程继续执行
}
});
();
();
```

3. synchronized 块

synchronized 块可用于将代码块限定为一次只允许一个线程执行。当一个线程进入 synchronized 块时，其他线程将被阻止进入，直到该线程释放锁。语法如下：```java
synchronized (lock) {
// 受保护的代码块
}
```

例如：```java
Object lock = new Object();
Thread thread1 = new Thread(() -> {
synchronized (lock) {
// 执行受保护的任务
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock) {
// 执行受保护的任务
}
});
();
();
```

4. ReentrantLock

ReentrantLock 是一个可重入锁，这意味着它允许同一个线程多次获取锁。它比 synchronized 块提供了更多的控制，并且可以用于实现复杂的并发场景。语法如下：```java
ReentrantLock lock = new ReentrantLock();
```

例如：```java
ReentrantLock lock = new ReentrantLock();
Thread thread1 = new Thread(() -> {
();
try {
// 执行受保护的任务
} finally {
();
}
});
Thread thread2 = new Thread(() -> {
();
try {
// 执行受保护的任务
} finally {
();
}
});
();
();
```

5. Semaphore

Semaphore 用于限制对资源的并发访问。它具有指定数量的许可，线程必须获取许可才能访问受保护的代码块。语法如下：```java
Semaphore semaphore = new Semaphore(permits);
```

例如：```java
Semaphore semaphore = new Semaphore(1);
Thread thread1 = new Thread(() -> {
();
try {
// 执行受保护的任务
} finally {
();
}
});
Thread thread2 = new Thread(() -> {
();
try {
// 执行受保护的任务
} finally {
();
}
});
();
();
```