公平锁/非公平锁/可重入锁/递归锁/自旋锁

最新推荐文章于 2022-11-02 08:53:20 发布
最新推荐文章于 2022-11-02 08:53:20 发布
阅读量204 收藏
点赞数
分类专栏： 复习 文章标签： java 并发编程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45607513/article/details/119181689
版权

公平和非公平锁

  • 公平锁：是指多个线程按照申请锁的顺序获取锁。先来后到。
  • 非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发下，有可能会造成优先级反转或者饥饿现象。

非公平锁的优点在于吞吐量比公平锁大。
ReentrantLock默认是非公平锁

Lock lock = new ReentrantLock();

public ReentrantLock() {
        sync = new NonfairSync();
    }

其有两个构造器。无参构造会创建一个非公平锁。
有参构造的参数是一个boolean值，true是公平锁，false是非公平锁(和无参构造一样)。

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

对于synchronized而言，也是一种非公平锁。

可重入锁(递归锁)

可重入锁(也叫递归锁)。
指的是线程获取锁之后，可以再次获取锁而不会发生死锁。

也就是获取锁之后进入method1方法，调用的method2方法(此时method2也有锁)，只不过method1和method2是一把锁。

举个现实生活中的例子：到家时用钥匙打开门后，就可以直接进入厨房或者卫生间。而不需要在用其他钥匙。

public sync method1(){
	method2();
}
public sync method2(){}

可重入锁最大的作用就是解决死锁问题。

ReentrantLock和synchronized都是可重入锁。

代码演示

此代码借用了博主https://blog.csdn.net/w8y56f/article/details/89554060的代码。
synchronized

package locks;

/*
*   可重入锁(也叫递归锁)
*   是指同一线程中，外层函数获取锁之后，在内层递归函数仍然能获取该锁的代码。
*   在同一线程在外层获取锁的时候，在进入内层方法会自动获取锁。
*
*   也就是说，线程可以进入任何一个它拥有锁所同步的代码块。
*
* */
public class ReentrantLockDemo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (this){
                    System.out.println("第1次获取锁，这个锁是："+this);
                    int index = 1;
                    while (true){
                        synchronized (this){
                            System.out.println("第"+(++index)+"次获取锁，这个锁是："+this);
                        }
                        if(index == 10){
                            break;
                        }
                    }
                }
            }
        }).start();
    }
}

可以看到，同一个线程可以多次获取锁，而且没有发生死锁。
在这里插入图片描述

ReentrantLock

package locks;

import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo2 {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    lock.lock();
                    System.out.println("第1次获取锁，这个锁是："+lock);

                    int index = 1;
                    while (true){

                        try{
                            lock.lock();
                            System.out.println("第"+(++index)+"次获取锁，这个锁是："+lock);

                            try{
                                Thread.sleep(new Random().nextInt(200));
                            }catch (Exception e){
                                e.printStackTrace();
                            }

                            if(index == 10){
                                break;
                            }

                        }finally {
                            lock.unlock();
                        }

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

}

在这里插入图片描述
注意：使用ReentrantLock，加锁和解锁必须是成对出现的。
例
正常情况

package locks;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T1 implements Runnable{
    Lock lock = new ReentrantLock();

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

    public void set(){

        lock.lock();

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

    }

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

    public static void main(String[] args) {

        T1 t1 = new T1();

        Thread t3 = new Thread(t1);
        Thread t4 = new Thread(t1);
        t3.start();
        t4.start();
    }

}

在这里插入图片描述

加锁比解锁多，会导致t4线程卡死，也就是说多出的lock，还没有释放锁，自然而然t4会一直等待。

package locks;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T1 implements Runnable{
    Lock lock = new ReentrantLock();

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

    public void set(){

        lock.lock();

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

    }

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

    public static void main(String[] args) {

        T1 t1 = new T1();

        Thread t3 = new Thread(t1);
        Thread t4 = new Thread(t1);
        t3.start();
        t4.start();
    }

}

在这里插入图片描述
解锁比加锁多：会直接运行出错。

package locks;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T1 implements Runnable{
    Lock lock = new ReentrantLock();

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

    public void set(){

        lock.lock();

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

    }

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

    public static void main(String[] args) {

        T1 t1 = new T1();

        Thread t3 = new Thread(t1);
        Thread t4 = new Thread(t1);
        t3.start();
        t4.start();
    }

}

在这里插入图片描述

自旋锁

自旋锁指的是尝试获取锁的线程不会立即阻塞，而是会通过循环不断的去尝试获取锁。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

代码验证
package locks;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class SpinDemo {
    //原子引用线程  初始值null
    AtomicReference<Thread> reference = new AtomicReference<>();


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

        //如果当前没有线程占用锁，则自己占用。 atomicInteger中cas思想
        while (!reference.compareAndSet(null,thread)){

            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"\t 自旋");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }

    }

    public void myunlock(){

        Thread thread = Thread.currentThread();
        //解锁操作，如果自己用完锁，则替换为null
        reference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t invoked myunlock");

    }

    public static void main(String[] args) {

        SpinDemo spinDemo = new SpinDemo();

        new Thread(()->{

            spinDemo.mylock();

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

            spinDemo.myunlock();

        },"t1").start();

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

        new Thread(()->{
            spinDemo.mylock();
            spinDemo.myunlock();
        },"t2").start();

    }




}

在这里插入图片描述
t1在占用锁的时间里，t2一直会尝试获取锁。

丿沐染烟忱丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java锁之可重入锁介绍
09-04
主要介绍了Java锁之可重入锁介绍,可重入锁,也叫做递归锁,指的是同一线程外层函数获得锁之后,内层递归函数仍然有获取该锁的代码,但不受影响,需要的朋友可以参考下
Python多线程操作之互斥锁、递归锁、信号量、事件实例详解
09-17
主要介绍了Python多线程操作之互斥锁、递归锁、信号量、事件,结合实例形式详细分析了Python多线程操作互斥锁、递归锁、信号量、事件相关概念、原理、用法与操作注意事项,需要的朋友可以参考下
公平锁/非公平锁/可重入锁/递归锁/自旋锁/独占锁/共享锁/互斥锁
weixin_42480780的博客
05-11 465
1. 公平锁和非公平锁 公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭 ，先来后到。 非公平锁：是指在多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象。 对于synchronized而言 也是一种非公平锁。 并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁 默认是非公平锁。 空参构造器：非公平锁 带参构造器：公平锁 2. 可重入锁（又名递归锁
Linux 互斥锁 递归锁 自旋锁 读写锁
Sakuya__的博客
09-06 3341
锁是什么，我们为什么要用到锁？回到问题的本质，我们在什么场景下会用到锁，是在针对于公共资源，也就是临界资源的使用。对于多线程编程，当两个或多个线程同时访问或对一个临界资源操作的时候，为了防止出现数据不一致的问题，我们在使用之前要进行加锁，使用完后进行解锁。 ...
公平锁、非公平锁、可重入锁、递归锁、自旋锁
小王同学的博客
09-01 200
公平锁、非公平锁 什么是公平锁与非公平锁？ 公平锁：先来先服务。 非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先级获取锁在高并发的情况下，有可能会造成优先级反转或者饥饿现象。 默认是非公平锁，非公平锁的优点在于比公平锁大。 如何设置公平锁？ //参数默认是false，表示非公平锁，参数为true时，表示为公平锁。 ReentrantLock re = new ReentrantLock(true); ReentrantLock re1 = new
Java中的公平锁和非公平锁实现详解
热门推荐
平菇虾饺
04-24 3万+
Java语言中有许多原生线程安全的数据结构，比如`ArrayBlockingQueue`、`CopyOnWriteArrayList`、，它们的实现方式并非通过`synchronized`关键字，而是通过`java.util.concurrent.locks.ReentrantLock`来实现。 本博客着重讲述ReentrantLock的可重入性原理、公平/非公平实现、内存可见性原理。
自旋锁、互斥锁、信号量、读写锁、递归锁、乐观锁、悲观锁的底层实现
u011495684的博客
06-22 801
自旋锁、互斥锁、信号量、读写锁、递归锁、乐观锁、悲观锁(一) 我们知道 每个操作系统都有这样一些锁，各个锁之间好像可以互相转换，但概念上又总是模棱两可。下面从Linux系统对这些锁的实现方式下手，谈一下这些锁之间的联系。 原子性:一条汇编指令的执行过程中是原子性的，cpu不可能将一条汇编语言执行一半，然后去执行别的汇编指令。这称为原子性，及，一条汇编语言就是cpu最小的执行时间单位，不可以分割，执行的时候不可暂停。因此，实现单一变量的原子读写操作是容易的，只要保证读写操作只对应一条汇编语言即可。 但是，很多
线程，线程锁，递归锁及队列，消费者模式（转自Alex li）
05-19
线程，线程锁，递归锁及队列，消费者模式（转自Alex li）
锁链 非递归做法C++.zip
06-22
但是你能否找到一个非递归算法呢？ 【输入输出】 输入：环的总数n。 输出：为尽量体现程序输出结果的层次，要求按照从n、n-1、n-2、……、1的顺序，将移除掉n号环的全部过程作为一个段落输出，然后将移除n-1号环的...
大白话聊聊Java并发面试问题之公平锁与非公平锁是啥？
lxltmac的博客
12-07 1024
一、写在前面   上篇文章（《大白话聊聊Java并发面试问题之谈谈你对AQS的理解？》）聊了一下java并发包中的AQS的工作原理，也间接说明了ReentrantLock的工作原理。   这篇文章接着来聊一个话题，java并发包中的公平锁与非公平锁有啥区别？     二、什么是非公平锁？   先来聊聊非公平锁是啥，现在大家先回过头来看下面这张图。   如上图，现在线程1加...
公平锁和非公平锁有什么区别
文盲青年的博客
06-04 553
公平锁 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点 所有的线程都能得到资源，不会饿死在队列中。 缺点 吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 非公平锁 多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。 优点 可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必唤醒所有线程，会减少唤起线程的数量。 缺点 可能导致队列中间的线程一直获取不
公平锁和非公平锁
小菜椒的博客
09-15 3884
公平锁和非公平锁 公平锁―是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁 在高并发的情况下，有可能会造成优先级反转或者饥饿现象 并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁 公平锁和非公平锁的区别： 1.公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个
自旋锁 互斥锁 读写锁 递归锁
DDR的专栏
09-18 4815
这几个锁的概念各有交叉，容易混淆 互斥锁： 最常使用于线程同步的锁；标记用来保证在任一时刻，只能有一个线程访问该对象，同一线程多次加锁操作会造成死锁；临界区和互斥量都可用来实现此锁，通常情况下锁操作失败会将该线程睡眠等待锁释放时被唤醒 自旋锁： 同样用来标记只能有一个线程访问该对象，在同一线程多次加锁操作会造成死锁；使用硬件提供的swap指令或test_and_set指令实现；
常⻅锁策略（1. 乐观锁 & 悲观锁2. 公平锁 & 非公平锁3. 读写锁4. 可重入锁 & 自旋锁）
m0_48273471的博客
04-18 782
1. 乐观锁 & 悲观锁 2. 公平锁 & 非公平锁 3. 读写锁 4. 可重入锁 & 自旋锁
公平锁与非公平锁的核心原理
小威的博客
11-02 1万+
本篇文章是关于并发编程中AQS的独占模式和共享模式，感兴趣的大佬可以前来围观哦。
嵌入式 自旋锁、互斥锁、读写锁、递归锁
weixin_33919941的博客
04-12 225
互斥锁(mutexlock)： 最常使用于线程同步的锁；标记用来保证在任一时刻，只能有一个线程访问该对象，同一线程多次加锁操作会造成死锁；临界区和互斥量都可用来实现此锁，通常情况下锁操作失败会将该线程睡眠等待锁释放时被唤醒 自旋锁(spinlock)： 同样用来标记只能有一个线程访问该对象，在同一线程多次加锁操作会造成死锁；使用硬件提供的swap指令或test_and_set指令实现；同互斥...
【图解】【源码】公平锁⾮公平锁
zhangxiaohui4445的博客
12-01 411
公平锁 概念 所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。在获取锁的自由状态时，若锁可获取不会直接获取该锁，而是需要判断是否需要入队（AQS）。 图解 由如下图可知，tn线程创建成功，进行锁状态的判断，当能获取自由状态时，需要判断是否需要入队，若不需要直接进行加锁成功，若需要进行入队操作。获取锁流程的源码后续会有专门的章节来详细讲述。 源码 从代码中也清楚的看到，没有直接持有锁的操作，而是对队列进行操作。 本文中只了解是对队列的操作即可，后续有专门文章对队列操..
lock底层源码
weixin_46919552的博客
06-29 306
ReetrantLock底层源码
iOS 开发中的八种锁（Lock）
努力，可能成功！放弃，注定失败！
08-29 1万+
锁之前的性能的图表： lock_benchmark.png 发现除了@synchronized 用过,其他的都陌生的很，可以说完全不知道啥玩意儿~ 于是怀着惭愧的心情赶紧把这些锁学习了下，废话不多说，我们开始: 锁 是什么意思？ 我们在使用多线程的时候多个线程可能会访问同一块资源，这样就很容易引发数据错乱和数据安全等问题，这时候就需要我们保证每次只有一个线程访问这一块
可重入锁和不可重入锁
最新发布
03-21
可重入锁也被称为递归锁，它允许同一个线程多次获取同一个锁而不会造成死锁。当一个线程已经持有了该锁时，它可以再次获取该锁而不会被阻塞。可重入锁通过记录持有锁的线程和计数器来实现。每次获取锁时，计数器加1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值