简单看看LockSupport和AQS

package com.example.demo.study;
import java.util.concurrent.locks.LockSupport;

public class Study0130 {

    public static void main(String[] args) {
        System.out.println("main begin");                
        LockSupport.park();       
        System.out.println("main end");
    }
}

package com.example.demo.study;
import java.util.concurrent.locks.LockSupport;

public class Study0130 {

    public static void main(String[] args) {
        //这里就是给当前线程授权了，当前线程可以随便跑，碰到park都不会挂
        LockSupport.unpark(Thread.currentThread());
        
        System.out.println("main begin");
        LockSupport.park();
        System.out.println("main end");

    }
}

package com.example.demo.study;

import java.util.concurrent.locks.LockSupport;

public class Study0130 {

    public static void main(String[] args) {

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1 start");
                //线程1会阻塞
                LockSupport.park();
                System.out.println("thread1 end");
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread2 start");
                //给线程1授权
                LockSupport.unpark(thread1);
                System.out.println("thread2 end");
            }
        });
        thread1.start();
        thread2.start();
    }
}

//字段
//指向链表的头节点
private transient volatile Node head;
//指向链表的尾节点
private transient volatile Node tail;
//状态信息，这个字段在每个实现类中表达的意思都不一样，比如在ReentrantLock中表示可重入的次数，
//在Semaphore中表示可用信号的个数等等用法
private volatile int state;

//获取Unsafe对象，前面用过的，还记得说过为什么可以使用getUnsafe的方式获取对象，而我们自己的类中却不能用这种方式
private static final Unsafe unsafe = Unsafe.getUnsafe();

//下面的这几个属性就是获取AQS类中的字段的偏移量，在前几篇的博客已经说过了这偏移量有什么用
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

//方法
//这几个方法都是尝试获取锁
public final void acquire(int arg) {}//独占方式
protected boolean tryAcquire(int arg) {}
public final void acquireShared(int arg) {}//共享方式
public final void acquireInterruptibly(int arg){}//独占方式
public final void acquireSharedInterruptibly(int arg){}//共享方式

//这几个方法都是试图释放锁
public final boolean release(int arg) {}//独占方式
public final boolean releaseShared(int arg) {}//共享方式
protected boolean tryRelease(int arg) {}
protected boolean tryReleaseShared(int arg) {}

public final void acquire(int arg) {
     //1.tryAcquire方法没有实现，这个方法主要是留给具体子类去实现，通过具体场景去用CAS修改state的值，修改成功返回true，否则false
     //2.如果修改state的值失败，就会到第二个条件这里，这里会将当前线程封装成一个Node.EXCLUSIVE类型的节点，然后存到链表尾端，最后在acquireQueued方法内部会调用
　　　　　　LockSupport.park(this);方法阻塞线程
     //3.调用selfInterrupt方法中断当前的线程，为什么要这样呢？因为一个线程在阻塞队列中等待，这时通过某种方式把它中断了，不会立即看到效果的，
　　　//只会在这个线程获取资源后再调用selfInterrupt方法将中断补上

    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
//中断当前线程
static void selfInterrupt() {
    Thread.currentThread().interrupt();
}

public final boolean release(int arg) {
    //tryRelease方法没有实现，子类根据具体场景是实现，其实就是修改state的值
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
        //这个方法在下面，里面会调用LockSupport.unpark(s.thread)方法激活阻塞队列中的一个节点的线程，而这个激活的线程会通过tryAcquire尝试当前的state是否满足自己的需要
　　　　　//满足条件的话就运行，不满足的话还是会挂起
            unparkSuccessor(h);
        return true;
    }
    return false;
}

 public final void acquireShared(int arg) {
    //tryAcquireShared方法也是没有实现，留给具体子类会根据实际情况实现，会设置state的值，设置成功就直接返回
    //设置失败的话就进入到doAcquireShared方法中，这个方法里会将当前线程封装为Node.SHARED类型的节点，然后放到阻塞队列的最后面
　　 //使用LockSupport.park(this)方法挂起自己
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

public final boolean releaseShared(int arg) {
    //tryReleaseShared方法由子类实现，修改state的值，尝试释放资源
    //释放资源成功的话，然后使用LockSupport.unpark(thread)去唤醒阻塞队列中的一个线程
    //激活的线程会使用tryReleaseShared查看当前state的值是否符合自己的需要，满足则激活，向下运行，否则还是被放在AQS阻塞队列中挂起
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}