1.简述
锁：把需要的代码块，资源或数据锁上，只允许一个线程去操作，保证了并发时共享数据的一致性。
2.公平锁&非公平锁
公平锁：多个线程按照申请锁的顺序去获得锁，所有线程都在队列里排队，这样就保证了队列中的第一个先得到锁。
非公平锁：多个线程不按照申请锁的顺序去获得锁，而是同时直接去尝试获取锁（插队），获取不到（插队失败），再进入队列等待（失败则乖乖排队），如果能获取到（插队成功），就直接获取到锁。
公平锁的优缺点：
- 优点：所有的线程都能得到资源，不会饿死在队列中。
- 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。
非公平锁的优缺点：
- 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
- 缺点：可能导致队列中排队的线程一直获取不到锁或者长时间获取不到锁，活活饿死。
性能：
- 非公平锁性能优于公平锁：因为公平锁在获取锁时，永远是等待时间最长的线程获取到锁，这样当线程释放锁以后，如果还想继续再获取锁，它也得去同步队列尾部排队，这样就会频繁的发生线程的上下文切换，当线程越多，对CPU的损耗就会越严重。非公平锁性能虽然优于公平锁，但是会存在导致线程饥饿的情况。在最坏的情况下，可能存在某个线程一直获取不到锁。不过相比性能而言，饥饿问题可以暂时忽略，这可能就是ReentrantLock默认创建非公平锁的原因之一了。
以买票为例子实现公平锁与非公平锁demo如下：
public class Demo{ //公平锁 private static Lock fairLock = new ReentrantLock(true); //非公平锁 private static Lock nonFairLock = new ReentrantLock(); private static int num = 100; public static void main(String[] args) throws Exception { new Thread(new Runnable(){ public void run() { testFairLock(); } }, "A窗口").start(); new Thread(new Runnable(){ public void run() { testFairLock(); } }, "B窗口").start(); } /**公平锁测试方法 */ public static void testFairLock(){ while (true) { try { fairLock.lock(); if (num > 0) { Thread.sleep(100); --num; System.out.println(Thread.currentThread().getName() + "占用1个座位，还剩余 " + num + "个座位"); } else { System.out.println(Thread.currentThread().getName() + ":不好意思，票卖完了！"); break; } } catch (InterruptedException e) { e.printStackTrace(); } finally { fairLock.unlock(); } } } /**非公平锁测试方法 */ public static void testNonFairLock(){ while (true) { try { nonFairLock.lock(); if (num > 0) { Thread.sleep(100); --num; System.out.println(Thread.currentThread().getName() + "占用1个座位，还剩余 " + num + "个座位"); } else { System.out.println(Thread.currentThread().getName() + ":不好意思，票卖完了！"); break; } } catch (InterruptedException e) { e.printStackTrace(); } finally { nonFairLock.unlock(); } } } }
通过输出可以看出公平锁是有序的排队执行，而非公平则不是。
对比公平锁与非公平锁的性能demo如下：
public class Demo{ //公平锁 private static Lock fairLock = new ReentrantLock(true); //非公平锁 private static Lock nonFairLock = new ReentrantLock(); //公平锁计数器 private static int fairCount = 0; //非公平锁计数器 private static int nonFairCount = 0; public static void main(String[] args) throws Exception { System.out.println("公平锁耗时：" + testFairLock(10)); System.out.println("非公平锁耗时：" + testNonFairLock(10)); System.out.println("公平锁累加结果：" + fairCount); System.out.println("非公平锁累加结果：" + nonFairCount); } /**公平锁测试方法 */ public static long testFairLock(int threadNum) throws InterruptedException{ long startTime = System.currentTimeMillis(); final CountDownLatch countDownLatch = new CountDownLatch(threadNum); // 创建threadNum个线程，让其以公平锁的方式，对fairCount进行自增操作 for (int i = 0; i < threadNum; i++) { new Thread(new Runnable(){ public void run() { for (int j = 0; j < 10000; j++) { fairLock.lock(); fairCount++; fairLock.unlock(); } countDownLatch.countDown(); } }).start(); } // 让所有线程执行完 countDownLatch.await(); long endTime = System.currentTimeMillis(); return endTime - startTime; } /**非公平锁测试方法 */ public static long testNonFairLock(int threadNum) throws InterruptedException{ long startTime = System.currentTimeMillis(); final CountDownLatch countDownLatch = new CountDownLatch(threadNum); // 创建threadNum个线程，让其以公平锁的方式，对fairCount进行自增操作 for (int i = 0; i < threadNum; i++) { new Thread(new Runnable(){ public void run() { for (int j = 0; j < 10000; j++) { nonFairLock.lock(); nonFairCount++; nonFairLock.unlock(); } countDownLatch.countDown(); } }).start(); } // 让所有线程执行完 countDownLatch.await(); long endTime = System.currentTimeMillis(); return endTime - startTime; } }
从上面的测试结果可以发现，非公平锁的耗时远远小于公平锁的耗时，这说明非公平锁在并发情况下，性能更好，吞吐量更大。当线程数越多时，差异越明显。
3.可重入锁&不可重入锁
可重入锁：也叫递归锁，指的是同一线程外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响。在Java中有ReentrantLock和synchronized。
不可重入锁：若当前线程执行中已经获取了锁，如果再次获取该锁时，就会获取不到被阻塞。在Java中有NonReentrantLock。
可重入锁诞生的目的就是防止死锁，导致同一个线程不可重入上锁代码段，目的就是让同一个线程可以重新进入上锁代码段。
可重入锁synchronized示例：
public class Demo{ public static void main(String[] args) throws Exception { new Thread(new Runnable() { public void run() { synchronized (this) { System.out.println("第1次获取锁，这个锁是：" + this); int index = 1; while (true) { synchronized (this) { System.out.println("第" + (++index) + "次获取锁，这个锁是："+ this); } if (index == 10) { break; } } } } }).start(); } }
可重入锁reentrantLock示例：
public class Demo{ public static void main(String[] args) throws Exception { final Lock lock = new ReentrantLock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("第" + (++index) + "次获取锁，这个锁是："+ lock); try { Thread.sleep(new Random().nextInt(200)); } catch (InterruptedException e) { e.printStackTrace(); } if (index == 10) break; } finally { lock.unlock(); } } } finally { lock.unlock(); } } }).start(); } }
注意点：ReentrantLock和synchronized不一样，ReentrantLock需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样，最好在 finally中进行锁释放
自定义可重入所示例：
public class Demo{ public static void main(String[] args) throws Exception { final Lock lock = new Lock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("第" + (++index) + "次获取锁，这个锁是："+ lock); try { Thread.sleep(new Random().nextInt(200)); } catch (InterruptedException e) { e.printStackTrace(); } if (index == 10) break; } catch (Exception e) { System.out.println("第" + index + "次获取锁出现异常："+ e.getMessage()); } finally { lock.unlock(); } } } catch (Exception e) { System.out.println("第1次获取锁出现异常："+ e.getMessage()); } finally { lock.unlock(); } } }).start(); } } class Lock{ boolean isLocked = false; Thread lockedBy = null; int lockedCount = 0; public synchronized void lock()throws InterruptedException{ Thread thread = Thread.currentThread(); while(isLocked && lockedBy != thread){ wait(); } isLocked = true; lockedCount++; lockedBy = thread; } public synchronized void unlock(){ if(Thread.currentThread() == this.lockedBy){ lockedCount--; if(lockedCount == 0){ isLocked = false; notify(); } } } }
所谓可重入，意味着线程可以进入它已经拥有的锁的同步代码块儿。
不可重入锁，是指同一个线程不可以重入上锁后的代码段。
不可重入锁示例：
public class Demo{ public static void main(String[] args) throws Exception { final NonReentrantLock lock = new NonReentrantLock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("第" + (++index) + "次获取锁，这个锁是："+ lock); try { Thread.sleep(new Random().nextInt(200)); } catch (InterruptedException e) { e.printStackTrace(); } if (index == 10) break; } catch (Exception e) { System.out.println("第" + index + "次获取锁出现异常：" + e.getMessage()); } finally { lock.unlock(); } } } catch (Exception e) { System.out.println("第1次获取锁出现异常：" + e.getMessage()); } finally { lock.unlock(); } } }).start(); } } class NonReentrantLock { private boolean isLocked = false; public synchronized void lock() throws InterruptedException { while (isLocked) { wait(); } isLocked = true; //线程第一次进入后就会将器设置为true，第二次进入是就会由于where true进入死循环 } public synchronized void unlock() { isLocked = false;//将这个值设置为false目的是释放锁 notify();//结束阻塞 } }
第一次上锁后，由于没有释放锁，因此执行第一次lock后isLocked = true，这个时候又一次调用了lock()，由于上个线程将isLocked = true，再次进入的时候就进入死循环。从而导致线程无法执行下去。这种现象就造成了不可重入锁。
4.悲观锁&乐观锁
悲观锁：悲观锁在操作数据时比较悲观，认为别人会同时修改数据。Java中Synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
乐观锁：乐观锁在操作数据时非常乐观，认为别人不会同时修改数据。在Java中java.util.concurrent.atomic包下面的原子变量类就是基于CAS实现的乐观锁。
使用场景：
- 悲观锁：适用于读比较少的情况下（多写场景），如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行重试，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。
- 乐观锁：适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。
悲观锁的demo如下：
public class Demo{ public static void main(String[] args) throws Exception { for (int i = 1; i <= 5; i++) { new Thread(new Runnable(){ public void run() { System.out.println(Thread.currentThread().getName() + "：等待"); visit(); } }, i+"号线程").start(); } } private static synchronized void visit() { System.out.println(Thread.currentThread().getName()+ "：操作数据 "); try { Thread.sleep((long) (Math.random() * 5000)); } catch (InterruptedException e) { e.printStackTrace(); } } }
从输出可以看到，每次有线程访问这个资源visit()方法时，在访问前先锁定了资源，导致其他线程只能等待，也就是说不能多个线程在访问它。
乐观锁可以使用版本号机制和CAS算法实现。
乐观锁：乐观锁不需要线程挂起等待，所以也叫非阻塞同步。
版本号机制：一般在一个数据表中加一个version字段，表示这个数据被更新的次数，当这个数据被修改一次，版本号就加1。
版本号机制条件：提交版本必须大于当前记录的版本。
版本号机制实现例子如下：
我现在银行账户有10元，现在有一个version字段，版本号为1。 现在我A操作取出2元，我先读入数据version=1，然后扣除。 与此同时，B操作也要取出1元，读入数据version=1，然后扣除。 这个时候，A操作完成，上传数据，版本号加1，version=2，这个版本大于当前的记录值1，所以更新操作完成。 这个时候，B操作也完成了，也要更新，他的版本号加1，version=2，然后更新的时候发现这个版本号和当前记录的版本号相同，不满足提交版本号必须大于当前记录的版本号的条件，不允许更新。 这个时候，B操作就要重新读入再重复之前的步骤。
通过这样的方式，我们就保证了B操作不会将A操作所更新的值覆盖，保证了数据的同步。
CAS算法：即compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。
CAS算法涉及到三个操作数：
- 需要读写的内存值V。
- 进行比较的值A。
- 拟写入的新值B。
当且仅当V的值等于A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。
使用AtomicBoolean原子类实现的一个无阻塞多线程争抢资源的模型，示例如下：
public class Demo{ private static AtomicBoolean flag = new AtomicBoolean(true); public static void main(String[] args) throws Exception { new Thread(new Runnable() { public void run() { test(); } }, "线程1").start(); new Thread(new Runnable() { public void run() { test(); } }, "线程2").start(); } private static void test() { System.out.println(Thread.currentThread().getName()+"：flag="+flag.get()); if (flag.compareAndSet(true, false)){ System.out.println(Thread.currentThread().getName()+"：flag="+flag.get()); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } flag.set(true); }else{ System.out.println(Thread.currentThread().getName()+"重试机制：flag="+flag.get()); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } test(); } } }
示例中compareAndSet(true, false)方法可以拆开成compare(true)方法和Set(false)方法理解，是compare(true)等于true后，就马上设置共享内存为false，这个时候，其它线程无论怎么走都无法走到只有得到共享内存为true时的程序隔离方法区。
但是这种得不到状态为true时使用递归算法是很耗cpu资源的，所以一般情况下，都会有线程sleep。
CAS的缺点：
- CPU开销较大：在并发量比较高的情况下，如果许多线程反复尝试更新某一个变量，却又一直更新不成功，循环往复，会给CPU带来很大的压力。
- 不能保证代码块的原子性：CAS机制所保证的只是一个变量的原子性操作，而不能保证整个代码块的原子性。比如需要保证多个变量共同进行原子性的更新，就不得不使用Synchronized了。
5.独享锁&共享锁
独享锁和共享锁都是通过AQS队列来实现的，通过实现不同的方法，来实现独享或者共享。
独享锁：该锁一次只能被一个线程所持有，参考synchronized以及JUC包下的ReentrantLock。
共享锁：该锁可被多个线程所持有，参考JUC包下的ReentrantReadWriteLock。
6.互斥锁&读写锁
互斥锁：互斥锁与悲观锁、独占锁同义，表示某个资源只能被一个线程访问，其他线程不能访问，Java提供了两种互斥锁来解决在共享资源时存在的并发问题，一种方式是synchronized关键字，另一种方式是显式的使用Lock对象。
读写锁：读写锁是一种技术，通过ReentrantReadWriteLock类来实现。为了提高性能， Java提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如果没有写锁的情况下，读是无阻塞的，在一定程度上提高了程序的执行效率。读写锁分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的。
读写锁：
- 读锁： 允许多个线程获取读锁，同时访问同一个资源。
- 写锁： 只允许一个线程获取写锁，不允许同时访问同一个资源。
synchronized同步代码块的方式实现互斥锁：
public class Demo { //数量 private static int count = 100; public static void main(String[] args) { for (int i = 1; i <= 3; i++) { new Thread(new Runnable(){ public void run() { while(true){ if(count > 1) synchronizedTest(); else break; } } },i+"号线程").start(); } } private synchronized static void synchronizedTest(){ try { System.out.println(Thread.currentThread().getName()+"剩余数量为：" + count--); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } }
显式Lock锁方式实现互斥锁：
public class Demo { //数量 private static int count = 100; private static Lock lock = new ReentrantLock(); public static void main(String[] args) { for (int i = 1; i <= 3; i++) { new Thread(new Runnable(){ public void run() { while(true){ if(count > 1) synchronizedTest(); else break; } } },i+"号线程").start(); } } private static void synchronizedTest(){ lock.lock(); try { System.out.println(Thread.currentThread().getName()+"剩余数量为：" + count--); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } lock.unlock(); } }
读写锁实现操作缓存：
class ReadWriteCache { //充当cache static Map<String, Object> map = new HashMap<String, Object>(); //实例化读写锁对象 static ReadWriteLock rwLock = new ReentrantReadWriteLock(); //实例化读锁 static Lock read = rwLock.readLock(); //实例化写锁 static Lock write = rwLock.writeLock(); //获取缓存中值 public static final Object get(String key) { read.lock(); try { return map.get(key); } finally { read.unlock(); } } //写缓存中值，并返回对应value public static final Object set(String key, Object obj) { write.lock(); try { return map.put(key, obj); } finally { write.unlock(); } } //清空所有内容 public static final void clear() { write.lock(); try { map.clear(); } finally { write.unlock(); } } }
7.分段锁
分段锁：其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作（Java 8， JDK弃用了这个策略，重新使用了synchronized）。
基于散列的Map的实现分段锁：
class StripedMap { // 同步策略: buckets[n]由 locks[n%N_LOCKS] 来保护 private static final int N_LOCKS = 16;// 分段锁的个数 private final Node[] buckets; private final Object[] locks; /**结点 * @param <K> * @param <V> */ private static class Node<K, V> implements Map.Entry<K, V> { final K key;// key V value;// value Node<K, V> next;// 指向下一个结点的指针 int hash;// hash值 // 构造器，传入Entry的四个属性 Node(int h, K k, V v, Node<K, V> n) { value = v; next = n;// 该Entry的后继 key = k; hash = h; } public final K getKey() { return key; } public final V getValue() { return value; } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } } /**构造器: 初始化散列桶和分段锁数组 * @param numBuckets */ public StripedMap(int numBuckets) { buckets = new Node[numBuckets]; locks = new Object[N_LOCKS]; for (int i = 0; i < N_LOCKS; i++) { locks[i] = new Object(); } } /**返回散列之后在散列桶之中的定位 * @param key * @return */ private final int hash(Object key) { return Math.abs(key.hashCode() % N_LOCKS); } /**分段锁实现的get * @param key * @return */ public Object get(Object key) { int hash = hash(key);// 计算hash值 // 获取分段锁中的某一把锁 synchronized (locks[hash % N_LOCKS]) { for (Node m = buckets[hash]; m != null; m = m.next) { if (m.key.equals(key)) { return m.value; } } } return null; } /**清除整个map */ public void clear() { // 分段获取散列桶中每个桶地锁，然后清除对应的桶的锁 for (int i = 0; i < buckets.length; i++) { synchronized (locks[i % N_LOCKS]) { buckets[i] = null; } } } }
实现示例中使用了N_LOCKS个锁对象数组，并且每个锁保护容器的一个子集，对于大多数的方法只需要回去key值的hash散列之后对应的数据区域的一把锁就行了。但是对于某些方法却要获得全部的锁，比如clear()方法，但是获得全部的锁不必是同时获得，可以使分段获得。
8.自旋锁
自旋锁：是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。
Java自旋锁：Jdk提供的java.util.concurrent.atomic包里面提供了一组原子类。基本上就是当前获取锁的线程，执行更新的方法，其他线程自旋等待，比如atomicInteger类中的getAndAdd方法内部实际上使用的就是Unsafe的方法。
利用CAS实现自旋锁：
public class Demo { static int count = 0; public static void main(String[] args) throws Exception { //线程池 ExecutorService exec = Executors.newFixedThreadPool(2); //任务集合 List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>(); //任务 Callable<Integer> task = null; final SpinLock spinLock = new SpinLock(); for (int i = 0; i < 2; i++) { task = new Callable<Integer>() { public Integer call() throws Exception { while(count < 50){ spinLock.lock(); System.out.println(Thread.currentThread().getName()+" 开始运行"); count++; Thread.sleep(500); System.out.println(Thread.currentThread().getName()+" 结束运行"); spinLock.unLock(); } return 1; } }; //这里提交的任务容器列表和返回的Future列表存在顺序对应的关系 tasks.add(task); } //执行线程任务 exec.invokeAll(tasks); //关闭线程池 exec.shutdown(); System.out.println(count); } } class SpinLock { /**持有锁的线程，null表示锁未被线程持有 */ private AtomicReference<Thread> cas = new AtomicReference<>(); public void lock() { Thread currentThread = Thread.currentThread(); while (!cas.compareAndSet(null, currentThread)) {//利用CAS //通过循环不断的自旋判断锁是否被其他线程持有 } System.out.println(Thread.currentThread().getName()+" 获取锁"); } public void unLock() { Thread cur = Thread.currentThread(); cas.compareAndSet(cur, null); System.out.println(Thread.currentThread().getName()+" 释放锁"); } }
实现示例中看出，自旋就是在循环判断条件是否满足，如果锁被占用很长时间的话，自旋的线程等待的时间也会变长，白白浪费掉处理器资源。因此在JDK中，自旋操作默认10次，我们可以通过参数“-XX:PreBlockSpin”来设置，当超过来此参数的值，则会使用传统的线程挂起方式来等待锁释放。
9.偏向锁&轻量级锁&重量级锁
锁的状态总共有四种，级别由低到高依次为：无锁、偏向锁、轻量级锁、重量级锁，只能升级，不能降级。
偏向锁：偏向锁就是在运行过程中，对象的锁偏向某个线程。即在开启偏向锁机制的情况下，某个线程获得锁，当该线程下次再想要获得锁时，不需要再获得锁（即忽略synchronized关键词），直接就可以执行同步代码，比较适合竞争较少的情况。
轻量级锁：轻量级锁不是用来替代传统的重量级锁的，而是在没有多线程竞争的情况下，使用轻量级锁能够减少性能消耗，但是当多个线程同时竞争锁时，轻量级锁会膨胀为重量级锁。
重量级锁：即当有其他线程占用锁时，当前线程会进入阻塞状态。
这些锁不等同于Java API中的ReentratLock这种锁，这些锁是概念上的，是JDK1.6中为了对synchronized同步关键字进行优化而产生的的锁机制。这些锁的启动和关闭策略可以通过设定JVM启动参数来设置，当然在一般情况下，使用JVM默认的策略就可以了。