Java并发编程之LockSupport类详解

一、locksupport类的属性

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字段的内存偏移地址
            parkblockeroffset = unsafe.objectfieldoffset(tk.getdeclaredfield("parkblocker"));
            // 获取thread的threadlocalrandomseed字段的内存偏移地址
            seed = unsafe.objectfieldoffset(tk.getdeclaredfield("threadlocalrandomseed"));
            // 获取thread的threadlocalrandomprobe字段的内存偏移地址
            probe = unsafe.objectfieldoffset(tk.getdeclaredfield("threadlocalrandomprobe"));
            // 获取thread的threadlocalrandomsecondaryseed字段的内存偏移地址
            secondary = unsafe.objectfieldoffset(tk.getdeclaredfield("threadlocalrandomsecondaryseed"));
        } catch (exception ex) { throw new error(ex); }
    }

二、locksupport类的构造函数

 // 私有构造函数，无法被实例化
    private locksupport() {

    }

三、park(object blocker)方法 和 park()方法分析

//调用park函数时,当前线程首先设置好parkblocker字段,然后再调用 unsafe的park函数
    // 此后,当前线程就已经阻塞了,等待该线程的unpark函数被调用，所以后面的一个 setblocker函数无法运行
    // unpark函数被调用，该线程获得许可后,就可以继续运行了，也就运行第二个 setblocker
    // 把该线程的parkblocker字段设置为null,这样就完成了整个park函数的逻辑。
    // 总之，必须要保证在park(object blocker)整个函数 执行完后，该线程的parkblocker字段又恢复为null。

    //阻塞当前线程，并且将当前线程的parkblocker字段设置为blocker
    public static void park(object blocker) {
        // 获取当前线程
        thread t = thread.currentthread();
        //将当前线程的parkblocker字段设置为blocker
        setblocker(t, blocker);
        //阻塞当前线程，第一个参数表示isabsolute，是否为绝对时间，第二个参数就是代表时间
        unsafe.park(false, 0l);
        //重新可运行后再此设置blocker
        setblocker(t, null);
    }

    //无限阻塞线程，直到有其他线程调用unpark方法
    public static void park() {
        unsafe.park(false, 0l);
    }

四、parknanos(object blocker，long nanos)方法 和 parknanos(long nanos)方法分析

//阻塞当前线程nanos秒 毫秒
    public static void parknanos(object blocker, long nanos) {
        //先判断nanos是否大于0，小于等于0都代表无限等待
        if (nanos > 0) {
            // 获取当前线程
            thread t = thread.currentthread();
            //将当前线程的parkblocker字段设置为blocker
            setblocker(t, blocker);
            //阻塞当前线程现对时间的nanos秒
            unsafe.park(false, nanos);
            //将当前线程的parkblocker字段设置为null
            setblocker(t, null);
        }
    }

    //阻塞当前线程nanos秒 毫秒
    public static void parknanos(long nanos) {
        if (nanos > 0)
            unsafe.park(false, nanos);
    }

五、parkuntil(object blocker，long deadline)方法 和 parkuntil(long deadline)方法分析

//将当前线程阻塞绝对时间的deadline秒，并且将当前线程的parkblockeroffset设置为blocker
    public static void parkuntil(object blocker, long deadline) {
        //获取当前线程
        thread t = thread.currentthread();
        //设置当前线程parkblocker字段设置为blocker
        setblocker(t, blocker);
        //阻塞当前线程绝对时间的deadline秒
        unsafe.park(true, deadline);
        //当前线程parkblocker字段设置为null
        setblocker(t, null);
    }

    //将当前线程阻塞绝对时间的deadline秒
    public static void parkuntil(long deadline) {
        unsafe.park(true, deadline);
    }

六、setblocker(thread t, object arg)和 getblocker(thread t) 方法分析

// 设置线程t的parkblocker字段的值为arg
    private static void setblocker(thread t, object arg) {
        unsafe.putobject(t, parkblockeroffset, arg);
    }


    //获取当前线程的blocker值
    public static object getblocker(thread t) {
        //若当前线程为空就抛出异常
        if (t == null)
            throw new nullpointerexception();
        //利用unsafe对象获取当前线程的blocker值
        return unsafe.getobjectvolatile(t, parkblockeroffset);
    }

七、unpark(thread thread) 方法分析

 //释放该线程的阻塞状态，即类似释放锁，只不过这里是将许可设置为1
    public static void unpark(thread thread) {
        // 线程为不空
        if (thread != null)
            // 释放该线程许可
            unsafe.unpark(thread);
    }

八、locksupport优点

locksupport比object的wait/notify有两大优势

1.locksupport不需要在同步代码块里 。所以线程间也不需要维护一个共享的同步对象了，实现了线程间的解耦。

2.unpark函数可以先于park调用，所以不需要担心线程间的执行的先后顺序。

到此这篇关于java并发编程之locksupport类详解的文章就介绍到这了,更多相关java locksupport类内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！