互斥场景重入锁处理方案

处理方案一: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`
相关推荐
mjhcsp5 分钟前
C++ long long 类型深度解析:大整数处理的基石
开发语言·c++·策略模式·long long
oak隔壁找我6 分钟前
RabbitMQ 实现延迟通知的完整方案
java·后端
信码由缰10 分钟前
Java的优势有哪些
java
trow17 分钟前
ConcurrentHashMap线程安全实现详解
java·后端
trow17 分钟前
HashMap核心原理与源码剖析
java·后端
YuanlongWang22 分钟前
C# 设计模式——工厂模式
开发语言·设计模式·c#
VB.Net29 分钟前
VB.Net循序渐进(第二版)
开发语言·.net·vb.net
埃伊蟹黄面35 分钟前
深入理解STL关联容器:map/multimap与set/multiset全解析
开发语言·c++
21号 137 分钟前
4.客户端(Redis)
开发语言·数据库·github
可观测性用观测云1 小时前
云原生架构下微服务接入 SkyWalking 最佳实践
java