Java并发学习笔记17 LockSupport

Java并发学习笔记17 LockSupport

基于 java 1.8.0

LockSupport 示例

package new_package.thread.locksupport;

import java.util.concurrent.locks.LockSupport;

public class LockSupportTest {

    public static void main(String[] args) {

        Object object = new Object();

        Thread thread = new Thread(() -> {
            // 禁用当前线程
            LockSupport.park(object);
            System.out.println("Hello");
        });
        thread.start();

        System.out.println("LockSupport");

        new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread2");
            //
            LockSupport.unpark(thread);
        }).start();

    }
}

LockSupport 文档

package java.util.concurrent.locks;
import sun.misc.Unsafe;

/**
 * 用来创建锁和其他同步类的基本线程阻塞原语。
 *
 * 此类以及每个使用它的线程与一个许可关联（从 Semaphore 类的意义上说）。
 * 如果该许可可用，并且可在进程中使用，则调用 park 将立即返回；否则可能 阻塞。
 * 如果许可尚不可用，则可以调用 unpark 使其可用。
 * （但与 Semaphore 不同的是，许可不能累积，并且最多只能有一个许可。）
 *
 * park 和 unpark 方法提供了阻塞和解除阻塞线程的有效方法，
 * 并且不会遇到导致过时方法 Thread.suspend 和 Thread.resume 因为以下目的变得不可用的问题：
 * 由于许可的存在，调用 park 的线程和另一个试图将其 unpark 的线程之间的竞争将保持活性。
 * 此外，如果调用者线程被中断，并且支持超时，则 park 将返回。
 * park 方法还可以在其他任何时间“毫无理由”地返回，因此通常必须在重新检查返回条件的循环里调用此方法。
 * 从这个意义上说，park 是“忙碌等待”的一种优化，它不会浪费这么多的时间进行自旋，但是必须将它与 unpark 配对使用才更高效。
 *
 * 三种形式的 park 还各自支持一个 blocker 对象参数。
 * 此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因。
 * （这样的工具可以使用方法 getBlocker(java.lang.Thread) 访问 blocker。）
 * 建议最好使用这些形式，而不是不带此参数的原始形式。在锁实现中提供的作为 blocker 的普通参数是 this。
 *
 * 这些方法被设计用来作为创建高级同步实用工具的工具，
 * 对于大多数并发控制应用程序而言，它们本身并不是很有用。
 * park 方法仅设计用于以下形式的构造：
 *
 * while (!canProceed()) { ... LockSupport.park(this); }}
 *
 * 在这里，在调用 park 之前，canProceed 和其他任何动作都不会锁定或阻塞。
 * 因为每个线程只与一个许可关联，park 的任何中间使用都可能干扰其预期效果。
 *
 * 示例用法。 以下是一个先进先出 (first-in-first-out) 非重入锁类的框架。
 *
 * class FIFOMutex {
 *   private final AtomicBoolean locked = new AtomicBoolean(false);
 *   private final Queue<Thread> waiters
 *     = new ConcurrentLinkedQueue<Thread>();
 *
 *   public void lock() {
 *     boolean wasInterrupted = false;
 *     Thread current = Thread.currentThread();
 *     waiters.add(current);
 *
 *     // Block while not first in queue or cannot acquire lock
 *     while (waiters.peek() != current ||
 *            !locked.compareAndSet(false, true)) {
 *       LockSupport.park(this);
 *       if (Thread.interrupted()) // ignore interrupts while waiting
 *         wasInterrupted = true;
 *     }
 *
 *     waiters.remove();
 *     if (wasInterrupted)          // reassert interrupt status on exit
 *       current.interrupt();
 *   }
 *
 *   public void unlock() {
 *     locked.set(false);
 *     LockSupport.unpark(waiters.peek());
 *   }
 * }}
 */
public class LockSupport {
    private LockSupport() {} // Cannot be instantiated.

    private static void setBlocker(Thread t, Object arg) {
        // Even though volatile, hotspot doesn't need a write barrier here.
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    /**
     * 如果给定线程的许可尚不可用，则使其可用。
     * 如果线程在 park 上受阻塞，则它将解除其阻塞状态。
     * 否则，保证下一次调用 park 不会受阻塞。
     * 如果给定线程尚未启动，则无法保证此操作有任何效果。
     *
     * @param thread 要执行 unpark 操作的线程；该参数为 null 表示此操作没有任何效果。
     */
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

    /**
     * 为了线程调度，在许可可用之前禁用当前线程。
     *
     * 如果许可可用，则使用该许可，并且该调用立即返回；
     * 否则，为线程调度禁用当前线程，并在发生以下三种情况之一前，使其处于休眠状态：
     *
     * 其他某个线程调用将当前线程作为目标调用 unpark；或者
     * 其他某个线程中断当前线程；或者
     * 该调用不合逻辑地（即毫无理由地）返回。
     *
     * 此方法不 报告是哪个线程导致该方法返回。
     * 调用者应该重新检查最先导致线程暂停的条件。
     * 调用者还可以确定返回时该线程的中断状态。
     *
     * @param blocker 导致此线程暂停的同步对象
     * @since 1.6
     */
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

    /**
     * 为了线程调度，在许可可用前禁用当前线程，并最多等待指定的等待时间。
     *
     * 如果许可可用，则使用该许可，并且该调用立即返回；否则，为线程调度禁用当前线程，并在发生以下四种情况之一前，使其处于休眠状态：
     *
     * 其他某个线程将当前线程作为目标调用 unpark；或者
     * 其他某个线程中断当前线程；或者
     * 已超过指定的等待时间；或者
     * 该调用不合逻辑地（即毫无理由地）返回。
     *
     * 此方法不 报告是哪个线程导致该方法返回。调用者应该重新检查最先导致线程暂停的条件。调用者还可以确定返回时该线程的中断状态或已过的时间。
     *
     * @param blocker 导致此线程暂停的同步对象
     * @param nanos 要等待的最大毫秒数
     * @since 1.6
     */
    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            UNSAFE.park(false, nanos);
            setBlocker(t, null);
        }
    }

    /**
     * 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
     *
     * 如果许可可用，则使用该许可，并且该调用立即返回；否则，为线程调度禁用当前线程，并在发生以下四种情况之一前，使其处于休眠状态：
     *
     * 其他某个线程将当前线程作为目标调用 unpark；或者
     * 其他某个线程中断当前线程；或者
     * 指定时限已过；或者, 
     * 该调用不合逻辑地（即毫无理由地）返回。
     *
     * 此方法不 报告是哪个线程导致该方法返回。调用者应该重新检查最先导致线程暂停的条件。调用者还可以确定返回时该线程的中断状态或当前时间。
     *
     * @param blocker 导致此线程暂停的同步对象
     * @param deadline 要等待的绝对时间，用相对于历元 (Epoch) 的毫秒数值表示
     * @since 1.6
     */
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    /**
     * 返回提供给最近一次尚未解除阻塞的 park 方法调用的 blocker 对象，如果该调用不受阻塞，则返回 null。
     * 返回的值只是一个瞬间快照，即由于未解除阻塞或者在不同的 blocker 对象上受阻而具有的线程。
     *
     * @param t the thread
     * @return the blocker
     * @throws NullPointerException if argument is null
     * @since 1.6
     */
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    /**
     * 为了线程调度，禁用当前线程，除非许可可用。
     */
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    /**
     * 为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用。
     *
     * @param nanos 要等待的最大毫秒数
     */
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

    /**
     * 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
     *
     * @param deadline 要等待的绝对时间，用相对于历元的毫秒数值表示
     */
    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

    /**
     * Returns the pseudo-randomly initialized or updated secondary seed.
     * Copied from ThreadLocalRandom due to package access restrictions.
     */
    static final int nextSecondarySeed() {
        int r;
        Thread t = Thread.currentThread();
        if ((r = UNSAFE.getInt(t, SECONDARY)) != 0) {
            r ^= r << 13;   // xorshift
            r ^= r >>> 17;
            r ^= r << 5;
        }
        else if ((r = java.util.concurrent.ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

    // Hotspot implementation via intrinsics API
    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 = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            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); }
    }

}