public class SpinLock { 。

  。

  private AtomicReference<Thread> sign =new AtomicReference<>(),

  public void lock(){     Thread current = Thread.currentThread();     while(!sign .compareAndSet(null, current)){     }   } 。

  public void unlock (){     Thread current = Thread.currentThread();     sign .compareAndSet(current, null);   } } 。

package com.alipay.titan.dcc.dal.entity,

  。

import java.util.concurrent.atomic.AtomicInteger,

public class TicketLock {     private AtomicInteger                     serviceNum = new AtomicInteger();     private AtomicInteger                     ticketNum  = new AtomicInteger();     private static final ThreadLocal<Integer> LOCAL      = new ThreadLocal<Integer>(),

    public void lock() {         int myticket = ticketNum.getAndIncrement();         LOCAL.set(myticket);         while (myticket != serviceNum.get()) {         } 。

    } 。

    public void unlock() {         int myticket = LOCAL.get();         serviceNum.compareAndSet(myticket, myticket + 1);     } } 。

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater,

  。

public class CLHLock {     public static class CLHNode {         private volatile boolean isLocked = true;     } 。

    @SuppressWarnings("unused")     private volatile CLHNode                                           tail;     private static final ThreadLocal<CLHNode>                          LOCAL   = new ThreadLocal<CLHNode>();     private static final AtomicReferenceFieldUpdater<CLHLock, CLHNode> UPDATER = AtomicReferenceFieldUpdater.newUpdater(CLHLock.class,                                                                                    CLHNode.class, "tail"),

    public void lock() {         CLHNode node = new CLHNode();         LOCAL.set(node);         CLHNode preNode = UPDATER.getAndSet(this, node);         if (preNode != null) {             while (preNode.isLocked) {             }             preNode = null;             LOCAL.set(node);         }     } 。

    public void unlock() {         CLHNode node = LOCAL.get();         if (!UPDATER.compareAndSet(this, node, null)) {             node.isLocked = false;         }         node = null;     } } 。

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater,

  。

public class MCSLock {     public static class MCSNode {         volatile MCSNode next;         volatile boolean isLocked = true;     } 。

    private static final ThreadLocal<MCSNode>                          NODE    = new ThreadLocal<MCSNode>();     @SuppressWarnings("unused")     private volatile MCSNode                                           queue;     private static final AtomicReferenceFieldUpdater<MCSLock, MCSNode> UPDATER = AtomicReferenceFieldUpdater.newUpdater(MCSLock.class,                                                                                    MCSNode.class, "queue"),

    public void lock() {         MCSNode currentNode = new MCSNode();         NODE.set(currentNode);         MCSNode preNode = UPDATER.getAndSet(this, currentNode);         if (preNode != null) {             preNode.next = currentNode;             while (currentNode.isLocked) { 。

            }         }     } 。

    public void unlock() {         MCSNode currentNode = NODE.get();         if (currentNode.next == null) {             if (UPDATER.compareAndSet(this, currentNode, null)) { 。

            } else {                 while (currentNode.next == null) {                 }             }         } else {             currentNode.next.isLocked = false;             currentNode.next = null;         }     } } 。