LockSupport详解

LockSupport详解

  1. 测试没有unpark,park会一直阻塞,unpark只是设置一个标识( 许可没有是被占用的),而park查看标识,有继续执行,没有一直阻塞

 

    // LockSupport.unpark(Thread.currentThread());

    LockSupport.park();

    // 如果不调用unpark线程会一直处于等待状态

    System.out.println("block.");

  1. LockSupport是可不重入的,可以这样理解unpark,把flag改为1,执行park就看是否是1,是1继续执行并把flag设置为0,不是1阻塞flag不存在,只是你让好理解)

Thread thread = Thread.currentThread();

LockSupport.unpark(thread);

System.out.println("a");

LockSupport.park();

System.out.println("b");

new Thread(new Runnable() {

    @Override

    public void run() {

        try {

            TimeUnit.SECONDS.sleep(3);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        LockSupport.unpark(thread);

    }

},"allen").start();

LockSupport.park(); //如果线程allen,执行了unpark,"c"永远不会打印

System.out.println("c");

  1. 能够响应中断请求,但不抛异常,会使阻塞状态变成运行状态

   Thread t = new Thread(() -> {

            LockSupport.park();  //等待或许许可

            System.out.println("thread over." + Thread.currentThread().isInterrupted());

        });

        t.start();

        // 让线程执行到   LockSupport.park();

        Thread.sleep(2000);

        t.interrupt();  // 中断线程

        System.out.println("main线程最后一条语句");

 

 

 

 

源码:底层实现是Unsafe,想看更深层,学习c、c++

package java.util.concurrent.locks;

import sun.misc.Unsafe;

public class LockSupport {

    private LockSupport() {} // 不能实例化

    private static final sun.misc.Unsafe UNSAFE;// Hotspot 内部实现

    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); }

    }

 

    private static void setBlocker(Thread t, Object arg) {

        // Even though volatile, hotspot doesn't need a write barrier here.

        UNSAFE.putObject(t, parkBlockerOffset, arg);

    }

 

    public static void unpark(Thread thread) {

        if (thread != null)  UNSAFE.unpark(thread);      

    }

 

    public static void park(Object blocker) {

        Thread t = Thread.currentThread();

        setBlocker(t, blocker);

        UNSAFE.park(false, 0L);

        setBlocker(t, null);

    }

 

    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);

        }

    }

 

    public static void parkUntil(Object blocker, long deadline) {

        Thread t = Thread.currentThread();

        setBlocker(t, blocker);

        UNSAFE.park(true, deadline);

        setBlocker(t, null);

    }

 

    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);}

 

    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 = java.util.concurrent.ThreadLocalRandom.current().nextInt()) == 0)

            r = 1; // avoid zero

        UNSAFE.putInt(t, SECONDARY, r);

        return r;

    }

}

 

你可能感兴趣的:(多线程)