锁（公平锁、非公平锁、可重入锁、递归锁、自旋锁、互斥锁）

墨xiao渊

已于 2023-01-16 15:25:26 修改

阅读量871

点赞数

分类专栏：基础（多线程、锁、集合）文章标签： lock java

于 2021-08-03 23:13:15 首次发布

本文链接：https://blog.csdn.net/qq_28772075/article/details/119348576

版权

基础（多线程、锁、集合）专栏收录该内容

8 篇文章 0 订阅

订阅专栏

2.3 DEMO-synchronized是可重入锁的验证

2.4 DEMO-ReentrantLock是可重入锁的验证

4 独占锁（写锁)、共享锁（读锁）、互斥锁

4.1 独占锁：

4.2 共享锁：

4.3 ReentrantReadWriteLock

4.4 DEMO-ReentrantReadWriteLock

5 参考文献

1. 公平锁，非公平锁

1.1 概念

1.1.1 公平锁

（队列，先来后到）：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到

1.1.2 非公平锁

（允许插队）：是指多个线程获取锁的顺序不是按照申请锁的顺序，又可能后申请的线程比先申请的线程有限获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象。

1.2 公平锁和非公平锁两者区别

1.2.1 公平锁

Threads acquire a fair lock in the order in which they requested it

公平锁就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程时等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO（先进先出）的规则从队列中取到自己。

先来后到，性能下降，顺序得到保障

1.2.2 非公平锁

a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

非公平锁比较粗暴，上来就尝试占有锁，如果尝试失败，就再采用类似公平锁的那种方式。

例如：插队失败，回到队尾排队

先抢先得，性能好，吞吐量比公平锁大

对于Synchronized而言，也是非公平锁

1.3 源码

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁。入参是false 非公平， true 公平

Lock lock = new ReentrantLock(true);

无参时是非公平：

2 可重入锁（又称递归锁）

2.1 概念

指的是同一个线程外层函数获得锁之后，内层递归函数仍然能够获取该锁的代码。

在同一个线程在外出获取锁的时候，在进入内层方法会自动获取锁

例：ReentrantLock / Synchronized（可重入锁）

可重入锁种类：

隐式锁：JVM层面来控制，比如Synchronized（默认是可重入锁）

显示锁：自己写，比如Lock,ReetrantLock

即：线程可以进入任何一个它已经拥有锁的所同步着代码块。自己可以获取自己的内部锁

例：访问了一个同步方法A，同步方法A中又访问了一个同步方法B（开锁进入家门，卧室有锁，但是相当于是同一把锁，开了家门最外面的锁，就相当于也开了卧室的锁）

public synchonized void A() {
    B();
}


public synchonized void B() {
    //do something
}

2.2 作用（优点）

防止死锁

2.3 DEMO-synchronized是可重入锁的验证

2.3.1 DEMO1

class Phone{

    public synchronized void sendSMS() throws Exception {
        System.out.println(Thread.currentThread().getName() + "  sendSMS()");
        sendEmail();
    }

    public synchronized void sendEmail() throws Exception {
        System.out.println(Thread.currentThread().getName() + " sendMail()");

    }
}

/**
 * T1 sendSMS       T1线程在外层方法获取锁的时候
 * T1 sendEmail     T1在进入内存方法会自动获取锁
 * T2 sendSMS
 * T2 sendEmail
 */
public class LockDemo1 {

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"T1").start();

        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}

输出

T1 sendSMS()
T1 sendMail()
T2 sendSMS()
T2 sendMail()

可发现同一线程，外层方法sendSMS和内层方法sendMail的锁一致

2.3.2 DEMO2:

输出：

2.3.3 DEMO3

2.4 synchronized底层编译

多出来的是防止异常锁没有结束。

2.4.1 synchronized可重入锁实现原理

2.5 DEMO-ReentrantLock是可重入锁的验证

class Phone implements Runnable{

    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        get();
    }

    public void get(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t ReentrantLock invoked get()");
            set();
        }finally {
            lock.unlock();
        }
    }

    public void set(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t ReentrantLock invoked set()");
        }finally {
            lock.unlock();
        }
    }
}

/**
 * 2.验证ReentrantLock是可重入锁
 */
public class LockDemo1 {

    public static void main(String[] args) {
        Phone phone = new Phone();
        Thread t3 = new Thread(phone);
        Thread t4 = new Thread(phone);

        t3.start();
        t4.start();
    }
}

输出

Thread-0   ReentrantLock invoked get()
Thread-0   ReentrantLock invoked set()
Thread-1   ReentrantLock invoked get()
Thread-1   ReentrantLock invoked set()

2.5.1 重复加锁是否会造成异常？

lock.lock();
lock.lock();
try {
    System.out.println(Thread.currentThread().getName() + "\t ReentrantLock invoked get()");
    set();
}finally {
    lock.unlock();
    lock.unlock();
}

输出正常，无异常。

若加锁两次，但lock.unlock();仅有一个，程序不会出错，但会卡死。后面若方法需要锁，会出现死锁。故，一定要加锁几次，就要解锁几次，申请释放两两配对。

3. 自旋锁

3.1 概念

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式区尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

CAS案例就是自旋锁。通过CAS操作完成自旋锁，A线程持有锁，B随后进来后发现当前A线程持有锁，只好自旋等待，直至A释放锁后B随后抢到

生活案例：A在打电话，B找A有事，发现A在打电话，B先处理其他事，过一会再来看A，多次查看A是否结束电话，即自旋。

3.2 DEMO-自旋锁

/**
 * 实现一个自旋锁
 * 自旋锁好处：循环比较获取知道成功为止，没有类似wait的阻塞
 *
 * 通过CAS操作完成自旋锁，
 * A线程进来调用mylock方法自己持有锁5秒钟，
 * B随后进来后发现当前有线程持有锁，不是null
 * 所以只能通过自旋等待，直至A释放锁后B随后抢到
 */
public class SpinLockDemo {

    //原子引用线程,初始值是null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t come in ^_^ ");

        while (!atomicReference.compareAndSet(null, thread)){
            System.out.println(Thread.currentThread().getName()+"\t cas ing !!! ");
        }
    }

    public void myUnLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName()+"\t invoked myUnLock()");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            spinLockDemo.myLock();
            try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); }
            spinLockDemo.myUnLock();
        }, "AA").start();

        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            spinLockDemo.myLock();
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            spinLockDemo.myUnLock();
        }, "BB").start();

    }
}

输出

AA     come in ^_^
BB     come in ^_^
BB     cas ing !!!

.....(若干 BB cas ing !!!)

BB     cas ing !!!
AA     invoked myUnLock()
BB     invoked myUnLock()

自旋锁优点，不用阻塞，缺点长时间无法获得锁会导致性能下降

4 独占锁（写锁)、共享锁（读锁）、互斥锁

4.1 独占锁：

指该锁一次只能被一个线程所持有，对ReentrantLock / Synchronized 而言也是独占锁

4.2 共享锁：

指该锁可被多个线程锁持有

4.3 ReentrantReadWriteLock

对ReentrantReadWriteLock其读锁是共享锁，写锁是独占锁。

读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程都是互斥的

优点：保证了数据一致性和并发性

多线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。

但，有一个线程想去写共享资源，就不应该再有其他线程可以对该资源进行读和写。

读-读能共存；读-写不能共存；写-写不能共存

缓存框架基本操作：写读清空

写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割打断。

LOCK

ReentrantReadWriteLock

ReentrantReadWriteLock方法

4.4 DEMO-ReentrantReadWriteLock


//资源类
class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    //写操作： 原子+独占,整个过程必须是一个完整的统一体，中间不许被分割打断
    public void put(String key, Object value) {
//        rwLock.writeLock().lock();
//        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);
            //模拟网络拥堵情况，暂停一会线程
            try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成 ");
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            rwLock.writeLock().unlock();
//        }
    }

    public void get(String key) {
//        rwLock.readLock().lock();
//        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取 ");
            //模拟网络拥堵情况，暂停一会线程
            try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成: " + result);
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            rwLock.readLock().unlock();
//        }
    }

    public void clearMap() {
        map.clear();
    }
}

/**
 * 读写锁
 */
public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt + "", tempInt + "");
            }, String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

输出

0   正在写入: 0
3   正在写入: 3
2   正在写入: 2
1   正在写入: 1
4   正在写入: 4
0   正在读取
1   正在读取
2   正在读取
3   正在读取
4   正在读取
2   写入完成
1   写入完成
4   读取完成: null
2   读取完成: null
0   读取完成: null
1   读取完成: null
3   写入完成
0   写入完成
4   写入完成
3   读取完成: null

可以明显看出写的过程被打断了。

解除注释内容，使用读写锁以后，输出：

0   正在写入: 0
0   写入完成
1   正在写入: 1
1   写入完成
2   正在写入: 2
2   写入完成
3   正在写入: 3
3   写入完成
4   正在写入: 4
4   写入完成
0   正在读取
2   正在读取
1   正在读取
3   正在读取
4   正在读取
3   读取完成: 3
1   读取完成: 1
4   读取完成: 4
2   读取完成: 2
0   读取完成: 0

可以看出，写的过程是原子性的，读是非原子的

5 参考文献

以上内容均来自于下方视频，博客内容仅作为个人学习笔记记录

【1】Java面试_高频重点面试题（第一、二、三季）_ 面试第1、2、3季_柴林燕_周阳_哔哩哔哩_bilibili

墨xiao渊

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
锁（公平锁、非公平锁、可重入锁、递归锁、自旋锁、互斥锁）

目录1. 公平锁，非公平锁1.1 概念1.1.1 公平锁1.1.2 非公平锁1.2 公平锁和非公平锁两者区别1.2.1 公平锁1.2.2 非公平锁1.3 源码2 可重入锁（又称递归锁）2.1 概念2.2 作用2.3 DEMO-synchronized是可重入锁的验证2.4 DEMO-ReentrantLock是可重入锁的验证2.4.1重复加锁是否会造成异常？3. 自旋锁3.1 概念3.2 DEMO-自旋锁4 独占锁（写锁)、共享锁.
复制链接

扫一扫