LockSupport秘籍：新手入门，高手精通，玩转同步控制

import java.util.concurrent.locks.LockSupport;

public class LockSupportExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始运行...");
            // 做一些工作...
            
            System.out.println("线程挂起...");
            LockSupport.park(); // 挂起线程
            
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("线程被中断...");
            } else {
                System.out.println("线程被恢复...");
            }
            
            // 继续执行其他任务...
        });
        
        thread.start();
        // 让主线程睡眠一段时间，确保子线程已经挂起
        Thread.sleep(2000);
        System.out.println("尝试恢复线程...");
        LockSupport.unpark(thread); // 恢复线程
        // 让主线程再睡眠一段时间，确保子线程有机会执行完毕
        Thread.sleep(2000);
    }
}

public class WaitNotifyExample {
    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1等待");
                    lock.wait(); // 线程等待
                    System.out.println("线程1被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2唤醒其他线程");
                lock.notify(); // 唤醒等待的线程
            }
        });

        thread1.start();
        Thread.sleep(1000); // 确保thread1先执行
        thread2.start();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockConditionExample {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("线程1等待");
                condition.await(); // 线程等待
                System.out.println("线程1被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("线程2唤醒其他线程");
                condition.signal(); // 唤醒等待的线程
            } finally {
                lock.unlock();
            }
        });

        thread1.start();
        Thread.sleep(1000); // 确保thread1先执行
        thread2.start();
    }
}

import java.util.concurrent.locks.LockSupport;

public class LockSupportExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("线程1开始运行");
            LockSupport.park("等待唤醒"); // 线程等待
            System.out.println("线程1被唤醒");
        });

        thread1.start();
        Thread.sleep(1000); // 确保thread1先执行并等待

        System.out.println("主线程唤醒线程1");
        LockSupport.unpark(thread1); // 唤醒线程1
    }
}

public class LockSupport {
    private LockSupport() {} // Cannot be instantiated.

    // Blocks until unparked, interrupted, or the caller spuriously returns.
    public static void park() {
        Unsafe.getUnsafe().park(false, 0L);
    }

    // Blocks until unparked, interrupted, the caller spuriously returns,
    // or the deadline passes, whichever comes first.
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            Unsafe.getUnsafe().park(false, nanos);
    }

    // Blocks until unparked, interrupted, the caller spuriously returns,
    // or approximately deadline milliseconds have passed, whichever comes first.
    public static void parkUntil(long deadline) {
        Unsafe.getUnsafe().park(true, deadline);
    }

    // Unblocks the thread blocked by park().
    public static void unpark(Thread thread) {
        if (thread != null)
            Unsafe.getUnsafe().unpark(thread);
    }

    // Hotspot implementation of park/unpark may need some help to find
    // threads blocked on the LockSupport objects created by this class.
    // These methods are natively implemented in the JDK.
    private static native void setBlocker(Thread t, Object arg);
    private static native Object getBlocker(Thread t);
    
    // Disables the current thread for thread scheduling purposes, for up to the
    // specified waiting time, unless the `permit` is available.
    // This method is designed to be used as a tool for creating higher-level
    // synchronization utilities, and is not intended for general use.
    // It supports a single permit, which is initially unavailable, and
    // which becomes available when `unpark` is invoked, or if the caller
    // spuriously returns.
    // ... additional methods related to permit (not shown here)
}