JUC之LockSupport---------多线程与高并发

前言

LockSupport的意思就是有两个方法park()和unpark(thread)控制线程的阻塞和唤醒。park()是说当前线程执行该方法后进入阻塞状态，须要再调用unpark(thread)解除阻塞限制。若是unpark(thread)先于park()执行，则该次park()不起做用不会使得线程阻塞。
咱们能够使用它来阻塞和唤醒线程,功能和wait,notify有些类似,可是LockSupport比起wait,notify功能更强大。

• wait和notify都是Object中的方法,在调用这两个方法前必须先得到锁对象，这限制了其使用场合:只能在同步代码块中。
• 当对象的等待队列中有多个线程时，notify只能随机选择一个线程唤醒，没法唤醒指定的线程。

package basic.aqs.LockSupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class TestLockSupport {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i==5)
                    LockSupport.park();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        t.start();
        try {
            TimeUnit.SECONDS.sleep(8);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("8s sleep done");
        LockSupport.unpark(t);

    }
}

package basic.aqs.LockSupport;

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

/**
 * 官方给的LockSupport示例
 * 实现的是一个先进先出的线程等待队列
 * 使用park和unpark控制线程的阻塞和唤醒
 */
class FIFOMutex {
    private final AtomicBoolean locked = new AtomicBoolean(false);
    private final Queue<Thread> waiters
            = new ConcurrentLinkedQueue<>();

    public void lock() {
        boolean wasInterrupted = false;
        // publish current thread for unparkers
        waiters.add(Thread.currentThread());

        // Block while not first in queue or cannot acquire lock
        while (waiters.peek() != Thread.currentThread() ||
                !locked.compareAndSet(false, true)) {
            LockSupport.park(this);
            // ignore interrupts while waiting
            if (Thread.interrupted())
                wasInterrupted = true;
        }

        waiters.remove();
        // ensure correct interrupt status on return
        if (wasInterrupted)
            Thread.currentThread().interrupt();
    }

    public void unlock() {
        locked.set(false);
        LockSupport.unpark(waiters.peek());
    }

    static {
        // Reduce the risk of "lost unpark" due to classloading
        Class<?> ensureLoaded = LockSupport.class;
    }
}

结尾

本文到这里就结束了，感谢看到最后的朋友，都看到最后了，点个赞再走啊，若有不对之处还请多多指正。
重要的事情说三遍: 关注我 关注我 关注我 !!!!
关注我带你解锁更多精彩内容