公平锁、非公平锁、可重入锁、自旋锁、读写锁

已于 2023-05-30 18:08:36 修改
阅读量2.1k 收藏 3
点赞数 1
分类专栏： Java基础 操作系统 文章标签： 多线程 队列 java 并发编程
于 2021-06-05 15:41:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoyaochengxian/article/details/117596343
版权

并发编程多种锁

公平锁与非公平锁

  • 公平锁
    指多个线程按照申请锁的顺序来获取锁，按照先来先服务的原则。其落地实现可使用队列。

  • 非公平锁
    多个线程获取锁的方式不是按照申请锁的顺序，后申请锁的线程可以比先申请锁的线程先获得锁。

  • JUC下的ReentrantLock的构造boolean值参数为锁的种类，true为公平锁，false为非公平锁；
    代码如下：

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

公平锁和非公平锁的区别

1）公平锁在并发环境中获取锁时会查看锁维护的等待队列，如果队列为空，或者当前线程是等待队列的第一个，就占有锁，否则加入等待队列，按照FIFO等待获取锁。
2）非公平锁直接尝试占有锁，如果尝试失败，就在采用类似公平锁的方式获取锁。

注意：synchronized是一种非公平锁

synchronized与ReentrantLock的区别

可重入锁

  • 已获取锁的线程可以进入该锁锁住的同步代码；

  • 同一线程外层函数获得锁之后，内层递归函数仍然能获取锁的代码。同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

  • 可重入锁最大作用就是规避死锁；

代码示例

/*
 * 可重入锁（也就是递归锁）
 *
 * 指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，
 * 在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
 *
 * 也就是说，线程可以进入任何一个它已经拥有的锁所有同步着的代码块。
 *
 * t1   invoked sendSMS()      t1线程在外层方法获取锁的时候
 * t1   invoked sendEmail()    t1在进入内层方法会自动获取锁
 * t2   invoked sendSMS()
 * t2   invoked sendEmail()
 *
 */
public class RenenterLockDemo {
    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();
    }

}

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

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

可以证明synchronized是一种可重入锁；进入sendSMS方法后，还能再访问另外一个同步方法sendEmail；
也证明了sychronized锁的当前实例对象；

package com.juc;

import java.util.concurrent.locks.ReentrantLock;

public class ReentryLock {
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{
            phone.set();
        },"AAA").start();
        new Thread(()->{
            phone.set();
        },"BBB").start();
    }
}
class Phone{
    public ReentrantLock lock=new ReentrantLock();
    public void set(){
        lock.lock();
        try{
            System.out.println("set.....");
            get();
        }catch(Exception e){

        } finally{
            lock.unlock();
        }
    }
    public void get(){
        lock.lock();
        try{
            System.out.println("get....");
        }catch(Exception e){

        } finally{
            lock.unlock();
        }
    }
}

可以证明ReentrantLock 是一种可重入锁；进入set的同步代码后，还能再访问另外一个get方法里的代码块；

自旋锁

尝试获取锁的线程不会立刻阻塞，而是通过循环的方式等待获取锁。而不用再操作系统层面被挂起（用户态-》内核态），避免了上下文切换。
场景：线程执行任务的时间较短，可以较快的释放锁，在循环等待期间就可以获取到锁了。

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；

自旋锁代码示例

使用原子引用封装Thread,通过CAS算法实现线程的自旋锁

/**
 * 写一个自旋锁
 * 自旋锁的好处：循环比较获取直到成功为止，没有类似wait的阻塞。
 *
 * 通过CAS操作完成自旋锁：
 *  A线程先进来调用myLock方法自已持有锁5秒钟
 *  B随后进来后发现当前有线程持有锁，不是null，
 *  所以只能通过自旋等待，直至A释放锁后B随后抢到
 *
 * @ClassName SpinLockDemo
 * @Description TODO
 * @Author Heygo
 * @Date 2020/8/8 13:37
 * @Version 1.0
 */
public class SpinLockDemo {
    // 泛型为 Thread
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        // 获取当前线程
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in ");
        /*
         自旋：
            期望值为 null 表示当前没有线程
            新值为 thread ，即 Thread.currentThread()
          */
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    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(5);
            } 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();
    }
}
程序运行结果：核心为 CAS 算法
线程 A 先执行，此时期望值为 null ，线程 A 将获得锁，并将期望值设置为线程 A 自身
线程 B 尝试获取锁，发现期望值并不是 null ，就在那儿原地自旋
线程 A 释放锁之后，将期望值设置为 null ，此时线程 B 获得锁，将期望值设置为线程 B 自身
最后线程 B 释放锁3

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

  • 独占锁：指的是该锁一次只能被一个线程持有，对于ReentrantLock和synchronized都是独占锁。
  • 共享锁：该锁可以被多个线程共同持有。
  • ReentrantWriteReadLock其内部的读锁是共享锁，写锁是独占锁；
public class ReadWriteLockTest {
    public static void main(String[] args) {
        MyCache myCache=new MyCache();
        for (int i = 0; i < 5; i++) {
            final int index=i;
            new Thread(()->{
                myCache.put(String.valueOf(index),index);
            },String.valueOf(i)).start();
        }
        for (int i = 0; i < 5; i++) {
            final int index=i;
            new Thread(()->{
                myCache.get(String.valueOf(index));
            },String.valueOf(i)).start();
        }

    }
}
class MyCache{
    public volatile Map<String,Object> map=new HashMap<>();
    ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
    public void put(String key,Object value){
        lock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
            Thread.sleep(3000);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成");
        }catch(Exception e){

        } finally{
            lock.writeLock().unlock();
        }
    }
    public void get(String key){

        lock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"读取---");
            Object val=map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取结束result="+val);
        }catch(Exception e){

        } finally{
            lock.readLock().unlock();
        }
    }
}

程序运行结果：写操作没有被打断，读操作可以同时进行


1	 正在写入：1
1	 写入完成
2	 正在写入：2
2	 写入完成
4	 正在写入：4
4	 写入完成
3	 正在写入：3
3	 写入完成
0读取---
0读取结束result=0
1读取---
1读取结束result=1
2读取---
3读取---
3读取结束result=3
4读取---
2读取结束result=2
4读取结束result=4

ReentrantReadWriteLock源码

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;

分别维护了一个读锁，写锁；

另外Synchronized在锁升级的过程会涉及到一些锁、偏向锁、轻量级锁、重量级锁。
可以查看这篇博文
10分钟必懂-深入理解Synchronized关键字

问道玄霄
关注
专栏目录
Java并发编程（14）—— Java中的公平锁和非公平锁
shangjg3的博客
07-10 1060
在Synchronized中，当一个线程释放锁时，JVM会从等待队列中随机选择一个线程来获取锁，而不是按照申请锁的顺序来获取锁，因此Synchronized是一种非公平锁。在并发环境中，每一个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个就占有锁，否者就会加入到等待队列中，以后会按照 FIFO 的规则获取锁。Synchronized是Java中内置的锁机制，它的锁模式是非公平锁，这是因为Synchronized的实现方式是基于对象监视器（monitor）的。
JUC_公平锁/非公平锁/可重入锁/递归锁/自旋锁/读写锁
Chill Lyn
05-12 338
公平锁/非公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁，类似队列，先进先出 非公平锁是指在多线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象 ReentrantLock可以通过构造函数指定采用哪种方式，默认是非公平锁 非公平锁的优点是吞吐量比公平锁大 可重入锁（递归锁） 同一线程外层函数获得锁之后，内层递归函数仍然能获得该锁的代码，在同一线程的外层方法获取锁的时候，在进入内层方法会自动获取锁，也就是说，线程可以
公平锁和非公平锁
ycd500756的博客
01-08 602
转载于《Java多线程核心技术》 定义： 公平锁：按照线程加锁的顺序来分配，即先来先得FIFO； 非公平锁：一种获取锁的抢占机制，是随机的获得锁的，这样可能会有些线程一直会拿不到锁，结果也就是不公平的。 1.公平锁实例代码： package test.Thread4; import java.util.concurrent.locks.ReentrantLock; class Se
JAVA基础 | 一张图读懂非公平锁与公平锁
落红不是无情物
03-25 1193
在Java并发编程中，公平锁与非公平锁是很常见的概念，ReentrantLock、ReadWriteLock默认都是非公平模式，非公平锁的效率为何高于公平锁呢？究竟公平与非公平有何区别呢？ 首先先简单从名字上来理解，公平锁就是保障了多线程下各线程获取锁的顺序，先到的线程优先获取锁，而非公平锁则无法提供这个保障。看到网上很多说法说非公平锁获取锁时各线程的的概率是随机的，这也是一种很不确切的说法。非...
公平锁与非公平锁
weixin_30408675的博客
02-17 341
在ReentrantLock中很明显可以看到其中同步包括两种，分别是公平的FairSync和非公平的NonfairSync。公平锁的作用就是严格按照线程启动的顺序来执行的，不允许其他线程插队执行的；而非公平锁是允许插队的。 默认情况下ReentrantLock是通过非公平锁来进行同步的，包括synchronized关键字都是如此，因为这样性能会更好。因为从线程进入了RUNNA...
Java的锁机制。乐观锁/悲观锁、公平锁/非公平锁、可重入锁、独占锁/共享锁、互斥锁/读写锁、分段锁、锁的状态(偏向锁、轻量级锁、重量级锁)、自旋锁。Java中8种锁机制，一步到位！
m0_49690461的博客
07-18 693
Java锁的机制 一、公平锁/非公平锁 ​ 在ReentrantLock中包含了公平锁和非公平锁两种锁。 如果你用默认的构造函数来创建ReentrantLock对象，默认的锁策略就是非公平的。 1、公平锁 公平锁定义： ​ 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 公平锁优缺点： 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 公平锁图示： 图
一篇文章轻松搞懂Java中的自旋锁
08-26
`ReentrantLock`的公平模式在锁不可用时会立即尝试自旋，而非非公平模式下会先尝试快速获取锁。自旋锁与`synchronized`关键字相比，提供了更高的灵活性和更细粒度的控制，但也需要开发者更加关注锁的使用和性能调优...
阿里面试失败后，一气之下我图解了Java中18把锁
热门推荐
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
互斥锁、自旋锁、读写锁、条件锁、悲观锁、乐观锁
pipi糖的博客
04-30 980
一. 互斥锁（Mutex） 互斥锁用于控制多个线程对他们之间共享资源互斥访问的一个信号量。也就是说是为了避免多个线程在某一时刻同时操作（如修改）一个共享资源。如果占用共享资源的线程释放互斥量时，有一个以上的线程阻塞，那么所有该锁上的阻塞线程进入准备就绪状态（其中也包括释放锁的线程，该线程也会进入就绪队列），准备就绪状态的所有线程，通过竞争，进入运行状态，然后竞争获取锁资源。 二. 自旋锁（Mutex） 自旋锁是一种非阻塞锁，也就是说，如果某线程需要获取自旋锁，但该锁已经被其他线程占用时，该线程不会被挂起（不
公平锁和，公平锁，可重入锁（递归锁），自旋锁，读写锁
啦啦啦啦啦啦博客
01-05 271
自旋锁 手写自旋锁 运行结果： 独占锁，共享锁 ReentrantReadWriteLock读写锁。 例子（未加读写锁）： 结果，写操作应该为独占，不许被分割。 解决：加上ReentrantReadWriteLock 写操作加上一个写锁 读操作加上一个读锁： 结果： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值