互斥场景重入锁处理方案

最新推荐文章于 2024-07-08 14:58:49 发布
最新推荐文章于 2024-07-08 14:58:49 发布
阅读量187 收藏
点赞数
文章标签： java jvm 开发语言 互斥 重入锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eieiei438/article/details/132697300
版权

处理方案一:map+超时重入锁数据结构(注：该方案并发时可以获取到锁进行操作)

  • 核心逻辑模拟--加超时时间

    import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static void main(String[] args) {

        final Long adminId = 123L;
        final Map<Long, ReentrantLock> locks = Collections.synchronizedMap(new HashMap<>());

        new Thread(new Runnable() {
            @Override
            public void run() {
                ReentrantLock lock = locks.get(adminId);
                if (lock == null) {
                    lock = new ReentrantLock();
                    locks.put(adminId, lock);
                }
                try {
                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("11核心逻辑处理开始");
                            Thread.sleep(10000);
                            System.out.println("11核心逻辑处理结束");
                        } catch (Throwable e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("11已经上锁");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                ReentrantLock lock = locks.get(adminId);
                if (lock == null) {
                    lock = new ReentrantLock();
                    locks.put(adminId, lock);
                }
                try {
                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("22核心逻辑处理开始");
                            Thread.sleep(15000);
                            System.out.println("22核心逻辑处理结束");
                        } catch (Throwable e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("22已经上锁");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}
  • 并发问题结果数据 
    11核心逻辑处理开始
22核心逻辑处理开始
11核心逻辑处理结束
22核心逻辑处理结束
  • 问题
    • 问题：锁对象创建并发问题

处理方案二:map+不超时重入锁数据结构(注：该方案并发时可以获取到锁进行操作)

  • 核心逻辑模拟--不加超时时间

    import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static void main(String[] args) {

        final Long adminId = 123L;
        final Map<Long, ReentrantLock> locks = Collections.synchronizedMap(new HashMap<>());

        new Thread(new Runnable() {
            @Override
            public void run() {
                ReentrantLock lock = locks.get(adminId);
                if (lock == null) {
                    lock = new ReentrantLock();
                    locks.put(adminId, lock);
                }
                try {
//                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                    if (lock.tryLock()) {
                        try {
                            System.out.println("11核心逻辑处理开始");
                            Thread.sleep(2000);
                            System.out.println("11核心逻辑处理结束");
                        } catch (Throwable e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("11已经上锁");
                    }
                } catch (Throwable e){
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                ReentrantLock lock = locks.get(adminId);
                if (lock == null) {
                    lock = new ReentrantLock();
                    locks.put(adminId, lock);
                }
                try {
//                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                    if (lock.tryLock()) {
                        try {
                            System.out.println("22核心逻辑处理开始");
                            Thread.sleep(1000);
                            System.out.println("22核心逻辑处理结束");
                        } catch (Throwable e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("22已经上锁");
                    }
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}
  • 并发结果问题数据 
    11核心逻辑处理开始
22核心逻辑处理开始
22核心逻辑处理结束
11核心逻辑处理结束
  • 问题
    • 问题：锁对象创建并发问题，这个只是简化后的超时为0的重入锁对象，和方案一其实道理一样

处理方案三:map+单独重入锁对象数据结构--可行，但是不满足互斥账号场景；缺点：锁对象只有一个，不同的账号场景互斥场景不太适合

  • 核心逻辑

    import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static void main(String[] args) {

        final Long adminId = 123L;
        final Map<Long, ReentrantLock> locks = Collections.synchronizedMap(new HashMap<>());
        final ReentrantLock lockTemp = new ReentrantLock();

        new Thread(new Runnable() {
            @Override
            public void run() {
                ReentrantLock lock = locks.get(adminId);
                if (lock == null) {
                    lock = lockTemp;
                    locks.put(adminId, lockTemp);
                }
                try {
//                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                    if (lock.tryLock()) {
                        try {
                            System.out.println("11核心逻辑处理开始");
                            Thread.sleep(2000);
                            System.out.println("11核心逻辑处理结束");
                        } catch (Throwable e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("11已经上锁");
                    }
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                ReentrantLock lock = locks.get(adminId);
                if (lock == null) {
                    lock = lockTemp;
                    locks.put(adminId, lockTemp);
                }
                try {
//                    if (lock.tryLock(5, TimeUnit.SECONDS)) {
                    if (lock.tryLock()) {
                        try {
                            System.out.println("22核心逻辑处理开始");
                            Thread.sleep(1000);
                            System.out.println("22核心逻辑处理结束");
                        } catch (Throwable e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("22已经上锁");
                    }
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}
  • 结果数据 
    22核心逻辑处理开始
11已经上锁
22核心逻辑处理结束

处理方案四:map+重入锁对象数据结构+同步取塞对象--可行，满足互斥账号场景

  • 核心逻辑

    import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    final static Map<Long, ReentrantLock> locks = Collections.synchronizedMap(new HashMap<>());

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(123L);
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(123L);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(123L);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(123L);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(123L);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(123L);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(456L);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                methodZx(456L);

            }
        }).start();
    }

    public static void methodZx(Long adminId) {
        ReentrantLock lock = null;
        synchronized (adminId) {
            lock = locks.get(adminId);
            if (lock == null) {
                lock = new ReentrantLock();
                locks.put(adminId, lock);
            }
        }
        try {
            if (lock.tryLock()) {
                try {
                    System.out.println(adminId + "处理start");
                    Thread.sleep(5000);
                    System.out.println(adminId + "处理end");
                } catch (Throwable e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println(adminId + "--已经上锁");
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}
  • 结果数据 
    123处理start
123--已经上锁
123--已经上锁
456处理start
456--已经上锁
123--已经上锁
123--已经上锁
123--已经上锁
123处理end
456处理end
乘风御浪云帆之上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
跨平台中对于 互斥量(mutex) 的包装
景奇的专栏
11-02 1794
以下代码在跨平台环境下包装了互斥量(mutex)，支持以下平台 linux/windows，vc/gcc/mingw /** * @file - * @author jingqi * @date 2010-7-9 */ #ifndef ___HEADFILE___814FCD2E_2F65_4787_93E5_ECDE19588938_ #define ___HEADFILE___
如何理解互斥锁、条件锁、读写锁以及自旋锁？
果冻虾仁
10-16 993
锁是一个常见的同步概念，我们都听说过加锁（lock）或者解锁（unlock），当然学术一点地说法是获取（acquire）和释放（release）。 恰好pthread包含这几种锁的API，而C++11只包含其中的部分。接下来我将通过pthread的API来展开回答。 mutex（互斥量） mutex（mutual exclusive）即互斥量（互斥体）。也便是常说的互斥锁。 尽管名称不含lock，但是称之为锁，也是没有太大问题的。mutex无疑是最常见的多线程同步方式。其思想简单粗暴，多线程共享一
Linux详解 --- 多线程2: 线程互斥(互斥量的使用与原理、线程安全与可重入函数、死锁)
wuqiongjin的博客
04-12 882
线程互斥、互斥量的使用、互斥量的原理、线程安全与可重入函数、死锁、死锁的4个必要条件、预防死锁的措施、避免死锁的算法
各种互斥量的总结
星空漫野
04-26 2972
研究生阶段一直使用C++，到工作时，才接触到Java。写了这么多年的多线程程序，觉得对于互斥(注意，不是同步哦)的各种锁有必要做个总结。 这里我想将Windows，Linux和Java JVM三种环境中使用锁的环境及虽然将Windows，Linux和Java JVM放在一起比较是有些不合适的，但是对基于Windows操作系统C++，Linux操作系统C++及Java程序而言，在应用层面上来
自旋锁与互斥锁的使用场景分析
玩命的狙击手
03-30 1698
本文不对自旋锁和互斥锁的概念做阐述，重点分析它们之间的区别和自旋锁的使用场景。 自旋锁和互斥锁的区别 a. 互斥锁加锁失败后，线程会释放 CPU，给其他线程；自旋锁加锁失败后，线程会忙等待，直到它拿到锁； b. 自旋锁会关闭本CPU内核抢占，互斥锁不会. 问：为什么自旋锁要关闭本CPU内核抢占？ 答：加锁进程A获取一把自旋锁之后，开始执行临界区代码，此时发生了调度，执行进程B。恰巧进程B需要用到该自旋锁，这就导致了死锁的发生. 自旋锁和互斥锁的使用场景 a. 如果我们明确知道被锁住的代码的执行时间很短，那
自旋锁替代互斥锁使用场景
SuperHakce
11-22 6058
自旋锁替代互斥锁使用场景
Java中的锁机制 -- 乐观锁、悲观锁、自旋锁、可重入锁、读写锁、公平锁、非公平锁、共享锁、独占锁、重量级锁、轻量级锁、偏向锁、分段锁、互斥锁、同步锁、死锁、锁粗化、锁消除
天行健 君子以自强不息，地势坤 君子以厚德载物。
04-12 2250
乐观锁是一种乐观思想，假定当前环境是读多写少，遇到并发写的概率比较低，读数据时认为别的线程不会正在进行修改（所以没有上锁）。写数据时，判断当前与期望 值是否相同，如果相同则进行更新（更新期间加锁，保证是原子性的）。Java中的乐观锁：CAS（Compare And Set），比较并替换，比较当前值（主内存中的值），与预期值（当前线程中的值，主内存中值的一份拷贝）是否一样，一样则更新，否则继续进行CAS操作。如上图所示，乐观锁可以同时进行读操作，读的时候其他线程不能进行写操作。悲观锁是一种悲观思想，即认为写多
线程的互斥与同步、锁与信号量
lijianyi0219的博客
03-29 1199
文章目录前言一、互斥1、加锁互斥锁自旋锁读写锁乐观锁2、信号量概念实现互斥二、同步1、信号量总结 前言 我在阅读 “小林coding” 公众号的图解操作系统系列文章后感觉受益良多，因此进行一些小总结，方便日后查阅。本篇是针对线程间互斥与同步的实现方法进行的总结。 原文链接： 面试官：你说说互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景 多个线程为了同个资源打起架来了，该如何让他们安分？ 线程之间存在两种常见的协作关系：互斥和同步，为了实现进程/线程间正确的协作，操作系统必须提供实现线程协作的措施和方
互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景
热门推荐
小林coding
09-15 1万+
最常用的就是互斥锁，当然还有很多种不同的锁，比如自旋锁、读写锁、乐观锁等，不同种类的锁自然适用于不同的场景。 如果选择了错误的锁，那么在一些高并发的场景下，可能会降低系统的性能，这样用户体验就会非常差了。 所以，为了选择合适的锁，我们不仅需要清楚知道加锁的成本开销有多大，还需要分析业务场景中访问的共享资源的方式，再来还要考虑并发访问共享资源时的冲突概率。
Java乐观锁悲观锁、synchronized,重入锁 (ReentrantLock)处理并发（互斥同步、非互斥同步）
Mr_JK的专栏
11-24 5888
在Java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字经过编译 之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令，这两个字节 码都需要一个reference类型的参数来指明要锁定和解锁的对象。如果Java程序中的 synchronized明确指定了对象参数，那就是这个对象的reference；如果没有明确指定，那就根 据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或Class对象来作为锁对
Java分布式锁的三种实现方案
08-31
Java分布式锁是解决多节点、多服务之间共享资源互斥访问的一种技术手段，确保在分布式环境下数据的一致性和完整性。...在实际应用中，可能还需要考虑锁的公平性、可重入性、锁超时等问题，以及异常处理和死锁检测机制。
redis锁与zk锁机制处理
09-11
- 支持多种锁类型，如公平锁、可重入锁等。 - 可以与其他Redis功能结合，如发布/订阅、有序集合等。 缺点： - 需要额外的服务器资源，对Redis依赖较高。 - 如果Redis服务出现问题，可能导致整个分布式系统受影响。 ...
Mysql 行级锁的使用及死锁的预防方案
09-09
这个例子展示了如何在事务中使用排他锁处理用户提现操作。但需要注意，当一个表涉及到多个排他锁时，必须谨慎处理，以避免死锁。 死锁是两个或多个事务互相等待对方释放资源而形成的僵局。死锁发生的四个必要条件是...
缓存雪崩服务器雪崩的场景与解决方案.docx
10-26
1. 线程池隔离模式：使用一个线程池来存储当前的请求，线程池对请求作处理，设置任务返回处理超时时间，堆积的请求堆积入线程池队列。 2. 信号量隔离模式：使用一个原子计数器（或信号量）来记录当前有多少个线程在...
分布式锁架构设计方案.docx
05-17
示例 1-2 提供了一个重入锁的实现，通过在锁资源的名称后附加访问者的唯一标识（visitorId）和重入次数（reentrancyNum），确保同一访问者可以多次加锁而不违反互斥性。加锁脚本检查锁的存在性，更新重入计数并设置...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 559
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 822
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
解决分布式环境下session共享问题
shenxiaomo1688的博客
07-06 988
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 224
【代码】springboot中抽离日志。
redis击穿 互斥锁
09-07
在处理Redis缓存击穿问题时，可以采用互斥锁的方式进行解决。互斥锁是一种机制，用于保护共享资源的访问，确保同一时刻只有一个线程能够获取锁来执行操作。在Redis缓存击穿的场景中，当一个高并发的请求发生时，如果缓存中不存在所需的数据，那么这个请求就会触发数据库的查询操作。 针对这种情况，我们可以引入互斥锁的概念来解决Redis缓存击穿问题。具体做法是，在查询缓存之前，先尝试获取互斥锁。如果获取到了锁，表示当前线程是第一个发起请求的线程，它可以继续执行查询数据库的操作，并将结果写入缓存。而其他线程在获取锁之前，只能等待一段时间后再次尝试获取锁。 为了实现这个逻辑，我们可以定义获取互斥锁的方法和释放锁的方法。获取互斥锁的方法可以使用Redis提供的setIfAbsent()方法来进行操作，设置一个键值对，如果该键不存在，则设置成功，并返回true；否则，返回false。释放锁的方法则是删除相应的键值对。 通过使用互斥锁，能够在高并发的情况下有效地控制对数据库的访问，避免出现缓存击穿的问题。这种方案在逻辑上实现了对缓存穿透和击穿的处理，并且可以封装为一个工具类，适用于各种场景。 引用内容: 代码片段，定义了获取互斥锁和释放锁的方法 Redis缓存穿透和击穿的处理方案 描述了使用互斥锁来解决缓存击穿问题的过程 提到了缓存击穿问题的本质和影响，引用了一个Redis教程中的PPT内容<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乘风御浪云帆之上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值