JUC学习笔记-线程阻塞

线程阻塞

使用sleep（）、wait（）和join（） 方法都会使线程进入阻塞状态。

1. sleep: 是一个线程暂停的方法，它使线程进入指定时间的睡眠状态，等待一段时间后再次被调度。在睡眠期间，线程不会占用CPU资源。
2. wait:是一个对象级别的方法，用于线程间的通信。当一个线程调用对象的wait()方法时，它会释放对象的锁，并进入等待状态，直到其他线程调用相同对象的notify()或notifyAll()方法来唤醒它。
3. join:是一个线程级别的方法，用于等待另一个线程的结束。当一个线程调用另一个线程的join()方法时，它会被阻塞，直到目标线程执行完毕。通常用于等待子线程执行完毕后再执行主线程的情况。

sleep（睡眠）：

sleep 方法是用来暂停当前线程的执行一段时间。在 Java 中，它通常以毫秒为单位来指定睡眠的时间。

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("线程开始执行");
        try {
            // 线程暂停 3 秒
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程继续执行");
    }
}

wait（等待）：

wait 方法是在对象级别上进行的暂停，它使当前线程等待直到其他线程调用相同对象上的 notify() 或 notifyAll() 方法。它通常与 synchronized 关键字一起使用。

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1等待...");
                    lock.wait(); // 线程1等待，直到被唤醒
                    System.out.println("线程1被唤醒，继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2唤醒线程1");
                lock.notify(); // 唤醒等待在lock对象上的一个线程
            }
        });

        thread1.start();
        thread2.start();
    }
}

join（加入）：

join 方法用于等待另一个线程的结束。当在一个线程中调用另一个线程的 join() 方法时，当前线程将被阻塞，直到另一个线程执行完毕。

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1执行完毕");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("线程2开始执行");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2执行完毕");
        });

        thread1.start();
        thread2.start();

        thread1.join(); // 等待线程1执行完毕
        thread2.join(); // 等待线程2执行完毕

        System.out.println("所有线程执行完毕");
    }
}