在进入同步块之前JVM会在当前线程的"栈帧中申请并创建锁记录的空间,接着把对象头的标识符写到锁记录中"
然后使用CAS将当前线程的锁记录的地址(指针)替换掉锁对应的对象中的标识符,CAS操作成功表示获得锁CAS
操作失败尝试使用自旋(就是在当前进程并且执行代码块的线程内的时间片下空循环烧CPU反正现代计算机大多都是多核处理器在短时间内不会太影响其他任务处理)来获取锁

要想撤销轻量级锁(解锁) 对象头中标识符必须设回为Displaced Mark Word
因此使用CAS操作将Displaced Mark Word替换回到对象头里面,成功那么撤销成功,失败说明有其它线程还在竞争此对象的锁这个时候
锁就会立即膨胀成重量级锁,后续的加锁和解锁都按照重量级锁的操作来

当只有一个线程或者多个线程中最先执行到同步块的时候 这个时候测试完没有偏向锁立即设置完对应的标识记录和锁记录就开始执行同步代码了,
假如下次再进入并且锁没有升级那么仅仅简单测试通过又继续执行了 在这最开始到结束全程没有各种加锁操作甚至连CAS都很有可能没有(是有可能有CASC操作的这涉及到偏向锁的撤销机制)
相比同步操作消耗很少  因此很划算的

当有多个线程竞争锁的时候 这个时候系统检测到了并且达到了锁升级的约束条件那么就会立即执行升级操作即便获得执行条件正在的线程
(当然必须等执行线程中的某个原子操作或者若干原子操作组成的原语)也要对锁记录进行升级然后才开始升级

优点: 把整个同步都消除掉，连CAS操作都不去做了，优于轻量级锁
缺点: 如果程序中大多数的锁都总是被多个不同的线程访问，那偏向锁就是多余的

偏向锁使用了一种等到竞争出现才释放锁的机制,所以当其他线程尝试竞争偏向锁时,持有偏向锁的线程才会释放锁。偏向锁的撤销,
需要等待全局安全点(在这个时间点上没有正在执行的字节码)。它会首先暂停拥有偏向锁的线程,然后检查持有偏向锁的线程是否活着,
如果线程不处于活动状态,则将对象头设置成无锁状态;如果线程仍然活着,拥有偏向锁的栈会被执行,遍历偏向对象的锁记录,
栈中的锁记录和对象头的mark word要么重新偏向于其它线程,要么恢复到无锁或者标记对象不适合作为偏向锁,最后唤醒暂停的线程。

可以考虑通过JVM参数关闭偏向锁
-XX:-UseBiasedLocking=false

synchronized是通过对象内部的一个叫做监视器锁
（monitor）来实现的，监视器锁本身依赖底层的操作系统的 Mutex Lock来实现。操
作系统实现线程的切换需要从用户态切换到核心态，成本非常高。这种依赖于操作系
统 Mutex Lock来实现的锁称为重量级锁。为了优化synchonized，引入了轻量级锁，
偏向锁

避免了线程切换的开销。挂起线程和恢复线程的操作都需要转入内核
态中完成，这些操作给Java虚拟机的并发性能带来了很大的压力。

占用处理器的时间，如果占用的时间很长，会白白消耗处理器资源，
而不会做任何有价值的工作，带来性能的浪费。因此自旋等待的时间必须有一定的限
度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起
线程。

0次，可以使用参数-XX:PreBlockSpin来自行更改。

自适应意味着自旋的时间不再是固定的，而是由前一次在同一个锁上的
自旋时间及锁的拥有者的状态来决定的。有了自适应自旋，随着程序运行时间的增长
及性能监控信息的不断完善，虚拟机对程序锁的状态预测就会越来越精准。

首先主观判断是需要写的操作高于读操作，因为你经常去写 假如你使用乐观锁那样烧cpu的方式进行那么非常浪费资源(计算机世界中CPU也是资源,甚至时间都是),
然后线程申请锁的时候要么被阻塞要么拿到锁(加锁成功) 拿到锁的继续执行没拿到的立即阻塞进入阻塞队列中等待 等待唤醒的时机
最后说下 悲观锁中如果存在数据库操作不管你是关系数据库,非关系数据库或者NOSQL这些 要小心数据处理的操作 特别是多个服务器对应到一个数据库或者多个服务器对应多个数据库等
要么你的数据处理在某个时刻只会运行在一台服务器上要么数据运行到多台服务器的时候在某个唯一服务器上进行唯一运行检验

行锁、表锁、读锁、写锁

当以这种模式运行时  我们预估大多数都能够实现  那么就以烧CPU轮询方式进行
在 当前运行的进程内的并且运行的线程一直轮询  只要不被阻塞或者其他什么引起线程不执行了就一直轮训知道成功为止
稍微提一下  必须满足运行的当前进程被操作系统调度进入CPU运行 因为操作系统内核对所有进程有一套调度算法一个进程正在执行中即便没有执行完也有可能被暂停,如时间片已经用完

Java 中java.util.concurrent.atomic包下面的原子变量使用了乐观锁的一种 CAS 实现方式
CAS，比较并替换，比较当前值（主内存中的值），与预期值（当前线程中的值，主内存中值的一份拷贝）是否一样，一样则更新，否则继续进行CAS操作

般是在数据表中加上一个数据版本号 version 字段，表示数据被修改的次数。
当数据被修改时，version 值会 +1。当线程 A 要更新数据时，在读取数据的同时也会读取 version 值，
在提交更新时，若刚才读取到的 version 值与当前数据库中的 version 值相等时才更新，否则重试更新操作，直到更新成功

它内部细分了若干个小的 HashMap，称之为段
(Segment)。 默认情况下一个 ConcurrentHashMap 被进一步细分为 16 个段，既
就是锁的并发度。如果需要在 ConcurrentHashMap 添加一项key-value，并不是将
整个 HashMap 加锁，而是首先根据 hashcode 得到该key-value应该存放在哪个段
中，然后对该段加锁，并完成 put 操作。在多线程环境中，如果多个线程同时进行
put操作，只要被加入的key-value不存放在同一个段中，则线程间可以做到真正的并
行。

：ConcurrentHashMap 是一个 Segment 数组， Segment 通过继承
ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这
样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全

通过ReentrantReadWriteLock类来实现。为了提高性能， Java
提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如果没有写
锁的情况下，读是无阻塞的，在一定程度上提高了程序的执行效率。 读写锁分为读锁
和写锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的

/* 创建一个读写锁* 它是一个读写融为一体的锁，在使用的时候，需要转换*/
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
/*获取读锁和释放读锁*/
//获取读锁
rwLock.readLock().lock();
// 释放读锁
rwLock.readLock().unlock();
/*获取写锁和释放写锁*/
//创建一个写锁
rwLock.writeLock().lock();
//写锁 释放
rwLock.writeLock().unlock();

处理器（包括 Intel 和 Sparc 处理器）使用的最通用的方法是实现名为比较并转换或CAS的原语，在 Intel 处理器中，
比较并交换通过指令的 cmpxchg系列实现。CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。
如果内存位置的值V与预期原值A相匹配，那么处理器会自动将该位置值V更新为新值B，否则，处理器不做任何操作，整个操作保证了原子性，即在对比V==A后、
设置V=B之前不会有其他线程修改V的值。

/** 拿对象o在内存偏移offset处的对象与expected比较，如果相等，则设置o.offset=x并返回true，否则返回false */
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
/** 拿对象o在内存偏移offset处的long值与expected比较，如果相等则设置o.offset=x */
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);
/** 拿对象o在内存偏移offset处的int值与expected比较，如果相等则设置o.offset=x */
public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

/** 获取字段f的偏移量 */
public native long objectFieldOffset(Field f);
/** 获取静态field在对象中的偏移量 */
public native long staticFieldOffset(Field f);                                                  

long stateOffset = unsafe.objectFieldOffset
                (AbstractQueuedSynchronizer.class.getDeclaredField("state"));

// CAS方式修改state字段的值
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

public final int getAndAddInt(Object o, long offset, int delta) {
	int v;
    do {
    	// 获取内存中的值
         v = getIntVolatile(o, offset);
     } while (!compareAndSwapInt(o, offset, v, v + delta));
     return v;
 }
 public final long getAndAddLong(Object o, long offset, long delta)
 public final int getAndSetInt(Object o, long offset, int newValue)
 public final long getAndSetLong(Object o, long offset, long newValue)
 public final Object getAndSetObject(Object o, long offset, Object newValue)

此外，Unsafe类还基于这几个native方法封装了几个给atomic原子类调用的方法：
拿getAndAddInt分析，首先取内存中的值，然后执行CAS操作，如果成功则返回修改前的值；
如果取完内存值后执行CAS失败，比如被其他线程修改了值，则重新取内存中的值，继续CAS，直到成功，
如果竞争比较激烈，可能会循环次数过多；这里可以引申出乐观锁悲观锁的含义，
比如某个线程要对变量进行add操作，悲观锁认为期间一定会有其他线程修改变量，于是会在整个修改期间加锁，比如synchronized；
而乐观锁认为不会有其他线程修改变量，getAndAddInt正是乐观锁，用CAS代替锁，如果出现竞争，则用自旋的方式等待；

// AtomicInteger可以理解为在并发场景下基于CAS乐观锁实现了int共享变量更新的线程安全，常见方法如下
public final int getAndSet(int newValue) {
    return unsafe.getAndSetInt(this, valueOffset, newValue);
}

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

public final int getAndDecrement() {
    return unsafe.getAndAddInt(this, valueOffset, -1);
}

如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。
如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，
这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。如图所示

waitStatus值为1时表示该线程节点已释放（超时、中断），已取消的节点不会再阻塞

waitStatus为-1时表示该线程的后续线程需要阻塞，即只要前置节点释放锁，就会通知标识为 SIGNAL 状态的后续节点的线程

waitStatus为-2时，表示该线程在condition队列中阻塞（Condition有使用）

waitStatus为-3时，表示该线程以及后续线程进行无条件传播（CountDownLatch中有使用）共享模式下， PROPAGATE 状态的线程处于可运行状态

因为只有前驱节点是head节点的节点才能被首先唤醒去进行同步状态的获取。当该节点获取到同步状态时，它会清除自己的值，将自己作为head节点，以便唤醒下一个节点

 除了同步队列之外，AQS中还存在Condition队列，这是一个单向队列。调用ConditionObject.await()方法，
 能够将当前线程封装成Node加入到Condition队列的末尾，然后将获取的同步状态释放（即修改同步状态的值，唤醒在同步队列中的线程）

public final void acquire(int arg) {
 if (!tryAcquire(arg) &&
 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
 selfInterrupt();
 }

 protected boolean tryAcquire(int arg) {
 throw new UnsupportedOperationException();
 }

/**
* 参数
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* 返回值
* @return the new node
*/
private Node addWaiter(Node mode) {
 //将当前线程以指定的模式创建节点node
 Node node = new Node(Thread.currentThread(), mode);
 // Try the fast path of enq; backup to full enq on failure
 // 获取当前同队列的尾节点
 Node pred = tail;
 //队列不为空，将新的node加入等待队列中
 if (pred != null) {
 node.prev = pred;
 //CAS方式将当前节点尾插入队列中
 if (compareAndSetTail(pred, node)) {
 pred.next = node;
 return node;
 }
 }
 //当队列为empty或者CAS失败时会调用enq方法处理
 enq(node);
 return node;
}

private Node enq(final Node node) {
    //不断自旋
     for (;;) {
        Node t = tail;
        //当前队列为empty
         if (t == null) { // Must initialize
         //完成队列初始化操作，头结点中不放数据，只是作为起始标记，lazy-load，在第一次用的时候new
             if (compareAndSetHead(new Node()))
                tail = head;
             } else {
                node.prev = t;
                //不断将当前节点使用CAS尾插入队列中直到成功为止
                 if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                 }
            }
         }
     }
 }

  final boolean acquireQueued ( final Node node, int arg)
        { //是否已获取锁的标志，默认为true 即为尚未
            boolean failed = true;
            try {
                 boolean interrupted = false;//等待中是否被中断过的标记
                 for (;;) {
                      final Node p = node.predecessor(); //获取前节点
                     // 如果当前节点已经成为头结点，尝试获取锁（tryAcquire）成功，然后返回 if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; 
                    help GC failed = false; return interrupted; } 
                     shouldParkAfterFailedAcquire根据对当前节点的前一个节点的状态进行判断，对当前节点做出不同的操作 
                      parkAndCheckInterrupt让线程进入等待状态，并检查当前线程是否被可以被中断 
                      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; }
                     } finally { //将当前节点设置为取消状态；取消状态设置为1 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;
 }

protected boolean tryRelease(int arg) {
 throw new UnsupportedOperationException();
 }

protected final boolean tryRelease(int releases) {
 if (!isHeldExclusively())
 throw new IllegalMonitorStateException();
 //减掉相应量的资源(state-=arg)
 int nextc = getState() - releases;
 //是否完全释放资源
 boolean free = exclusiveCount(nextc) == 0;
 if (free)
 setExclusiveOwnerThread(null);
 setState(nextc);
 return free;
 }

private void unparkSuccessor(Node node) {
 //当前线程所在的结点node
 int ws = node.waitStatus;
 //置零当前线程所在的结点状态，允许失败
 if (ws < 0)
 compareAndSetWaitStatus(node, ws, 0);
 //找到下一个需要唤醒的结点
 Node s = node.next;
 if (s == null || s.waitStatus > 0) {
 s = null;
 // 从后向前找
 for (Node t = tail; t != null && t != node; t = t.prev)
 //从这里可以看出，<=0的结点，都是还有效的结点
 if (t.waitStatus <= 0)
 s = t;
 }
 if (s != null)
 //唤醒
 LockSupport.unpark(s.thread);
}

public final void acquireShared(int arg) {
 if (tryAcquireShared(arg) < 0)
 doAcquireShared(arg);
}

 protected int tryAcquireShared(int arg) {
 throw new UnsupportedOperationException();
 }

private void doAcquireShared(int arg) {
 //加入队列尾部
 final Node node = addWaiter(Node.SHARED);
 //是否成功标志
 boolean failed = true;
 try {
 //等待过程中是否被中断过的标志
 boolean interrupted = false;
 for (;;) {
 final Node p = node.predecessor();//获取前驱节点
 if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
 int r = tryAcquireShared(arg);//尝试获取资源
 if (r >= 0) {//成功
 setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
 p.next = null; // help GC
 if (interrupted)//如果等待过程中被打断过，此时将中断补上。
 selfInterrupt();
 failed = false;
 return;
 }
 }
 
 //判断状态，队列寻找一个适合位置，进入waiting状态，等着被unpark()或interrupt()
 if (shouldParkAfterFailedAcquire(p, node) &&
 parkAndCheckInterrupt())
 interrupted = true;
 }
 } finally {
 if (failed)
 cancelAcquire(node);
 } 
}

public final boolean releaseShared(int arg) {
 //尝试释放资源
 if (tryReleaseShared(arg)) {
 //唤醒后继结点
 doReleaseShared();
 return true;
 }
 return false;
}

private void doReleaseShared() {
 for (;;) {
 Node h = head;
 if (h != null && h != tail) {
 int ws = h.waitStatus;
 if (ws == Node.SIGNAL) {
 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
 continue;
 //唤醒后继
 unparkSuccessor(h);
 }
 else if (ws == 0 &&
 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
 continue;
 }
 // head发生变化
 if (h == head)
 break;
 }
}