LockSupport原理分析

phoenixsky 发布于2019-08-15 15:31 / 975人阅读

摘要：此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因。调用该线程变量的方法，会唤醒该线程，并抛出异常。对于等待状态来说，它比状态多了一种唤醒方式，就是超过规定时间，那么线程会自动醒来。

一. LockSupport类介绍

LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作的。

每个线程都有一个许可(permit)，permit只有两个值1和0,默认是0。

当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。

当调用park()方法，如果当前线程的permit是1，那么将permit设置为0，并立即返回。如果当前线程的permit是0，那么当前线程就会阻塞，直到别的线程将当前线程的permit设置为1.park方法会将permit再次设置为0，并返回。

注意：因为permit默认是0，所以一开始调用park()方法，线程必定会被阻塞。调用unpark(thread)方法后，会自动唤醒thread线程，即park方法立即返回。

二. LockSupport类示例

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.LockSupport;

// 简易的先进先出非重入锁
class FIFOMutex {
    //
    private final AtomicBoolean locked = new AtomicBoolean(false);
    // 记录等待线程队列
    private final Queue waiters = new ConcurrentLinkedQueue();

    public void lock() {
        boolean wasInterrupted = false;
        Thread current = Thread.currentThread();
        waiters.add(current);

        // 如果当前线程不是等待线程队列第一个，或者locked状态已经是true，那么当前线程就要等待
        while (waiters.peek() != current || !locked.compareAndSet(false, true)) {
            System.out.println(Thread.currentThread().getName()+"  park start");
            LockSupport.park(this);
            System.out.println(Thread.currentThread().getName()+"  park end");
            // 等待线程的中断线程标志位为true，就设置wasInterrupted为true
            if (Thread.interrupted())
                wasInterrupted = true;
        }

        // 移除第一个元素。当前线程就是第一个元素，因为while判断条件
        waiters.remove();
        // 如果wasInterrupted为true，当前线程发出中断请求
        if (wasInterrupted)
            current.interrupt();
        System.out.println(Thread.currentThread().getName()+" lock end" );
    }

    // 唤醒可能等待的线程
    public void unlock() {
        System.out.println(Thread.currentThread().getName()+"  unpark start ");
        // 将locked设置为false
        locked.set(false);
        // 唤醒当前线程队列中第一个元素
        LockSupport.unpark(waiters.peek());
        System.out.println(Thread.currentThread().getName()+"  unpark end ");
    }
}


public class LockSupportTest {

    public static void startThread(String name, final FIFOMutex clock, final CountDownLatch countDownLatch) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                clock.lock();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(Thread.currentThread().getName()+"  finally");
                    countDownLatch.countDown();
                    clock.unlock();
                }
            }
        }, name).start();
    }

    public static void main(String[] args) {
        FIFOMutex clock = new FIFOMutex();
        CountDownLatch countDownLatch = new CountDownLatch(3);
        startThread("t111", clock, countDownLatch);
        startThread("t222", clock, countDownLatch);
        startThread("t333", clock, countDownLatch);

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main end");
    }
}

从这个例子中可以看出，park方法会阻塞当前线程，unpark(thread)方法，会立即唤醒被阻塞的线程，让它从park方法处继续执行。

三. LockSupport源码注释

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

import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 提供阻塞线程和唤醒线程的方法。
 */
public class LockSupport {
    // 构造函数是私有的，所以不能在外部实例化
    private LockSupport() {}

    // 用来设置线程t的parkBlocker属性。此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因。
    private static void setBlocker(Thread t, Object arg) {
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    // 唤醒处于阻塞状态下的thread线程
    public static void unpark(Thread thread) {
        // 当线程不为null时调用
        if (thread != null)
            // 通过UNSAFE的unpark唤醒被阻塞的线程
            UNSAFE.unpark(thread);
    }

    // 阻塞当前线程
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        // 设置线程t的parkBlocker属性，用于记录线程阻塞情况
        setBlocker(t, blocker);
        // 通过UNSAFE的park方法阻塞线程
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

    // 阻塞当前线程nanos纳秒时间，超出时间线程就会被唤醒返回
    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);
        }
    }
    // 阻塞当前线程，超过deadline日期线程就会被唤醒返回
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    // 获取线程t的parkBlocker属性
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    // 阻塞当前线程，不设置parkBlocker属性
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

    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 = ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

    // Hotspot implementation via intrinsics API
    private static final 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.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); }
    }

}

LockSupport的源码比较简单，主要就是park系列阻塞当前线程的方法，以及unpark唤醒某个线程的方法。

注意，park系列的方法就是直接阻塞当前线程的，所以不需要线程变量参数。而unpark方法是唤醒对应线程的，所以必须传递线程变量thread。

在Java多线程详细介绍这篇文章中，我们介绍了线程一共有六种状态，而park系列方法线程进入两种状态：WAITING等待状态或TIMED_WAITING等待状态。这两种状态都会使线程阻塞在当前位置。
那么怎么唤醒这两种状态的线程呢？

对于WAITING等待状态有两种唤醒方式：

调用对应的唤醒方法。这里就是LockSupport的unpark方法。

调用该线程变量的interrupt()方法，会唤醒该线程，并抛出InterruptedException异常。

对于TIMED_WAITING等待状态来说，它比WAITING状态多了一种唤醒方式，就是超过规定时间，那么线程会自动醒来。

云服务器 GPU云服务器 LockSupport js跨域原理分析语音降噪图形分析原理webrtc 排序原理

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/69112.html

浅谈Java并发编程系列（八）—— LockSupport原理剖析

摘要：此对象在线程受阻塞时被记录，以允许监视工具和诊断工具确定线程受阻塞的原因。阻塞当前线程，最长不超过纳秒，返回条件在的基础上增加了超时返回。唤醒线程唤醒处于阻塞状态的线程。 LockSupport 用法简介 LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。 LockSupport是用来创建锁和其他同步类的基本线程阻塞...

jeyhan 2019-08-14 17:36 评论0 收藏0
FutureTask源码分析笔记

摘要：主要的实现实际上运行还是一个，它对做了一个封装，让开发人员可以从其中获取返回值是有状态的共种状态，四种状态变换的可能和的区别通过方法调用有返回值可以抛异常结果的实现原理判断状态非状态则直接进入返回结果处于状态，则进入等待流程获主要的实现FutureTask # FutureTask实际上运行还是一个runnable，它对callable做了一个封装，让开发人员可以从其中获取返回值； ...

PascalXie 2019-08-15 15:42 评论0 收藏0
Java并发编程，Condition的await和signal等待通知机制

摘要：是要和配合使用的也就是和是绑定在一起的，而的实现原理又依赖于，自然而然作为的一个内部类无可厚非。示意图如下是的内部类，因此每个能够访问到提供的方法，相当于每个都拥有所属同步器的引用。Condition简介Object类是Java中所有类的父类，在线程间实现通信的往往会应用到Object的几个方法： wait(),wait(long timeout),wait(long timeout, i...

el09xccxy 2019-05-23 16:22 评论0 收藏0
AbstractQueuedSynchronizer的介绍和原理分析

摘要：同步器拥有三个成员变量队列的头结点队列的尾节点和状态。对于同步器维护的状态，多个线程对其的获取将会产生一个链式的结构。使用将当前线程，关于后续会详细介绍。简介提供了一个基于FIFO队列，可以用于构建锁或者其他相关同步装置的基础框架。该同步器（以下简称同步器）利用了一个int来表示状态，期望它能够成为实现大部分同步需求的基础。使用的方法是继承，子类通过继承同步器并需要实现它的方法来管理...

Yuanf 2019-08-14 11:37 评论0 收藏0
AbstractQueuedSynchronizer 原理分析 - Condition 实现原理

摘要：实现原理是通过基于单链表的条件队列来管理等待线程的。中断在转移到同步队列期间或之后发生，此时表明有线程正在调用转移节点。在该种中断模式下，再次设置线程的中断状态。 1. 简介 Condition是一个接口，AbstractQueuedSynchronizer 中的ConditionObject内部类实现了这个接口。Condition声明了一组等待/通知的方法，这些方法的功能与Objec...

leone 2019-08-16 11:15 评论0 收藏0