Java并发编程（二）（锁）

.挽星.

已于 2023-11-08 10:39:03 修改

阅读量1.4k

点赞数 2

分类专栏： Java多线程文章标签： java

于 2023-01-22 14:39:26 首次发布

本文链接：https://blog.csdn.net/qq_41449402/article/details/128712425

版权

Java多线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、锁的分类

1.可重入锁、不可重入锁

可重入：线程A拿到锁资源，此时线程A尝试再次拿取同一把锁资源，是可以获取到的。

不可重入：线程A拿到锁资源，此时线程A尝试再次拿取同一把锁资源，无法获取到，因为锁被自身占用着，需要等自己将锁释放才能再次获取到。

（java中的synchronize、ReentrantLock、ReentrantReadWriteLock都是可重入锁）

2.乐观锁、悲观锁

悲观锁：线程获取不到锁资源时，会将该线程挂起（BLOCKED,WAITING），涉及到用户态和内核态的切换，而这种切换是非常消耗资源的。

用户态：JVM可以自行执行指令，不需要借助操作系统。
内核态：JVM不可以自行执行指令，需要借助操作系统才能执行。

乐观锁：线程获取不到锁资源时，会再次调度CPU重新尝试获取锁资源。

（java中的synchronize、ReentrantLock、ReentrantReadWriteLock都是悲观锁，cas是乐观锁的一种实现）

3.公平锁、非公平锁

公平锁：线程A拿到了锁资源，此时线程B来了没有拿到锁资源，线程B去排队，之后线程C又来了，他会排到线程B之后，当B拿到锁资源或者取消后才去竞争锁资源。

非公平锁：线程A拿到了锁资源，此时线程B来了没有拿到锁资源，线程B去排队，之后线程C又来了，他会先尝试去竞争一波锁资源，有可能会在B之前拿到锁资源。

（java中的synchronize是非公平锁，ReentrantLock、ReentrantReadWriteLock可以实现公平锁，也可以实现非公平锁）

4.互斥锁、共享锁

互斥锁：同一时间点，只有一个线程可以获取到当前锁资源。

共享锁：同一时间点，多个线程可以共享同一个锁资源。

（java中的synchronize、ReentrantLock是互斥锁，ReentrantReadWriteLock有互斥锁也有共享锁）

二、深入synchronize

1.类锁、对象锁

synchronize可以用于代码块或者方法上，是基于对象实现的。

synchronize用于静态方法上，锁的是整个class类，因为全局只有一个（类锁）。
synchronize用于非静态方法上，锁的是调用该方法的对象（对象锁）。

public class Demo01 {

    public static void main(String[] args) {
        //synchronize锁的是Demo01这个类，因为全局只有一个
        Demo01.test1();
        //synchronize锁的是demo01这个对象，因为每个对象的实例化都是不一样的
        Demo01 demo01 = new Demo01();
        demo01.test2();
    }

    public static synchronized void test1() {
        System.out.println("类锁");
    }

    private synchronized void test2() {
        System.out.println("对象锁");
    }

}

2.synchronize的优化

在jdk1.5的时候，推出了ReentrantLock锁，效率远高于synchronize，因此在jdk1.6中，对synchronize做了大量优化，效率和ReentrantLock很接近。

2.1.锁消除

在synchronize代码块中，如果不存在操作临界资源的情况下，也就是没必要进行加锁，这时会触发锁消除，即便写了synchronize也不会触发。

    private synchronized void test1() {
        //没有操作临界资源
        //加锁无意义，可以认为这个方法的synchronize木有
    }

2.2.锁膨胀

在循环的代码块中加入synchronize锁，会频繁的获取锁和释放锁，这样是非常消耗资源的，此时会触发锁膨胀，也就是将锁的范围扩大，避免频繁的获取锁和释放锁而带来不必要的消耗。

    private void test2() {
        for (int i = 0; i < 1000; i++) {
            synchronized (this) {
                //频繁竞争锁资源
            }
        }
        //这时会触发锁膨胀，扩大锁的范围
        synchronized (this){
            for (int i = 0; i < 1000; i++) {
                
            }
        }
    }

2.3.锁升级

jdk1.6出现的ReentrantLock是基于cas乐观锁实现的，在锁竞争时，会先尝试获取锁资源，如果实在拿不到锁，才会将线程挂起。jdk1.6之前的synchronize是获取不到锁就将线程挂起，前面提到线程挂起涉及到用户态和内核态的切换，是非常消耗资源的，因此jdk1.6之前的synchronize性能是非常差的，因此在jdk1.6对synchronize做个锁升级的优化，会涉及到以下四个状态。

无锁、匿名偏向：当前对象创建后，还没有线程加入，对象没有锁存在
偏向锁：如果当前锁资源只有一个线程在频繁的获取锁和释放锁，那么当线程过来获取锁，只需要判断是否为当前线程：
- 若是，则直接拿到当前锁资源
- 若不是当前线程，会基于cas的方式，尝试将偏向锁指向当前线程，若获取不到则升级为轻量级锁（出现了锁的竞争）
轻量级锁：采用自旋以cas的方式频繁的获取锁（自适应自旋锁）
- 成功获取到则拿着锁资源走
- 未获取到，自旋达到了一定次数，触发锁升级，升级为重量级锁
重量级锁：采用最传统的synchronize方式，若获取不到锁，就将线程挂起（用户态&内核态）

锁升级状态的转变

三、ReentrantLock

1.ReentrantLock和synchorized的区别

ReentrantLock是一个类，synchronized是一个关键字
ReentrantLock是基于cas实现的，synchronized是基于ObjectMonitor实现的
在线程竞争锁资源激烈的情况下，ReentrantLock效率较高，因为其内部不存在锁升级的概念，synchronized升级为重量级锁时效率较低
ReentrantLock功能更全面，可以支持公平锁和非公平锁，还可以指定锁等待的时间

2.AQS概述

AQS是AbstractQueuedSynchronizer的缩写，是一个抽象类，属于JUC的一个基类，JUC下的很多内容都是通过AQS实现的，例ReentrantLock，ThreadPoolExecutor，阻塞队列，CountDownLatch，Semaphore，CyclicBarrier等等都是基于AQS实现。

2.1.AQS的内部结构

由volatile修饰的state成员变量，保证了可见性和有序性（禁止指令重排）
双向链表Node头节点和尾节点

3.ReentrantLock加锁流程（三种）

3.1.lock()方法

ReentrantLock可以指定公平锁和非公平锁，默认为非公平锁，在构造函数里进行指定。

如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁。

    public static void main(String[] args) {
        //默认无参构造方法，非公平锁
        ReentrantLock reentrantLock = new ReentrantLock();
        //有参构造方法，非公平锁
        //ReentrantLock reentrantLock1 = new ReentrantLock(true);
        reentrantLock.lock();
        try {
            System.out.println("业务代码");
        } finally {
            reentrantLock.unlock();
        }
    }

3.2.tryLock()方法

tryLock()：尝试获取锁资源，如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false
tryLock(long timeout, TimeUnit unit)，尝试获取锁资源，若没获取到，在指定时间内再次不断获取锁资源，并返回获取结果

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        boolean result = reentrantLock.tryLock(5L, TimeUnit.MINUTES);
        try {
            System.out.println("加锁状态:" + result);
            System.out.println("业务代码");
        } finally {
            reentrantLock.unlock();
        }
    }

3.3.lockInterruptibly()方法

与tryLock类似，区别在于拿不到锁资源，就死等，等到锁资源释放后，被唤醒，或者是被中断唤醒。

如果获取了锁资源立即返回，如果没有获取锁资源，当前线程处于休眠状态，直到获取锁资源，或者当前线程被别的线程中断。

    public static void main(String[] args) throws InterruptedException {
        //默认无参构造方法，非公平锁
        ReentrantLock reentrantLock = new ReentrantLock();
        //有参构造方法，非公平锁
        //ReentrantLock reentrantLock1 = new ReentrantLock(true);
        reentrantLock.lockInterruptibly();
        try {
            System.out.println("业务代码");
        } finally {
            reentrantLock.unlock();
        }
    }

4.ReentrantLock释放锁

四、ReentrantReadWriteLock

传统的synchronized和ReentrantLock都是互斥锁，如果有一个读多写少的操作，还要保证线程安全的问题，使用互斥锁效率是非常低的，因此出现了ReentrantReadWriteLock读写锁，在读读的操作下使用共享锁，在写写和读写的操作下使用互斥锁，提升了效率。

public class ReadWriteLockDemo {

    public static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();

    public static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();

    public static void main(String[] args) {
        new Thread(() -> {
            readLock.lock();
            try {
                System.out.println("子线程加读锁");
                Thread.sleep(50000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                readLock.unlock();
            }
        }).start();

        readLock.lock();
        System.out.println("主线程加读锁");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            readLock.unlock();
        }
    }

}