Java多线程实现阻塞和唤醒-蒲公英云

Java多线程实现阻塞和唤醒

在Java中，多线程编程是处理并发任务的一种方式。阻塞和唤醒是多线程编程中常用的概念，它们可以帮助我们控制线程的执行顺序和协调线程间的工作。以下是一些Java中实现阻塞和唤醒的基本方法：

1. 使用`wait()`和`notify()`

wait()和notify()方法是Object类的方法，可以用来实现线程间的协作。当一个线程调用wait()方法时，它会释放对象的锁并进入等待状态，直到其他线程调用相同对象的notify()或notifyAll()方法。

```javapublic class WaitNotifyExample {
public static void main(String[] args) {
Object lock = new Object();
Thread t1 = new Thread(() -> {
synchronized (lock) {
try {
System.out.println(“Thread1 is waiting”);
lock.wait();
System.out.println(“Thread1 is resumed”);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread t2 = new Thread(() -> {
synchronized (lock) {
System.out.println(“Thread2 is notifying”);
lock.notify();
}
});

t1.start();
try {
Thread.sleep(1000); //确保t1先执行} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
``###2. 使用Condition对象Condition是java.util.concurrent.locks包中的一个接口，它提供了比wait()和notify()更灵活的线程通信机制。Condition`允许一个线程在某个条件不满足时释放锁并等待，直到其他线程在相同条件下通知它。

```javaimport java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample {
private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();

public void await() throws InterruptedException {
lock.lock();
try {
System.out.println(“Thread is waiting”);
condition.await();
System.out.println(“Thread is resumed”);
} finally {
lock.unlock();
}
}

public void signal() {
lock.lock();
try {
System.out.println(“Thread is signaling”);
condition.signal();
} finally {
lock.unlock();
}
}

public static void main(String[] args) throws InterruptedException {
ConditionExample example = new ConditionExample();
Thread t1 = new Thread(() -> {
try {
example.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
});

Thread t2 = new Thread(() -> {
example.signal();
});

t1.start();
Thread.sleep(1000); //确保t1先执行t2.start();
}
}
``###3. 使用CountDownLatch`

CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

```javaimport java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);

Thread t1 = new Thread(() -> {
try {
latch.await();
System.out.println(“Thread1 is resumed”);
} catch (InterruptedException e) {
e.printStackTrace();
}
});

Thread t2 = new Thread(() -> {
System.out.println(“Thread2 is counting down”);
latch.countDown();
});

t1.start();
Thread.sleep(1000); //确保t1先执行t2.start();
}
}
```这些是Java中实现阻塞和唤醒的一些基本方法。根据具体的应用场景，你可以选择最适合的方法来实现线程间的协调。