互斥场景重入锁处理方案

乘风御浪云帆之上2023-09-07 9:37

处理方案一: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
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南08在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）092025软件测试面试八股文（含答案+文档）10Labelme从安装到标注：零基础完整指南