在Java中，我们可以通过以下几种方式实现等待：使用Thread.sleep()方法、使用Object.wait()方法、使用Lock/Condition机制、利用BlockingQueue、使用FutureTask、利用CountDownLatch和CyclicBarrier、使用Semaphore、使用ScheduledExecutorService等等。
其中，最常见的一种方法是使用Thread.sleep()方法。这是一个静态方法，可以使当前线程暂停执行指定的时间，让出cpu给其他线程，但是它的缺点是精确度受操作系统调度精度和准确度影响。下面我们将详细展开描述这种方法。
一、使用Thread.sleep()方法
Thread.sleep()方法是最基本的一种使线程等待的方法。它是Thread类的一个静态方法，用于暂停当前正在执行的线程，使其进入睡眠状态。
1.1 如何使用Thread.sleep()方法
要使用Thread.sleep()方法，我们只需要调用Thread.sleep()，并传入你希望线程睡眠的毫秒数。例如，以下代码将使当前线程睡眠1秒：
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
在这里，Thread.sleep(1000)会使当前线程暂停1秒。如果在睡眠期间线程被中断，那么线程会立即退出睡眠状态，同时Thread.sleep()方法会抛出InterruptedException异常。
1.2 Thread.sleep()方法的注意事项
尽管Thread.sleep()方法很简单，但在使用时还是有一些需要注意的地方。
首先，Thread.sleep()方法的参数是毫秒数，所以如果你需要使线程睡眠的时间超过1秒，你需要传入的数值就需要超过1000。
其次，虽然Thread.sleep()可以使线程暂停执行，但它不会释放任何锁资源。因此，如果一个线程在持有某个锁的时候调用了Thread.sleep()方法，那么这个线程在睡眠期间依然会持有这个锁。这可能会阻塞其他试图获取这个锁的线程。
最后，Thread.sleep()方法可能会抛出InterruptedException异常。当一个线程在睡眠状态下被另一个线程中断时，会抛出这个异常。因此，当你使用Thread.sleep()方法时，你需要准备处理这个异常。
二、使用Object.wait()方法
Object.wait()方法是一个实例方法，用于使当前线程进入等待状态，同时释放当前线程持有的所有同步资源。
2.1 如何使用Object.wait()方法
要使用Object.wait()方法，我们需要先获取一个对象的监视器（monitor）。一般情况下，我们会使用synchronized关键字来获取一个对象的监视器：
synchronized (obj) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
在这里，obj.wait()会使当前线程进入等待状态，并释放obj的监视器。如果在等待期间线程被中断，那么线程会立即退出等待状态，同时obj.wait()方法会抛出InterruptedException异常。
2.2 Object.wait()方法的注意事项
Object.wait()方法的使用与Thread.sleep()方法有许多相似之处，但也有一些重要的区别。
首先，Object.wait()方法也可以接受一个毫秒数作为参数，用来指定线程等待的最长时间。如果在这段时间内没有其他线程调用同一个对象的notify()或notifyAll()方法，那么线程会自动退出等待状态。
其次，与Thread.sleep()方法不同，Object.wait()方法会释放线程持有的所有同步资源。这意味着，如果一个线程在持有某个锁的时候调用了Object.wait()方法，那么这个线程在进入等待状态时会释放这个锁。这可以避免因线程的睡眠而导致的资源阻塞。
最后，Object.wait()方法也可能会抛出InterruptedException异常。当一个线程在等待状态下被另一个线程中断时，会抛出这个异常。因此，当你使用Object.wait()方法时，你需要准备处理这个异常。
三、使用Lock/Condition机制
Lock/Condition机制是Java并发包java.util.concurrent中提供的一种等待/通知机制，它是对Object.wait()方法和Object.notify()方法的增强和扩展。
3.1 如何使用Lock/Condition机制
要使用Lock/Condition机制，我们首先需要创建一个Lock对象和一个Condition对象：
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
然后，我们可以在一个线程中调用Condition的await()方法使线程进入等待状态：
lock.lock();
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
在这里，condition.await()会使当前线程进入等待状态，并释放lock锁。如果在等待期间线程被中断，那么线程会立即退出等待状态，同时condition.await()方法会抛出InterruptedException异常。
另一个线程可以调用Condition的signal()方法或signalAll()方法来唤醒等待状态的线程：
lock.lock();
try {
condition.signal();
} finally {
lock.unlock();
}
在这里，condition.signal()会唤醒一个在condition上等待的线程，condition.signalAll()会唤醒所有在condition上等待的线程。
3.2 Lock/Condition机制的注意事项
Lock/Condition机制提供了比Object.wait()方法和Object.notify()方法更强大、更灵活的等待/通知机制。
首先，Lock/Condition机制提供了多路通知能力。每个Lock对象可以有多个Condition对象，线程可以选择在某个Condition对象上等待，也可以选择唤醒某个Condition对象上的等待线程。这比Object.wait()方法和Object.notify()方法只能在一个对象上等待和唤醒线程要灵活得多。
其次，Lock/Condition机制提供了公平锁和非公平锁。公平锁保证了等待时间最长的线程最先获得锁，非公平锁则不作这种保证。而Object.wait()方法和Object.notify()方法则只提供了非公平锁。
最后，Lock/Condition机制提供了更精确的线程调度。它允许我们选择性地唤醒等待线程，而Object.wait()方法和Object.notify()方法则只能随机唤醒一个等待线程或唤醒所有等待线程。
四、利用BlockingQueue
BlockingQueue是Java并发包java.util.concurrent中的一个接口，它表示一个线程安全的队列，可以在队列为空时阻塞读线程，队列满时阻塞写线程。
4.1 如何利用BlockingQueue
要利用BlockingQueue，我们首先需要创建一个BlockingQueue对象：
BlockingQueue
然后，我们可以在一个线程中调用BlockingQueue的put()方法将元素放入队列：
try {
queue.put("element");
} catch (InterruptedException e) {
e.printStackTrace();
}
在这里，queue.put("element")会将元素放入队列。如果队列已满，那么put()方法会使当前线程进入等待状态，直到队列中有空位。
另一个线程可以调用BlockingQueue的take()方法从队列中取出元素：
try {
String element = queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
在这里，queue.take()会从队列中取出元素。如果队列为空，那么take()方法会使当前线程进入等待状态，直到队列中有元素。
4.2 利用BlockingQueue的注意事项
BlockingQueue提供了一种简单、有效的线程间通信方式。通过BlockingQueue，我们可以轻松实现生产者-消费者模型，使生产者线程和消费者线程能够有序、高效地进行数据交换。
首先，BlockingQueue提供了公平锁和非公平锁。公平锁保证了等待时间最长的线程最先获得锁，非公平锁则不作这种保证。我们可以在创建BlockingQueue时通过构造函数参数来选择是使用公平锁还是非公平锁。
其次，BlockingQueue提供了多种阻塞和非阻塞的操作方法。例如，put()方法和take()方法是阻塞的，add()方法和remove()方法是非阻塞的，offer()方法和poll()方法是有超时限制的非阻塞方法。
最后，BlockingQueue是线程安全的，我们可以在多线程环境下使用它而无需担心线程同步问题。
五、使用FutureTask
FutureTask是Java并发包java.util.concurrent中的一个类，它表示一个异步计算的结果。通过FutureTask，我们可以在一个线程中提交一个任务，然后在另一个线程中等待这个任务的结果。
5.1 如何使用FutureTask
要使用FutureTask，我们首先需要创建一个Callable对象，这个对象表示我们要执行的任务：
Callable
@Override
public Integer call() throws Exception {
return doSomeLongTimeOperation();
}
};
然后，我们创建一个FutureTask对象，并将Callable对象传给它：
FutureTask
接着，我们创建一个Thread对象，并将FutureTask对象传给它：
Thread thread = new Thread(futureTask);
最后，我们启动线程，并在需要结果的地方调用FutureTask的get()方法来获取结果：
thread.start();
try {
Integer result = futureTask.get();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
在这里，futureTask.get()会使当前线程进入等待状态，直到任务完成并返回结果。如果在等待期间线程被中断，那么线程会立即退出等待状态，同时futureTask.get()方法会抛出InterruptedException异常。
5.2 使用FutureTask的注意事项
FutureTask提供了一种高效、灵活的线程间通信方式。
首先，FutureTask提供了任务取消功能。我们可以调用FutureTask的cancel()方法来取消任务。如果任务已经完成，或者已经被取消，或者由于其他原因不能被取消，那么cancel()方法会返回false。否则，它会返回true。
其次，FutureTask提供了任务完成通知功能。我们可以重写FutureTask的done()方法，当任务完成时，done()方法会被自动调用。
最后，FutureTask是线程安全的，我们可以在多线程环境下使用它而无需担心线程同步问题。
六、利用CountDownLatch和CyclicBarrier
CountDownLatch和CyclicBarrier是Java并发包java.util.concurrent中的两个类，它们都可以用于使线程等待其他线程。
6.1 如何利用CountDownLatch
要利用CountDownLatch，我们首先需要创建一个CountDownLatch对象，并指定一个计数值：
CountDownLatch latch = new CountDownLatch(3);
然后，在需要等待的线程中调用CountDownLatch的await()方法：
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
在这里，latch.await()会使当前线程进入等待状态，直到CountDownLatch的计数值变为0。如果在等待期间线程被中断，那么线程会立即退出等待状态，同时latch.await()方法会抛出InterruptedException异常。
在其他线程中，我们可以调用CountDownLatch的countDown()方法，使计数值减1：
latch.countDown();
当CountDownLatch的计数值变为0时，所有在latch.await()上等待的线程都会被唤醒。
6.2 如何利用CyclicBarrier
要利用CyclicBarrier，我们首先需要创建一个CyclicBarrier对象，并指定一个屏障点的线程数：
CyclicBarrier barrier = new CyclicBarrier(3);
然后，在需要等待的线程中调用CyclicBarrier的await()方法：
try {
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
在这里，barrier.await()会使当前线程进入等待状态，直到所有线程都到达屏障点。如果在等待期间线程被中断，或者其他线程由于异常而使屏障破裂，那么线程会立即退出等待状态，同时barrier.await()方法会抛出InterruptedException或BrokenBarrierException异常。
当所有线程都到达屏障点时，所有在barrier.await()上等待的线程都会被唤醒，同时CyclicBarrier会自动重置，可以被再次使用。
6.3 利用CountDownLatch和CyclicBarrier的注意事项
CountDownLatch和CyclicBarrier提供了两种不同的线程同步机制。
首先，CountDownLatch是一次性的，它的计数值只能从一个非负值递减到0，不能被重置。而CyclicBarrier可以被重复使用，每当所有线程都到达屏障点时，它就会自动重置。
其次，CountDownLatch主要用于一个线程等待多个线程的场景，例如主线程等待多个子线程完成。而CyclicBarrier主要用于多个线程互相等待的场景，例如多个线程在完成各自的部分工作后，等待所有线程都准备好，然后再同时继续下一步工作。
最后，CountDownLatch和CyclicBarrier都可能会抛出InterruptedException异常。当一个线程在等待状态下被另一个线程中断时，会抛出这个异常。因此，当你使用CountDownLatch或CyclicBarrier时，你需要准备处理这个异常。
七、使用Semaphore
Semaphore是Java并发包java.util.concurrent中的一个类，它表示一个信号量。通过Semaphore，我们可以限制同时访问某个资源的线程数。
7.1 如何使用Semaphore
要使用Semaphore，我们首先需要创建一个Semaphore对象，并指定信号量的数量：
Semaphore semaphore = new Semaphore(3);
然后，在需要访问资源的线程中调用Semaphore的acquire()方法：
try {
semaphore.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
在这里，semaphore.acquire()会尝试获得一个许可。如果没有许可可用，那么acquire()方法会使当前线程进入等待状态，直到有许可可用。如果在等待期间线程被中断，那么线程会立即退出等待状态，同时semaphore.acquire()方法会抛出InterruptedException异常。
在访问完资源后，线程需要调用Semaphore的release()方法，释放许可：
semaphore.release();
当Semaphore有可用的许可时，所有在semaphore.acquire()上等待的线程都会被唤醒，然后竞争获得许可。
7.
相关问答FAQs：
1. 如何在Java中进行等待操作？
在Java中，可以使用wait()方法来进行等待操作。该方法必须在同步代码块或同步方法中使用，并且会使当前线程进入等待状态，直到其他线程通知或中断当前线程。
2. 如何唤醒一个正在等待的线程？
要唤醒一个正在等待的线程，可以使用notify()或notifyAll()方法。notify()方法会随机选择一个等待的线程进行唤醒，而notifyAll()方法会唤醒所有等待的线程。需要注意的是，唤醒线程的操作必须在同步代码块或同步方法中执行。
3. 如何防止线程在等待时出现死锁？
为了防止线程在等待时出现死锁，可以在等待操作中使用wait(long timeout)方法，并设置一个超时时间。这样，如果等待的时间超过了指定的超时时间，线程就会自动唤醒。另外，还可以使用interrupt()方法中断等待的线程，使其提前结束等待状态。
文章包含AI辅助创作，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/204710