LockSupport 的简单介绍和AQS的简单说明

LockSupport 的简单介绍和AQS的简单说明

LockSupport 是AQS 底层阻塞线程的常用方式，LockSupport 底层使用的是Unsafe

public static void park(Object blocker); // 暂停当前线程
public static void parkNanos(Object blocker, long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(Object blocker, long deadline); // 暂停当前线程，直到某个时间
public static void park(); // 无期限暂停当前线程
public static void parkNanos(long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(long deadline); // 暂停当前线程，直到某个时间
public static void unpark(Thread thread); // 恢复指定线程
public static Object getBlocker(Thread t);

package com.study.springenvironment.locksupport;

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

public class LockSupportTest {
    private static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(()->{
            System.out.println("start park lock");
            LockSupport.park();//阻塞当前线程，如果之前有调用过LockSupport.unpark(thread)（多次也只算一次）;，这里会直接放行
            System.out.println("resume park lock");

            System.out.println("start park object lock");
            LockSupport.park(object);
            System.out.println("resume park object lock");

        });
        thread.start();
        TimeUnit.MINUTES.sleep(1);
        System.out.println("main park over");
        LockSupport.unpark(thread);
//        thread.interrupt();//中断也会释放,然后在park 会没有效果直接返回，并且不会抛出异常，需要自己判断
        TimeUnit.MINUTES.sleep(1);
        System.out.println("main park object over");
        LockSupport.unpark(thread);

    }
}

线程阻塞jstack 效果
park()的效果

park(obj)的效果

Unsafe 的简单使用（CAS 原子操作）

package com.study.springenvironment.unsafe;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class UnsafeTest {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
//        Unsafe unsafe1 = Unsafe.getUnsafe();//这种方式是获取不到的，被限制了
        Field feild = Unsafe.class.getDeclaredField("theUnsafe");//theUnsafe 在类加载的时候就已经被创建加载了
        // 所以我们可以通过反射去获取这个属性
        feild.setAccessible(true);
        Unsafe unsafe = (Unsafe) feild.get(null);
        User user = new User();
        Field agefile = user.getClass().getDeclaredField("age");
        long ageFileOffset = unsafe.objectFieldOffset(agefile);//获取User 中 age属性的内存偏移量
        boolean flag = unsafe.compareAndSwapInt(user, ageFileOffset, 0, 12);//比较并交换
        System.out.println("是否设置成功："+ flag +"-内存偏移量："+ageFileOffset);
        System.out.println(user);


    }
}

package com.study.springenvironment.unsafe;

public class User {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                '}';
    }
}

AQS 的简单说明
AbstractQueuedSynchronizer 抽象同步队列简称 AQS ，它是实现同步器的 础组件，并发包中锁的底层就是使用AQS 实现的 。

AQS 是一个 FIFO 的双向队列，通过head 和 tail 记录队首和队尾，队列元素的类型为 Node，Node 记录当前线程的状态。
Node 中的 thread 变量用来存放进入 AQS队列里面的线程， waitStatu 记录当前线状态，SHARED （获取共享资源时被阻塞）， EXCLUSIVE （获取独占资源时被挂起后放入AQS 队列），CANCELLED （线程被取消了）、SIGNAL（ 线程需要被唤醒）、 ONDITION （线程在条件队列里面等待〉、 PROPAGATE （释放共享资源时需要通知其他节点〕；AQS 中维持一个状态信息变量state，可以通过getState setState，compareAndSetState 改变state ，实现相关锁信息的保存。
Reentran tLock中用其保存当前线程获取锁的的可重入次数
ReentrantReadWriteLock 来说 state 16位表示读状态，也就是获取该读锁的次数，低 16 位表示获取到写锁的线程的可重入次数；

自定义同步器 继承 重写相关的AQS 方法即可

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。

自定义同步器要么是独占方法，要么是共享方式，只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但 AQS 也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

AQS 注释中一个简单案例

import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Mutex implements Lock, java.io.Serializable {

    // Our internal helper class
    private static class Sync extends AbstractQueuedSynchronizer {
        // Reports whether in locked state
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        // Acquires the lock if state is zero
        public boolean tryAcquire(int acquires) {
            assert acquires == 1; // Otherwise unused
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // Releases the lock by setting state to zero
        protected boolean tryRelease(int releases) {
            assert releases == 1; // Otherwise unused
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        // Provides a Condition
        Condition newCondition() {
            return new ConditionObject();
        }

        // Deserializes properly
        private void readObject(ObjectInputStream s)
                throws IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }
    private final Sync sync = new Sync();
    public void lock()                { sync.acquire(1); }
    public boolean tryLock()          { return sync.tryAcquire(1); }
    public void unlock()              { sync.release(1); }
    public Condition newCondition()   { return sync.newCondition(); }
    public boolean isLocked()         { return sync.isHeldExclusively(); }
    public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    public void lockInterruptibly() throws InterruptedException {
      sync.acquireInterruptibly(1);
    }
    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
      return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
}