Java中的锁

public class LockCase {
    private Lock lock = new ReentrantLock();

    public void method() {
        lock.lock();
        try {
            // manipulate protected state
        } finally {
            lock.unlock();
        }
    }
}

static final class Node {
    // 标记⼀个结点（对应的线程）在共享模式下等待
    static final Node SHARED = new Node();
   // 标记⼀个结点（对应的线程）在独占模式下等待
    static final Node EXCLUSIVE = null;
   // waitStatus的值，表示该结点（对应的线程）已被取消
    static final int CANCELLED =  1;
    // waitStatus的值，表示后继结点（对应的线程）需要被唤醒
static final int SIGNAL    = -1;
    //waitStatus的值，表示该结点（对应的线程）在等待某⼀条件
    static final int CONDITION = -2;
    //该值表示有资源可⽤，新head结点需要继续唤醒后继结点（共享模式下，多线程并行）
    static final int PROPAGATE = -3;
  // 等待状态，取值范围，-3，-2，-1，0，1
    volatile int waitStatus;

    volatile Node prev;//前驱节点
    volatile Node next;//后继节点
    volatile Thread thread;//节点对应线程
  //等待队列中的后继节点，如果当前节点是共享的，那么这个字段是一个SHARED常量，也就是说节  //点类型和等待队列中的后继节点共用一个字段。
    Node nextWaiter;
  //判断共享模式的方法
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

   //返回上一个节点，如果为空抛空指针
    final Node predecessor() {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    //建立初始头部或共享标记
    Node() {}

    //addWaiter使用的构造函数
    Node(Node nextWaiter) {
        this.nextWaiter = nextWaiter;
        THREAD.set(this, Thread.currentThread());
    }

    //addConditionWaiter使用的构造函数
    Node(int waitStatus) {
        WAITSTATUS.set(this, waitStatus);
        THREAD.set(this, Thread.currentThread());
    }

    //使用CAS设置 waitStatus字段
    final boolean compareAndSetWaitStatus(int expect, int update) {
        return WAITSTATUS.compareAndSet(this, expect, update);
    }

    //使用CAS设置next字段
    final boolean compareAndSetNext(Node expect, Node update) {
        return NEXT.compareAndSet(this, expect, update);
    }
//忽略其他代码
  }

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
private Node addWaiter(Node mode) {
//生成该线程都Node节点
        Node node = new Node(Thread.currentThread(), mode);
        // 快速尝试在队列尾部添加
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
//使用CAS尝试添加，成功则返回
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
//如果等待队列为空或上述CAS失败，则自旋CAS插入
        enq(node);
        return node;
    }
 
 //自旋CAS插入等待队列
private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
 
 
  final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
//自旋
            for (;;) {
//获取上一个节点
                final Node p = node.predecessor();
// 如果node的前驱结点p是head，表示node是第⼆个结点，就可以尝试去获取资源了
                if (p == head && tryAcquire(arg)) {
// 拿到资源后，将head指向该结点。
// 所以head所指的结点，就是当前获取到资源的那个结点或null。
                    setHead(node);
//节点资源获取成功，将之前head设置引用null，帮助GC回收
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
// 如果⾃⼰可以休息了，就进⼊waiting状态，直到被unpark()
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
//设置当前线程的初始状态为0
        node.compareAndSetWaitStatus(ws, 0);
  
    Node s = node.next;//找到head下一个需要唤醒的节点，   
 if (s == null || s.waitStatus > 0) {//如果下一个节点被取消了（>0），则从tail往前找
        s = null;
        for (Node p = tail; p != node && p != null; p = p.prev)
            if (p.waitStatus <= 0)
                s = p;
    }
    if (s != null)
//unpark()唤醒线程
        LockSupport.unpark(s.thread);
}

public class ReEntrantLock {
    private Lock lock = new ReentrantLock();

    public void m() {
        lock.lock();
        lock.lock();
        try {
            // ... method body
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }
}

@ReservedStackAccess
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

public class ReentrantLock2 extends ReentrantLock {
    /***
     * @函数功能：构造函数
     * @param fair: 公平性
     * @return：
     */
    public ReentrantLock2(boolean fair) {
        super(fair);
    }

    @Override
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        return super.getWaitingThreads(condition);
    }

    @Override
    protected Collection<Thread> getQueuedThreads() {
        ArrayList<Thread> list = new ArrayList<>(super.getQueuedThreads());
        Collections.reverse(list);
        return list;
    }
}

@Slf4j
public class FairAndUnfair {
    private static ReentrantLock fair = new ReentrantLock2(true);
    private static ReentrantLock unfair = new ReentrantLock2(false);

    public static void main(String[] args) {
        log.info("公平锁测试");
//        log.info("非公平锁测试");
        for (int i = 0; i < 5; i++) {
            Thread thread = new Job(fair);
//            Thread thread = new Job(unfair);
            thread.setName("" + i);
            thread.start();
        }
     }

    private static class Job extends Thread {
        private ReentrantLock lock;

        public Job(ReentrantLock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            for (int i = 0; i < 2; i++) {
                lock.lock();
                ArrayList<Thread> list= (ArrayList) ((ReentrantLock2) lock).getQueuedThreads();
                try {
    Thread.sleep(500);
                    List<String> tName=new LinkedList<>();
                    list.forEach(thread -> tName.add(thread.getName()));
                    log.info("Lock by [{}], Waiting by [{}}",Thread.currentThread().getName(), tName.toString());
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}

@Slf4j
public class PerformanceTest {
    private static volatile int count;
    //    private static Lock lock = new ReentrantLock2(false);    //非公平锁
    private final static Lock lock = new ReentrantLock2(true);   //公平锁

    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
//        String lockType = "非公平锁";
//        String lockType = "公平锁";
        String lockType = "synchronized";
        long start = System.currentTimeMillis();
        //该构造方法的最后一个线程达到栏栅时，会执行Time线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(128, new Time(lockType, start));
        for (int i = 0; i < 128; i++) {
            Thread thread = new Thread(new Job(lock, cyclicBarrier)) {
            };
            thread.start();
        }
    }

    private static class Job implements Runnable {
        private Lock lock;
        private CyclicBarrier cyclicBarrier;

        public Job(Lock lock, CyclicBarrier cyclicBarrier) {
            this.lock = lock;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
//                lock.lock();
//                try {
//                    count++;
//                } finally {
//                    lock.unlock();
//                }
                synchronized (lock) {
                    count++;
                }
            }
            try {
                cyclicBarrier.await();  //计数器+1，直到10个线程都到达
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Time implements Runnable {
        private long start;
        private String lockType;

        public Time(String lockType, long start) {
            this.start = start;
            this.lockType = lockType;
        }

        @Override
        public void run() {
            log.info("count:{},{}耗时:{}毫秒", count, lockType, (System.currentTimeMillis() - start));

        }
    }
}

public class ReadWriteLockCase {
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static final Object get(String key) {
        r.lock();
        try {
            return null;

        } finally {
            r.unlock();
        }
    }

    public static final Object clean() {
        w.lock();
        try {
            return null;

        } finally {
            w.unlock();
        }
    }
}