互斥场景重入锁处理方案

处理方案一: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`
相关推荐
Dontla几秒前
Dockerfile解析器指令(Parser Directive)指定语法版本,如:# syntax=docker/dockerfile:1
java·docker·eureka
彭于晏Yan3 分钟前
SpringBoot优化树形结构数据查询
java·spring boot·后端
AAA修煤气灶刘哥19 分钟前
缓存这「加速神器」从入门到填坑,看完再也不被产品怼慢
java·redis·spring cloud
上位机付工21 分钟前
C#与倍福TwinCAT3进行ADS通信
开发语言·c#
练习时长一年25 分钟前
Spring事件监听机制(三)
java·后端·spring
月阳羊26 分钟前
【硬件-笔试面试题-69】硬件/电子工程师,笔试面试题(知识点:电机驱动电路的反馈电路)
java·经验分享·嵌入式硬件·面试
励志不掉头发的内向程序员30 分钟前
STL库——二叉搜索树
开发语言·c++·学习
2301_7813925234 分钟前
用spring框架实现简单的MVC业务
java·后端·spring
phltxy40 分钟前
SpringMVC 程序开发
java·后端·spring
至此流年莫相忘44 分钟前
设计模式:模板方法模式
java·开发语言·设计模式