Object.wait()和LockSupport.park()

Object.wait() 和 LockSupport.park() 都是用来使当前线程等待的方法，但它们在使用场景和机制上有所不同：

Object.wait()

1. 用途：wait() 方法属于对象监视器（Monitor）的一部分，通常与 synchronized 块或方法一起使用。当线程调用某个对象的 wait() 方法时，它会释放该对象的锁，并使自己进入等待状态，直到其他线程调用该对象的 notify() 或 notifyAll() 方法唤醒它，此时线程会重新尝试获取锁并继续执行。

2. 位置限制：只能在同步代码块或同步方法中调用，因为需要先获取到对象的监视器锁。

3. 唤醒条件：可以被 notify() 唤醒，意味着有一个或多个等待线程会被唤醒，但具体哪个线程被唤醒是不确定的；也可以被 notifyAll() 唤醒，这时所有等待该对象监视器的线程都会进入锁的竞争状态。

LockSupport.park()

1. 用途：park() 方法属于 java.util.concurrent.locks.LockSupport 类，它提供了一种低级别的线程阻塞原语。它不需要与特定的锁关联，可以在任何地方调用，使得线程阻塞。它通常与 unpark() 方法配对使用，后者可以唤醒一个调用了 park() 的线程。

2. 位置限制：没有位置限制，可以在任何地方调用，不需要先获取锁。

3. 唤醒条件：调用 LockSupport.unpark(Thread thread) 方法可以直接唤醒目标线程，更加灵活和精确。它可以唤醒一个特定的线程，而无需竞争或不确定性。

4. 线程许可：park() 和 unpark() 是基于每个线程的许可（permit）机制。初始时，每个线程没有许可，调用 unpark() 会给指定线程添加一个许可，即使之前已经调用过 unpark() 给该线程添加了许可，再调用也不会造成影响（许可不会累积）。调用 park() 时，如果没有许可，线程会阻塞，如果有许可，则消耗许可并继续执行。

总结来说，Object.wait() 更适合与同步代码块或方法一起使用，与对象的监视器锁紧密相关，适用于传统的线程协作场景；而 LockSupport.park() 提供了一种更底层、更灵活的线程阻塞和唤醒机制，适用于更复杂的并发控制逻辑。

下面是分别使用 Object.wait() 和 LockSupport.park() 的简单示例：

使用 Object.wait() 的例子

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object monitor = new Object();
        
        Thread waitingThread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (monitor) {
                    System.out.println(Thread.currentThread().getName() + " 开始等待");
                    try {
                        monitor.wait(); // 等待被唤醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 被唤醒");
                }
            }
        }, "WaitingThread");
        
        Thread notifierThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000); // 模拟一些工作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                synchronized (monitor) {
                    monitor.notify(); // 唤醒等待的线程
                    System.out.println(Thread.currentThread().getName() + " 发出了唤醒通知");
                }
            }
        }, "NotifierThread");
        
        waitingThread.start();
        notifierThread.start();
    }
}

使用 LockSupport.park() 的例子

import java.util.concurrent.locks.LockSupport;

public class ParkUnparkExample {
    public static void main(String[] args) {
        Thread waitingThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 开始等待");
                LockSupport.park(); // 阻塞当前线程
                System.out.println(Thread.currentThread().getName() + " 被唤醒");
            }
        }, "WaitingThread");
        
        Thread unparkerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000); // 模拟一些工作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                System.out.println(Thread.currentThread().getName() + " 准备唤醒线程");
                LockSupport.unpark(waitingThread); // 唤醒指定线程
            }
        }, "UnparkerThread");
        
        waitingThread.start();
        unparkerThread.start();
    }
}

在这两个例子中，第一个展示了如何使用 Object.wait() 和 notify() 来实现线程间的等待与通知，第二个例子展示了如何使用 LockSupport.park() 和 unpark() 实现类似的线程控制功能，但更为灵活和独立于特定锁。