java中的锁

定义

锁(Lock)和synchronized同步块一样，是一种线程同步机制

Lock 接口及其主要实现类都位于java.util.concurrent.locks包下

我们这里的锁主要指locks包下的,synchronized有时候也被叫做内置锁

java常用锁

image

锁的种类

对于 Java 锁的分类没有严格意义的规则，我们常说的分类一般都是依据锁的特性、锁的设计、锁的状态等进行归纳整理的

公平锁、非公平锁：公平锁指多个线程按照申请锁的顺序来获取锁，非公平锁就是没有顺序完全随机，所以能会造成优先级反转或者饥饿现象；synchronized 就是非公平锁，ReentrantLock（使用 CAS 和 AQS 实现） 通过构造参数可以决定是非公平锁还是公平锁，默认构造是非公平锁；非公平锁的吞吐量性能比公平锁大好。

可重入锁：又名递归锁，指在同一个线程在外层方法获取锁的时候在进入内层方法会自动获取锁，synchronized 和 ReentrantLock 都是可重入锁，可重入锁可以在一定程度避免死锁。

独享锁、共享锁：独享锁是指该锁一次只能被一个线程持有，共享锁指该锁可以被多个线程持有；synchronized 和 ReentrantLock 都是独享锁，ReadWriteLock 的读锁是共享锁，写锁是独占锁；ReentrantLock 的独享锁和共享锁也是通过 AQS 来实现的。

互斥锁、读写锁：其实就是独享锁、共享锁的具体说法；互斥锁实质就是 ReentrantLock，读写锁实质就是 ReadWriteLock。

乐观锁、悲观锁：这个分类不是具体锁的分类，而是看待并发同步的角度；悲观锁认为对于同一个数据的并发操作一定是会发生修改的（哪怕实质没修改也认为会修改），因此对于同一个数据的并发操作悲观锁采取加锁的形式，因为悲观锁认为不加锁的操作一定有问题；乐观锁则认为对于同一个数据的并发操作是不会发生修改的，在更新数据的时候会采用不断的尝试更新，乐观锁认为不加锁的并发操作是没事的；由此可以看出悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升，悲观锁在 java 中很常见，乐观锁其实就是基于 CAS 的无锁编程，譬如 java 的原子类就是通过 CAS 自旋实现的。

分段锁：实质是一种锁的设计策略，不是具体的锁，对于 ConcurrentHashMap 而言其并发的实现就是通过分段锁的形式来实现高效并发操作；当要 put 元素时并不是对整个 hashmap 加锁，而是先通过 hashcode 知道它要放在哪个分段，然后对分段进行加锁，所以多线程 put 元素时只要放在的不是同一个分段就做到了真正的并行插入，但是统计 size 时就需要获取所有的分段锁才能统计；分段锁的设计是为了细化锁的粒度。

偏向锁、轻量级锁、重量级锁：这种分类是按照锁状态来归纳的，并且是针对 synchronized 的，java 1.6 为了减少获取锁和释放锁带来的性能问题而引入的一种状态，其状态会随着竞争情况逐渐升级，锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后无法降为偏向锁，这种升级无法降级的策略目的就是为了提高获得锁和释放锁的效率。

自旋锁：其实是相对于互斥锁的概念，互斥锁线程会进入 WAITING 状态和 RUNNABLE 状态的切换，涉及上下文切换、cpu 抢占等开销，自旋锁的线程一直是 RUNNABLE 状态的，一直在那循环检测锁标志位，机制不重复，但是自旋锁加锁全程消耗 cpu，起始开销虽然低于互斥锁，但随着持锁时间加锁开销是线性增长。

可中断锁：synchronized 是不可中断的，Lock 是可中断的，这里的可中断建立在阻塞等待中断，运行中是无法中断的。

参考资料

Java 常见的锁分类

锁的可重入性

什么是可重入?
如果一个线程持有某个管程对象上的锁，那么它就有权访问所有在该管程对象上同步的块

可重入锁最大的作用是避免死锁

重入锁死:重复获取不可重入锁

解决方法

1. 编写代码时避免再次获取已经获取的锁

2. 使用可重入锁

实现一个可重入锁

先来看个不可重入锁的实现

public class TheardTest013 {
    private AtomicReference reference=new AtomicReference<>();
    public void lock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"尝试获得锁");
        while (!reference.compareAndSet(null,thread)){

        }
        System.out.println(thread.getName()+"获得锁");
    }

    public void unlock(){
       Thread thread= Thread.currentThread();
       reference.compareAndSet(thread,null);
        System.out.println(thread.getName()+"释放锁");
    }

    public static void main(String[] args) {
        TheardTest013 theardTest013=new TheardTest013();
        new Thread(new Runnable() {
            @Override
            public void run() {
                theardTest013.lock();
                theardTest013.lock();
                theardTest013.unlock();
                theardTest013.unlock();
            }
        }).start();
    }
}

在第二次执行lock方法时陷入死循环了

一个可重入锁的实现

public class TheardTest013 {
    private AtomicReference reference = new AtomicReference<>();
    private Integer count = 0;

    public void lock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "尝试获得锁");

        if (thread == reference.get()) {
            count++;
            System.out.println(thread.getName() + "获得锁");
            return;
        }
        while (!reference.compareAndSet(null, thread)){}
        System.out.println(thread.getName() + "获得锁");
    }

    public void unlock() {
        Thread thread = Thread.currentThread();
        if (thread == reference.get()) {
            count--;
            if (count == 0) {
                reference.compareAndSet(thread, null);
                System.out.println(thread.getName() + "释放锁");
            }
        }
    }

    public static void main(String[] args) {
        TheardTest013 theardTest013 = new TheardTest013();
        for (int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        theardTest013.lock();
                        theardTest013.lock();
                        TimeUnit.SECONDS.sleep(10);
                        theardTest013.unlock();
                        theardTest013.unlock();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

    }
}

参考资料

Java锁的种类以及辨析（四）：可重入锁

lock和synchronized的区别

• 代码层面

synchronized 是 Java 的一个内置特性关键字，而 Lock 是 Java 的一个接口类

• 异常处理

synchronized 在发生异常时会自动释放线程占用的锁，而 Lock 在发生异常时（不发生也一样）需要主动在 finally 中调用 unLock() 去释放锁

• 是否可中断

Lock 可以让等待锁的线程响应中断，而 synchronized 无法响应中断，会一直等待下去

• 可见性

Lock 和 synchronized 都可以保证保证内存可见性

• 其它

Lock 可以知道有没有成功获取到锁，而 synchronized 无法办到；Lock 可以提高多线程进行读操作的效率，而 synchronized 不可以；在性能上来说如果竞争资源不激烈则两者差距不大，如果竞争资源非常激烈（很多线程同时抢占）时 Lock 的性能远远好于 synchronized；不过要注意只能中断阻塞中的线程，一旦获取到锁进入运行状态就无法中断

参考资料

Java Lock 锁相关的技术

ReentrantLock

ReentrantLock是Lock接口的实现类,可以用来替代Synchronized，在需要同步的代码块加_上锁，最后一定要释放锁，否则其他线程永远进不来

基础例子

public class TheardTest011 {

   private Lock lock=new ReentrantLock();

    public static void main(String[] args) {
        TheardTest011 theardTest011 = new TheardTest011();
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    theardTest011.doing();
                }
            }).start();
        }
    }

    public void doing(){
        lock.lock();
        System.out.println(Thread.currentThread().getName()+"获取到锁");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {  
    // 释放锁  
     lock.unlock(); 
      }  
       
        System.out.println(Thread.currentThread().getName()+"释放锁");
    }


}

公平性

默认是非公平锁,但是可以在构造方法中强制指定使用公平锁

替代Synchronized

ReentrantLock和Synchronized相同,都是可重入的独占锁

在Synchronized中实现线程间通讯使用到了Object.wait()和Object.notify()方法

在ReentrantLock中使用lock.newCondition()替代

condition.await()相当于wait

condition.signal()相当于notify