Java中的锁的概念大汇总

公平锁/非公平锁

公平锁

公平锁指的是多线程环境中按照申请锁的顺序获取锁，类似FIFO队列，先申请锁的线程在有资源的情况下保证先获取到锁。
示例说明一下公平锁：

public class FairLockDemo {
    //内部类公平锁测试
    static class FairLockRunnable implements Runnable {
        ReentrantLock reentrantLock = new ReentrantLock(false);//设置false代表是公平锁，默认是非公平锁

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();//获取线程名称
            reentrantLock.lock();//获取锁
            try {
                System.out.println("[" + threadName + "] 获取锁");
                Thread.sleep(2000);//模拟执行任务，睡2s
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();//释放锁
                System.out.println("[" + threadName + "] 释放锁");
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();//定义依噶线程池
        for (int i = 0; i < 5; i++) {
            executor.execute(new FairLockRunnable());
        }
        executor.shutdown();//线程池优雅关闭
    }
}

打印结果：

[pool-1-thread-2] 获取锁
[pool-1-thread-1] 获取锁
[pool-1-thread-4] 获取锁
[pool-1-thread-3] 获取锁
[pool-1-thread-5] 获取锁
[pool-1-thread-2] 释放锁
[pool-1-thread-1] 释放锁
[pool-1-thread-4] 释放锁
[pool-1-thread-3] 释放锁
[pool-1-thread-5] 释放锁

可以看出来这里获取锁和释放锁的顺序是按照申请锁的顺序来的，这就是公平锁。 new ReentrantLock(false)是一种公平锁。

非公平锁

非公平锁对应的是公平锁，在多线程环境中获取锁的顺序并不是按申请锁的顺序来进行的。
测试代码跟上面的一样，只需要改一处地方：

        ReentrantLock reentrantLock = new ReentrantLock();//设置false代表是公平锁，默认是非公平锁

打印结果：

[pool-1-thread-1] 获取锁
[pool-1-thread-2] 获取锁
[pool-1-thread-3] 获取锁
[pool-1-thread-4] 获取锁
[pool-1-thread-5] 获取锁
[pool-1-thread-2] 释放锁
[pool-1-thread-3] 释放锁
[pool-1-thread-4] 释放锁
[pool-1-thread-1] 释放锁
[pool-1-thread-5] 释放锁

可以看出，获取锁的顺序并没有按照申请锁的顺序来走，其实是随机的。非公平锁可以增加业务的吞吐量，因为是随机让获取到资源的线程执行的，但是有可能造成优先级反转或者线程饥饿问题（可能存在有个倒霉的线程一直获取不到锁，一直在等待），因此是不公平的锁。

乐观锁/悲观锁

乐观锁和悲观锁更像是某种思想，就像是看待问题的方式，乐观锁倾向于乐观的方式看待数据认为每次获取的只有一个线程，悲观锁倾向于悲观的方式看待数据认为每次获取都是多个线程，所以需要将数据锁定只让一个线程访问。

乐观锁

乐观锁总是认为不存在多线程并发问题，因此每次获取数据的时候总认为不会有其他线程对数据进行修改，因此不会上锁。但是更新的时候会进行数据的比较以防止被其他线程已经修改。实现方式一般使用“数据版本机制”或者“CAS操作”来实现。

1. 数据版本机制就是在在数据库表字段加一个version字段。这个字段代表被修改的次数，每当数据被修改version就加1。 修改的时候一定要等得到查询的version和数据库中存在的version相等在更新，否则更新失败。
2. CAS(Compare and Swap)比较并交换。CAS包含三个操作数： 内存为值(V)、进行比较的预期原值(A)、拟修改的新值(B)。如果内存位置V的值和预期原值A相匹配，那么比较器会将新值更新为B，否则不做处理。

在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS(Compare and Swap 比较并交换)实现的。

悲观锁

悲观锁总是认为数据总是多线程访问的，如果对数据进行操作必须加锁实现。对数据操作之前加锁，操作完成或者操作异常都要解锁。
悲观锁有synchronized、ReentrantLock等。

独占锁/共享锁

独占锁(排它锁)

独占锁指的是锁资源被一个线程所持有，每一次只能一个线程独占使用。ReentrantLock和 synchronized都是独占锁。

共享锁

共享锁指的是锁资源可以被多个线程持有的。如果线程A对数据Data加共享锁后，其他线程只能对Data再加共享锁，不能加独占锁。独占锁和共享锁在JAVA中都是通过AQS实现的。 ReentrantReadWriteLock读锁是共享锁，写锁是独占锁。读锁的共享可以保证并发读是高效的，读写，写读，写写是互斥的。

互斥锁/读写锁

互斥锁

互斥锁指的最多只能有一个线程持有的锁，属于独占锁的一种。ReentrantLock和 synchronized都是互斥锁。

读写锁

读写锁指的具体的关于读写的一种锁，既有独占锁又有共享锁，read模式就是共享的，但是write模式是独占的。
读写锁的机制：

1. “读-读”不互斥
2. “读-写”互斥
3. “写-写”互斥

java中读写锁的实现是ReentrantReadWriteLock。

偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
JVM通过以下方式关闭偏向锁：

-XX:-UseBiasedLocking

偏向锁

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

轻量级锁

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

重量级锁

重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让他申请的线程进入阻塞，性能降低。

可重入锁

可重入的意思其实就是可重复使用，就是一把锁可以重复多次用，但是注意需要按照获取锁的次数进行解锁，也就是加锁此时一定要等于解锁次数。ReentrantLock和 synchronized都是可重入锁。

分段锁

分段锁指的是一种设计，并非真正的锁。对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

自旋锁

自旋锁其实也不是真正的锁，只是一种现象的描述，原理就是通过循环去实现。
例如JDK源码中很多都是通过for循环实现自旋锁的。

	for (;;) {
		省略业务代码......
    }

锁粗化

锁粗化简单理解就是将多个锁合并成一个，减少重复锁请求带来的性能损耗。一个例子理解：

public void doSomethingMethod(){
   while(i<1000){
    	 synchronized(lock){
    		//do some thing
    	}
    }	
}

锁粗化之后的代码

public void doSomethingMethod(){
    synchronized(lock){
    	while(i<1000){
    	//do some thing
    	}
    }
}

锁消除

锁消除是发生在编译器级别的一种锁优化方式。举个简单例子可以理解：

    public synchronized void logApend(String content){
        StringBuffer sb = new StringBuffer();
        sb.append(content);
    }

代码非常简单，就是向StringBuffer中添加内容的方法，并且这个方法是synchronized来修饰的。其实我们看apppd方法的源码发现这里也有一个synchronized来修饰。

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

我们可以通过编译器将其优化，将锁消除。
前提是java必须运行在server模式（server模式会比client模式作更多的优化），同时必须开启逃逸分析:

-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks

+DoEscapeAnalysis：开启逃逸分析
+EliminateLocks：锁消除。