Java并发 - LockSupport详解

LockSupport是Java中用于实现线程阻塞和唤醒的工具类。它提供了一种基于线程的阻塞原语,能够在不需要持有锁的情况下实现线程的挂起和唤醒操作。

1. LockSupport是什么?

LockSupport是Java并发包(java.util.concurrent)中的一个工具类,用于实现线程的阻塞和唤醒操作。与传统的使用synchronized关键字或Object类的wait()和notify()方法不同,LockSupport使用更加灵活的方式来管理线程的阻塞状态。

2. LockSupport的主要作用?

LockSupport的主要作用是允许线程进行阻塞和唤醒,而且可以在任意位置对线程进行操作,而无需持有特定的锁。它提供了park()和unpark()两个静态方法,可以分别用于阻塞线程和唤醒线程。

  • park(): 阻塞当前线程。
  • unpark(Thread thread): 唤醒指定线程。

LockSupport不需要获取某个对象的锁来进行阻塞或唤醒,而是通过给线程分配一个许可证(permit)的方式来实现。

3. LockSupport核心函数

  • **park():**使得当前线程进入阻塞状态,一直阻塞直到调用unpark(Thread thread)方法或被中断。
  • **unpark(Thread thread):**用于唤醒通过park()方法被阻塞的线程。
  • **parkNanos(Object blocker, long nanos):**阻塞当前线程,最多阻塞nanos纳秒,或直到被中断。
  • **parkUntil(Object blocker, long deadline):**阻塞当前线程,直到deadline时间点或被中断。

4. LockSupport源码分析

LockSupport的核心方法是park()和unpark(Thread thread),它们的实现比较简单。以下是简化的LockSupport源码:

public class LockSupport {

    public static void park(Object blocker) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 设置Blocker
        setBlocker(t, blocker);
        // 获取许可
        UNSAFE.park(false, 0L);
        // 重新可运行后再此设置Blocker
        setBlocker(t, null);
    }

    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }
    
    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) { // 时间大于0
            // 获取当前线程
            Thread t = Thread.currentThread();
            // 设置Blocker
            setBlocker(t, blocker);
            // 获取许可,并设置了时间
            UNSAFE.park(false, nanos);
            // 设置许可
            setBlocker(t, null);
        }
    }
    
    public static void parkUntil(Object blocker, long deadline) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 设置Blocker
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        // 设置Blocker为null
        setBlocker(t, null);
    }
    
    // ... 其他代码 ...
	// Unsafe实例
    private static final sun.misc.Unsafe UNSAFE;
    // 以下字段记录的是内存偏移地址
    private static final long parkBlockerOffset;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;

    static {
        try {
            // 获取UnSafe对象实例
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            // 获取线程对象
            Class<?> tk = Thread.class;
			// 获取Thread类中的字段parkBlocker、threadLocalRandomSeed、threadLocalRandomProbe、threadLocalRandomSecondarySeed的内存偏移量。
            parkBlockerOffset = UNSAFE.objectFieldOffset(tk.getDeclaredField("parkBlocker"));
            SEED = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomSeed"));
            PROBE = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomProbe"));
            SECONDARY = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }
    // ... 其他代码 ...
}

5. LockSupport的应用场景

LockSupport的灵活性使得它在一些特定的场景中非常有用,如:

  1. 替代传统的wait()和notify():LockSupport可以在任意位置进行线程的阻塞和唤醒,而不需要在特定的同步块内调用。
  2. 实现自定义的线程同步机制:LockSupport可以作为构建自定义锁或同步工具的基础组件,提供更灵活的线程控制。
  3. 线程的挂起和唤醒:LockSupport可以用于实现一些需要线程挂起和唤醒的场景,例如线程池中的工作者线程。

6. LockSupport示例

public class LockSupportExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is going to be parked");
            LockSupport.park(); // 阻塞当前线程
            System.out.println("Thread is unparked");
        });

        thread.start();

        try {
            Thread.sleep(2000); // 等待2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        LockSupport.unpark(thread); // 唤醒线程
    }
}
Thread is going to be parked
Thread is unparked

在这个例子中,线程启动后会被阻塞,然后主线程等待2秒后调用LockSupport.unpark()方法唤醒被阻塞的线程。

问:先调用park再调用unpark 跟 先调用unpark再调用park有什么区别

在调用unpark之后,线程调用LockSupport.park(),由于之前已经被唤醒,所以它不会被阻塞,可以继续执行之后的代码。

7. LockSupport的深入理解

LockSupport中的parkunpark方法与waitnotify方法都用于线程之间的协作,但有一些重要的区别。

7.1 粒度和使用方式

  • parkunpark
    • parkunpark是用于线程级别的协作,不需要在特定的同步块内调用。
    • 可以在任意地方调用parkunpark,并且不需要持有某个对象的锁。
  • waitnotify
    • waitnotify是基于对象级别的协作,必须在同步块内使用,通常使用synchronized关键字。
    • 调用waitnotify之前需要获取对象的锁。

7.2 唤醒方式:

  • parkunpark
    • unpark可以在park之前调用,也可以在park之后调用。多次调用unpark不会积累许可,每个线程最多有一个许可。
    • unpark可以指定唤醒特定线程。
  • waitnotify
    • notify必须在wait之后调用,且只能唤醒等待同一对象锁的某一个线程。
    • notifyAll唤醒等待同一对象锁的所有线程。

7.3 中断响应:

  • parkunpark
    • park可以响应中断,线程在被中断时会立即返回。
    • unpark不会受到中断的影响。
  • waitnotify
    • wait在等待期间被中断会抛出InterruptedException
    • notify不受中断的影响。

7.4 条件等待:

  • parkunpark
    • parkunpark本身不提供条件等待的机制,但可以通过配合使用其他条件来实现。
  • waitnotify
    • waitnotify通常与while循环一起使用,以检查特定条件是否满足。

7.5 示例代码对比

使用LockSupport的示例:

请看上述示例

使用waitnotify的示例:

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

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread is going to wait");
                try {
                    lock.wait(); // 阻塞当前线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread is notified");
            }
        });

        thread.start();

        try {
            Thread.sleep(2000); // 等待2秒
            System.out.println("sleep end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized (lock) {
            lock.notify(); // 唤醒线程
            System.out.println("thread is notify");
        }
    }
}
Thread is going to wait
sleep end
thread is notify
Thread is notified

你可能感兴趣的:(Java,java,开发语言)