java 如何实现等待

在Java中实现等待的方法有多种，包括使用Thread.sleep()、Object.wait()、以及高级并发工具如CountDownLatch和CyclicBarrier。这些方法各有优缺点，适用于不同的场景。今天，我们将深入探讨这几种实现等待的方法，并介绍它们的使用场景和最佳实践。

一、THREAD.SLEEP() 方法

1.1 基本用法

Thread.sleep()是最简单的等待方式。它使当前线程休眠指定的毫秒数。

try {
    Thread.sleep(1000); // 休眠1秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

1.2 使用场景和注意事项

这个方法适用于简单的延时操作，但有几个注意事项：

不可控的中断：Thread.sleep()会抛出InterruptedException，需要处理这个异常。
不精确的等待：Thread.sleep()的精确度取决于操作系统的调度器，因此并不总是精确的。

二、OBJECT.WAIT() 方法

2.1 基本用法

Object.wait()是实现线程间通信的常用方法，通常与notify()和notifyAll()配合使用。

synchronized (lock) {
    while (!condition) {
        lock.wait();
    }
}

2.2 使用场景和注意事项

线程间通信：适用于需要线程间通信的场景，比如生产者-消费者模式。
必须在同步块中使用：wait()、notify()和notifyAll()必须在同步块或同步方法中使用。
可能导致死锁：如果不小心使用，可能会导致死锁。

三、高级并发工具

3.1 COUNTDOWNLATCH

CountDownLatch允许一个或多个线程等待其他线程完成操作。

CountDownLatch latch = new CountDownLatch(1);
new Thread(() -> {
    try {
        Thread.sleep(1000);
        latch.countDown();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();
latch.await();

3.2 CYCLICBARRIER

CyclicBarrier用于让一组线程互相等待，直到所有线程都到达某个公共屏障点。

CyclicBarrier barrier = new CyclicBarrier(3);
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            Thread.sleep(1000);
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }).start();
}

四、EXECUTOR FRAMEWORK

4.1 基本用法

ExecutorService提供了高级的线程池管理，允许更灵活地控制线程的生命周期。

ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
    executor.submit(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}
executor.shutdown();
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);

4.2 使用场景和注意事项

复杂任务管理：适用于管理复杂任务的场景，如批处理任务或高并发请求处理。
资源消耗：创建和管理线程池需要消耗一定的系统资源。

五、SEMAPHORE

5.1 基本用法

Semaphore是一个计数信号量，通常用于限制对某些资源的访问。

Semaphore semaphore = new Semaphore(1);
new Thread(() -> {
    try {
        semaphore.acquire();
        Thread.sleep(1000);
        semaphore.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

5.2 使用场景和注意事项

资源控制：适用于需要控制对某些资源的并发访问的场景。
复杂度：相对于其他方法，Semaphore的使用和理解相对复杂。

六、PHASER

6.1 基本用法

Phaser是一个更为灵活的同步屏障，适用于动态参与和离开同步操作的线程。

Phaser phaser = new Phaser(1);
new Thread(() -> {
    phaser.register();
    try {
        Thread.sleep(1000);
        phaser.arriveAndDeregister();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();
phaser.arriveAndAwaitAdvance();

6.2 使用场景和注意事项

动态线程管理：适用于需要动态管理线程的复杂同步场景。
灵活性：提供了更高的灵活性，但也增加了使用复杂度。

七、COMPLETABLEFUTURE

7.1 基本用法

CompletableFuture是Java 8引入的一个强大的异步编程工具。

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
future.join();

7.2 使用场景和注意事项

异步编程：适用于需要异步任务处理的场景。
回调地狱：如果不小心使用，可能会导致代码难以维护。

八、总结

在Java中实现等待的方法多种多样，每种方法都有其特定的使用场景和注意事项。选择合适的方法取决于具体的需求和应用场景。在简单的延时操作中，Thread.sleep()可能是最直接的选择；而在复杂的线程间通信和同步场景中，高级并发工具如CountDownLatch、CyclicBarrier和Phaser可能更为适用。理解并灵活运用这些工具，可以大大提升Java并发编程的效率和可靠性。

通过合理使用这些等待方法，可以有效地提高程序的健壮性和性能，避免常见的并发问题如死锁和资源竞争。