Java中如何实现线程等待和唤醒？

Java中可以使用以下几种方式实现线程的等待和唤醒：

1. 使用Object类的wait()、notify()和notifyAll()方法：

Object类中的这三个方法可以用于线程的等待和唤醒，前提是线程必须先对对象加锁（即在synchronized代码块或方法内调用这三个方法）。

- wait()方法使当前线程等待，直到其他线程调用对象的notify()或notifyAll()方法唤醒它。

- notify()方法随机唤醒正在等待对象的一个线程。

- notifyAll()方法唤醒正在等待对象的所有线程。

2. 使用Condition接口：

Condition接口是Java并发包中提供的一种更加灵活的线程等待和唤醒机制，可以替代Object类的wait()、notify()和notifyAll()方法。

Condition接口可以通过Lock接口的newCondition()方法创建。

   import java.util.concurrent.locks.*;
   public class MyThread implements Runnable {
     private Lock lock = new ReentrantLock();
     private Condition condition = lock.newCondition();

     public void run() {
       lock.lock();
       try {
         System.out.println("线程等待开始");
         condition.await();
         System.out.println("线程被唤醒");
       } catch (InterruptedException e) {
         e.printStackTrace();
       } finally {
         lock.unlock();
       }
     }

     public void wakeup() {
       lock.lock();
       try {
         System.out.println("线程唤醒开始");
         condition.signal();
         System.out.println("线程唤醒结束");
       } finally {
         lock.unlock();
       }
     }

     public static void main(String[] args) {
       MyThread thread = new MyThread();
       new Thread(thread).start();
       try {
         Thread.sleep(2000);
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       thread.wakeup();
     }
   }
   

上述代码中，线程首先调用condition.await()方法进行等待，然后另一个线程调用condition.signal()方法唤醒等待的线程。

3. 使用Thread类的join()方法：

join()方法可以让一个线程等待另一个线程的结束。当一个线程执行另一个线程的join()方法时，它会等待另一个线程执行完毕后再继续执行。

   public class JoinExample {
     public static void main(String[] args) {
       Thread t1 = new Thread(new MyRunnable(), "Thread 1");
       Thread t2 = new Thread(new MyRunnable(), "Thread 2");

       t1.start();
       try {
         t1.join();
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       t2.start();
     }

     static class MyRunnable implements Runnable {
       public void run() {
         for (int i = 0; i < 5; i++) {
           System.out.println(Thread.currentThread().getName() + ": " + i);
           try {
             Thread.sleep(1000);
           } catch (InterruptedException e) {
             e.printStackTrace();
           }
         }
       }
     }
   }
   

上述代码中，线程t1调用了t1.join()方法，会使主线程等待t1线程执行完毕后再继续执行。

以上是Java中几种常见的线程等待和唤醒的方式。根据实际需求选择合适的方式来实现线程的等待和唤醒操作。