对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
对于 synchronized 而言，也是一种非公平锁，由于其并不像 ReentrantLock 是通过 AQS 来实现线程调度，所以并没有任何办法使其变成公平锁。
ReentrantLock 和 synchronized 都是可重入锁。
另外，读锁的共享可保证并发读诗非常高效的，但是读写和写写，写读都是互斥的。
独享锁与共享锁也是通过 AQS 来实现的。
对于synchronized而言，当然是独享锁。
读写锁在Java中具体实现就是 ReadWriteLock
传统的关系型数据库里边就用到了很多这种锁机制，比如行锁、表锁。读锁、写锁等，都是在做操作之前先上锁。Java中 synchronized 和 ReentrantLock 等独占锁就是悲观锁思想的实现。
乐观锁适用于多读的应用类型，这样可以提高吞吐量。
在Java中,java.util.concurrent.atomic包下面的原子变量类就是使用乐观锁的一种实现方式CAS。
分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不存在锁竞争，从而有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。
synchronized 锁的状态：
无锁状态偏向锁状态轻量级锁状态重量级锁状态锁的状态是通过对象监视器在对象头中的字段来表明的。
四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级。
这四种状态都不是Java语言中的锁，而是JVM为了提高锁的获取与释放而做的优化（使用synchronized时）
无锁的好处：
1.在高并发的情况下，它比有锁的程序拥有更好的性能。2.它天生就是死锁免疫的。凭借这两个优势，就值得我们冒险尝试使用无锁的并发。
CAS算法的核心思想：
执行函数 CAS(V, E, N);其包含3个参数： V：表示要更新的变量 E：表示预期值 N：表示新值
如果V值等于E值，则将V的值设为N。若V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。
由于CAS操作属于乐观锁，它总认为自己可以完成操作，当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。
基于这样的原理，CAS操作即使没有锁，同样知道其他线程对共享资源操作影响，并执行相应的处理措施。
CPU指令对CAS的支持：
或许我们可能会有这样的疑问，假设存在多个线程执行CAS操作，并且CAS的步骤很多，有没有可能在判断V和E相同后，正要赋值时，切换了线程，更改了值，造成了数据不一致呢？答案是否定的。因为CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，该类是非安全的，毕竟unsafe拥有着类似于C的指针操作，因此总是不应该首先使用Unsafe类。
但是我们还是有必要了解该类，因为Java中CAS操作的执行依赖于Unsafe类的方法，注意Unsafe类中的所有方法都是native修饰的。
public class User{ public User(){ sysout("User构造方法被调用"); private String name; private int age; private static String id = "USER_ID"; @override public String toString(){ return "User{ name + age + id}" } } } public class UnsafeDemo{ public static void main(String[] args){ // 通过反射得到Unsafe类中的theUnsafe对象 Field field = Unsafe.class.getDeclaredFiled("theUnsafe"); // 设置该Field为可访问 field.setAccessible(true); // 通过该Field得到对应的具体对象 // 如果不是static属性，那么get方法的参数就不能是null,否则会抛出异常 // 如果是static属性，那么传入任何对象包括null,因为get方法会将该参数忽略 Unsafe unsafe = (Unsafe) field.get(null); sysout(unsafe); // 通过allocateInstance直接创建对象，不会调用构造方法 User user = (User) unsafe.allocateInstance(User.class); Class userClass = user.getClass(); Field name = userClass.getDeclaredField("name"); Field age = userClass.getDeclaredField("age"); Field id = userClass.getDeclaredField("id"); // 获取实例变量name和age在对象内存中的偏移量并设置值 unsafe.putInt(user, Unsafe.objectFieldOffset(age), 18); unsafe.putObject(user, Unsafe.objectFieldOffset(name), "android-TV"); // 这里返回User.class Object staticBase = Unsafe.staticFieldBase(id); sysout("staticBase:" + staticBase); // 获取静态变量id的偏移量StaticOffset long staticOffset = unsafe.staticFieldOffset(userClass.getDeclaredField("id")); // 获取静态变量的值 sysout("设置前的ID:" + unsafe.getObject(staticBase, staticOffset)); // 设置值 unsafe.putObject(staticBase, staticOffset, "sss"); sysout("设置后的ID:" + unsafe.getObject(staticBase, staticOffset)); // 输出User sysout("输出USER:" + user.toString()); sysout("--------------------"); long data = 1000; byte size = 1; // 调用allocateMemory分配内存，并获取内存地址memoryAddress long memoryAddress = Unsafe.allocateMemory(size); // 直接往内存写入数据 Unsafe.putAddress(memoryAddress, data); // 获取指定内存地址的数据 long addressData = Unsafe.getAddress(memoryAddress); sysout("addrData：" + addrData); } }虽然在Unsafe类中存在getUnsafe()方法，但该方法只提供给高级的Bootstrap类加载器使用，普通用户调用将抛出异常。所以我们在Demo中使用了反射技术获取了Unsafe实例对象并进行相关操作。
CAS是一些CPU直接支持的指令，也就是我们前面分析的无锁操作，在Java中无锁操作CAS基于以下3个方法实现：
// 第一个参数o为给定对象，offset为对象内存的偏移量，通过这个偏移量迅速定位字段并设置或获取该字段的值。 // expected表示期望值，x表示要设置的值，下面3个方法都通过CAS原子指令进行操作 public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x); public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x); public final native boolean compareAndSwapInt(Object o, long offset, long expected, long x);这3个类的实现原理和使用方式几乎是一样的，这里我们以AtomicInteger为例，进行分析。
AtomicInteger 主要针对int类型的数据执行原子操作，它提供了原子自增方法，原子自减方法以及原子赋值方法。
实现原理:
public class AtomicInteger extends Number implements java.io.Serializable{ // 获取指针类Unsafe private static final Unsafe unsafe = Unsafe.getUnsafe(); // 变量value在atomicInteger实例变量内的内存偏移量 private static final long valueOffset; static { try { // 通过Unsafe类的objectFieldOffset方法，获取value变量在对象 // 内存中的偏移 // 通过该偏移量valueOffset，unsafe类的内部方法可以获取到变量 // value并对其进行取值或者赋值操作 valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile int value; /** * Creates a new AtomicInteger with the given initial value. * * @param initialValue the initial value */ public AtomicInteger(int initialValue) { value = initialValue; } // 设置新值并获取旧值，底层调用的是CAS操作 public final int getAndSet(int newValue) { return unsafe.getAndSetInt(this, valueOffset, newValue); } // 如果当前值为expect，则设置为update public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); } // 当前值加1，返回旧值，底层CAS操作 public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); } // 当前值加1，返回新值 public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } }Unsafe类中的getAndAddInt方法：
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; }可以看出,getAndAddInt通过while循环不断的重试，更新要设置的值，直到成功为止。
使用方式：
public class AtomicIntegerDemo{ static AtomicInteger i = new AtomicInteger(); public static class AddThread implements Runnable{ @override public void run(){ for(int k = 0; k < 10000; k++){ i.incrementAndGet(); } } } public static void main(String[] args){ Thread[] ts = new Thread[10]; for(int k = 0; k < 10; k++){ ts[k] = new Thread(new AddThread()); } for(int k = 0; k < 10; k++){ ts[k].join(); } sysout(i); } }使用方式：
public class AtomicReferenceDemo{ public static AtomicReference<User> atomicUserRef = new AtomicReference<User>(); public static void main(String[] args){ User user = new User("zejian", 18); atomicUserRef.set(user); User updateUser = new User("shine", 25); atomicUserRef.compareAndSet(user, updateUser); sysout(atomicUserRef.get().toString()); } static class User{ public String name; private int age; } }原子更新数组指的是通过原子的方式更新数组中的某个元素
AtomicIntegerArrayAtomicLongArrayAtomicReferenceArray使用方式：
public class AtomicIntegeArrayDemo{ static AtomicIntegeArray arr = new AtomicIntegeArray(10); public static class AddThread implements Runnable: run(): for(int k = 0; k < 10000; k++){ arr.getAndIncrement(k % arr.length); } main(): Thread ts = new Thread[10]; for(k:0-10, k++): ts[k] = new Thread(new AddThread()); for(k:0-10, k++): ts[k].start(); for(k:0-10, k++): ts[k].join(); sysout(arr); }假设，当第一个线程执行CAS(V, E, U)操作，在获取到当前变量V，准备修改为新值U前，另外两个线程已经连续修改了两次变量V的值，使得该值又恢复为旧值，这样的话，我们就无法正确判断这个变量是否已经被修改过。
这就是典型的CAS的ABA问题，一般这种情况发生的概率较小，可能发生了改变也不会造成什么问题，但是在某些情况下还是需要防止的。
在Java中解决ABA问题，可以使用以下两个原子类：
AtomicStampedReferenceAtomicStampedReference 原子类是一个带有时间戳的对象引用，在每次修改后，AtomicStampedReference不仅会设置新值，而且还会记录更改的时间。
当 AtomicStampedReference 设置对象值时，对象值以及时间戳必须满足期望值才能写入成功。
测试Demo如下:
package com.zava.multithread.cas; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicStampedReference; public class ABADemo { public ABADemo() { } static AtomicInteger atIn = new AtomicInteger(100); // 初始化时需要传入一个初始值和初始时间 static AtomicStampedReference<Integer> atomicStampedR = new AtomicStampedReference<Integer>(100, 0); static Thread t1 = new Thread(new Runnable() { public void run() { atIn.compareAndSet(100, 200); atIn.compareAndSet(200, 100); }; }); static Thread t2 = new Thread(new Runnable() { @Override public void run() { try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } boolean flag = atIn.compareAndSet(100, 500); System.out.println("flag:" + flag + ",newValue:" + atIn); } }); static Thread t3 = new Thread(new Runnable() { @Override public void run() { int time = atomicStampedR.getStamp(); System.out.println(Thread.currentThread().getName() + "-time:" + time); boolean flag1 = atomicStampedR.compareAndSet(100, 200, time, time + 1); System.out.println("------flag1---------" + flag1); // int time2 = atomicStampedR.getStamp(); // // System.out.println(Thread.currentThread().getName() + "-time2:" + time2); boolean flag2 = atomicStampedR.compareAndSet(200, 100, atomicStampedR.getStamp(), atomicStampedR.getStamp() + 1); System.out.println("------flag2---------" + flag2); } }); static Thread t4 = new Thread(new Runnable() { @Override public void run() { int time = atomicStampedR.getStamp(); System.out.println("sleep 前 t4 time:" + time); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } boolean flag = atomicStampedR.compareAndSet(100, 500, time, time + 1); System.out.println("flag:" + flag + ",newValue:" + atomicStampedR.getReference()); } }); public static void main(String[] args) throws Exception { t1.start(); t2.start(); t1.join(); t2.join(); t3.start(); // t4.start(); } }输出结果: flag: true,newValue:500 sleep钱 t4 time:0 flag: false, newValue:500
自旋锁：指当一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。
无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入等待状态，但是自旋锁不会，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放锁。
Java实现自旋锁：
public class SpinLock{ private AtomicReference<Thread> cas = new AtomicReference<>(); public void lock(){ Thread current = Thread.currentThread(); while(!cas.compareAndSet(null, current)){ } } public void unlock(){ Thread current = Thread.currentThread(); cas.compareAndSet(current, null); } }lock()方法利用CAS，当第一个线程A获取到锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁，另一个线程B又来获取锁，此时，由于不满足CAS，所以就会进入while循环，不断判断是否满足CAS，知道A线程调用unlock方法释放了锁
自旋锁存在的问题：
1.如果某个线程持有锁的时间过长，就会导致其他等待获取锁的线程进入循环等待，消耗CPU，使用不当会造成CPU使用率极高。
2.上面Java实现的自旋锁是不公平的，即无法满足等待时间最长的线程优先获取到锁。不公平的锁就会存在“线程饥饿”问题。
自旋锁的优点： 自旋锁不会使线程状态发生切换，一直处于用户状态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快。
1.请问flag1和flag2是多少？
static AtomicStampedReference<Integer> atomicStampedR = new AtomicStampedReference<Integer>(100, time); boolean flag1 = atomicStampedR.compareAndSet(100, 200, time, time + 1); boolean flag2 = atomicStampedR.compareAndSet(200, 100, time, time + 1);2.本节中实现的SpinLock是可重入的吗，如果不是请自己实现一个可重入的自旋锁。
