JUC锁框架——LockSupport应用以及源码分析-CSDN博客

2019独角兽企业重金招聘Python工程师标准>>>

LockSupport用法

在没有LockSupport之前，线程的挂起和唤醒咱们都是通过Object的wait和notify/notifyAll方法实现，而Object的wait和notify/notifyAll方法只能在同步代码块里用。而LockSupport的park和unpark无需同步代码块里，直接调用就可以了。

    public static void main(String[] args)throws Exception {
        Thread t1 = new Thread(()->{
            int sum = 0;
            for(int i=0;i<10;i++){
                sum+=i;
            }
            LockSupport.park();
            System.out.println(sum);
        });
        t1.start();
        Thread.sleep(1000);//等待t1中的求和计算完成，当我们注释此行时，则会导致unpark方法先于park方法。但是程序依然能够正确执行。
        LockSupport.unpark(t1);
    }

注意：我们在调用Object的notify和wait方法时如果notify先于wait方法那么程序将会无限制的等下去，而如果LockSupport的unpark方法先于park方法则不会无限制的等待。程序依然能够正确的执行

LockSupport比Object的wait/notify有两大优势：

LockSupport不需要在同步代码块里。所以线程间也不需要维护一个共享的同步对象了，实现了线程间的解耦。
unpark函数可以先于park调用，所以不需要担心线程间的执行的先后顺序。

LockSupport在ThreadPoolExecutor中的应用1

1、首先我们创建一个线程池并执行FutureTask任务。

public static void main(String[] args)throws Exception {
        ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(1000);
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5,5,1000, TimeUnit.SECONDS,queue);
        Future<String> future = poolExecutor.submit(()->{//此任务实现了Callable接口
            TimeUnit.SECONDS.sleep(5);
            return "hello";
        });
        String result = future.get();//同步阻塞等待线程池的执行结果。
        System.out.println(result);
    }

2、future.get()是如何阻塞当前线程并获取线程池的执行结果？

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);//查看源码其实是创建了一个FutureTask对象
    execute(ftask);
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

通过上面的代码我们可以看出，其实当我们调用future.get()方法其实是调用FutureTask的get()方法。

//判断当前任务是否执行完毕，如果执行完毕直接返回任务结果，否则进入awaitDone方法阻塞等待。
public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}

关于FutureTask源码分析具体可以查看https://my.oschina.net/cqqcqqok/blog/1982375

private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);//调用parkNanos方法阻塞线程
            }
            else
                LockSupport.park(this);//调用park方法组塞住当前线程。
        }
    }

3、从前面的分析我们知道了当调用future.get()方法是如何阻塞线程，那么当任务执行完成之后如何唤醒线程的呢？

由于我们提交的任务已经被封装为了FutureTask对象，那么任务的执行就是FutureTask的run方法执行。

    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //c.call()就是执行我们提交的任务，任务执行完后调用了set方法，进入set方法发现set方法调用了finishCompletion方法
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        finishCompletion();
    }
}

    private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);//通过cas操作将所有等待的线程拿出来，然后便使用LockSupport的unpark唤醒每个线程。
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }
        done();
        callable = null;        // to reduce footprint
    }

LockSupport在ThreadPoolExecutor中的应用2

您有没有这样的一个疑问，当线程池里没有任务时，线程池里的线程在干嘛呢？如果读过线程池源码（https://my.oschina.net/cqqcqqok/blog/2049249 ）那么你一定知道，在线程getTask()获取任务的时候，如果没有新的任务那么线程会调用队列的take方法阻塞等待新任务。那队列的take方法是不是也跟Future的get方法实现一样呢？我们以ArrayBlockingQueue为例，来看一下源码实现。

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            notEmpty.await();//此处调用了Condition的await方法
        return dequeue();
    } finally {
        lock.unlock();
    }
}

继续看源码

public final void await() throws InterruptedException {
    if (Thread.interrupted()) throw new InterruptedException();
    Node node = addConditionWaiter();
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);//调用了LockSupport的park方法
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

LockSupport的实现

park和unpark简单介绍

LockSupport其实是一个简单的代理类，它里面的代码都是使用Unsafe类里面的native方法，这里可以简单看看sun.misc.Unsafe 本文主要学习里面的park和unpark方法。

在Unsafe里面，park和unpark分别如下定义：

//isAbsolute代表传入的time是绝对时间还是相对时间
public native void park(boolean isAbsolute, long time);
public native void unpark(Object thread);

unpark函数为线程提供“许可(permit)”，线程调用park函数则等待“许可”。这个有点像信号量，但是这个“许可”是不能叠加的，“许可”是一次性的。可以理解为设置一个变量0，1之间的切换。

如果线程B连续调用了多次unpark函数，当线程A调用park函数就使用掉这个“许可”，如果线程A第二次调用park，则进入等待状态。

注意，unpark函数可以先于park调用。比如线程B调用unpark函数，给线程A发了一个“许可”，那么当线程A调用park时，它发现已经有“许可”了，那么它会马上再继续运行，也就是不会阻塞。

而如果线程A处于等待许可状态，再次调用park，则会永远等待下去，调用unpark也无法唤醒。

下面先看LockSupport里面的park和unpark定义：

public static void park(Object blocker) {
    //获取当前运行线程
    Thread t = Thread.currentThread();
    //设置t中的parkBlockerOffset（挂起线程对象的偏移地址）的值为blocker
    //这个字段可以理解为专门为LockSupport而设计的，它被用来记录线程是被谁堵塞的，当程序出现问题时候，通过线程监控分析工具可以找出问题所在。注释说该对象被LockSupport的getBlocker和setBlocker来获取和设置，且都是通过地址偏移量方式获取和修改的。由于这个变量LockSupport提供了park(Object parkblocker)方法。
    setBlocker(t, blocker);
    //阻塞线程
    UNSAFE.park(false, 0L);
    //线程被释放，则将parkBlockerOffset设为null
    setBlocker(t, null);
}

public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

park和unpark的c++实现

首先，包含park和unpark的头函数在：http://hg.openjdk.java.net/jdk8u/jdk8u40/hotspot/file/68577993c7db/src/share/vm/runtime/park.hpp 而其具体实现函数则在：http://hg.openjdk.java.net/jdk8u/jdk8u40/hotspot/file/95e9083cf4a7/src/os/solaris/vm/os_solaris.cpp

void Parker::park(bool isAbsolute, jlong time) {
 //_counter字段，就是用来记录“许可”的。
 //先尝试能否直接拿到“许可”，即_counter>0时，如果成功，则把_counter设置为0
  if (_counter > 0) {
      _counter = 0 ;
      OrderAccess::fence();
      //直接返回
      return ;
  }
  //获取当前线程
  Thread* thread = Thread::current();
  assert(thread->is_Java_thread(), "Must be JavaThread");
  JavaThread *jt = (JavaThread *)thread;
  //如果中途已经是interrupt了，那么立刻返回，不阻塞
  if (Thread::is_interrupted(thread, false)) {
    return;
  }
  //记录当前绝对时间戳
  timespec absTime;
  //如果park的超时时间已到，则返回
  if (time < 0) { // don't wait at all
    return;
  }
  if (time > 0) {
  //更换时间戳
    unpackTime(&absTime, isAbsolute, time);
  }
   //进入安全点，利用该thread构造一个ThreadBlockInVM。
  ThreadBlockInVM tbivm(jt);
  if (Thread::is_interrupted(thread, false) ||
      os::Solaris::mutex_trylock(_mutex) != 0) {
    return;
  }
  //记录等待状态
  int status ;
  //中途再次给予了许可，则直接返回不等带。
  if (_counter > 0)  { // no wait needed
    _counter = 0;
    status = os::Solaris::mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
    OrderAccess::fence();
    return;
  }
#ifdef ASSERT
  sigset_t oldsigs;
  sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals();
  thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
#endif
  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
  jt->set_suspend_equivalent();
#if defined(__sparc) && defined(COMPILER2)
  if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
#endif
  if (time == 0) {
    //等待时间为0时，直接等待
    status = os::Solaris::cond_wait (_cond, _mutex) ;
  } else {
    //time不为0，则继续等待。
    status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);
  }
   assert_status(status == 0 || status == EINTR ||
                status == ETIME || status == ETIMEDOUT,
                status, "cond_timedwait");
#ifdef ASSERT
  thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
#endif
  _counter = 0 ;
  status = os::Solaris::mutex_unlock(_mutex);
  assert_status(status == 0, status, "mutex_unlock") ;
  if (jt->handle_special_suspend_equivalent_condition()) {
    jt->java_suspend_self();
  }
  OrderAccess::fence();
}

void Parker::unpark() {
//定义两个变量，staus用于判断是否获取锁
  int s, status ;
  //获取锁
  status = os::Solaris::mutex_lock (_mutex) ;
  //判断是否成功
  assert (status == 0, "invariant") ;
  //存储原先变量_counter
  s = _counter;
  //把_counter设为1
  _counter = 1;
  //释放锁
  status = os::Solaris::mutex_unlock (_mutex) ;
  assert (status == 0, "invariant") ;
  if (s < 1) {
  //如果原先_counter信号量小于1，即为0，则进行signal操作，唤醒操作
    status = os::Solaris::cond_signal (_cond) ;
    assert (status == 0, "invariant") ;
  }
}

参考地址

转载于:https://my.oschina.net/cqqcqqok/blog/2049659