互斥场景重入锁处理方案

乘风御浪云帆之上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`
相关推荐
FreemanGordon4 分钟前
Java volatile 关键字
java
北京_宏哥5 分钟前
《手把手教你》系列基础篇（九十三）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-上篇（详解教程）
java·前端·selenium
鲤籽鲲13 分钟前
C# Enumerable类 之 数据排序
开发语言·c#·c# 知识捡漏
北京_宏哥13 分钟前
《手把手教你》系列基础篇（九十二）-java+ selenium自动化测试-框架设计基础-POM设计模式简介（详解教程）
java·selenium·前端工程化
*.✧屠苏隐遥(ﾉ◕ヮ◕)ﾉ*.✧13 分钟前
C语言_数据结构总结6：链式栈
c语言·开发语言·数据结构·算法·链表·visualstudio·visual studio
当归102423 分钟前
微服务与消息队列RabbitMQ
java·微服务
IT猿手24 分钟前
2025最新群智能优化算法：云漂移优化（Cloud Drift Optimization，CDO）算法求解23个经典函数测试集，MATLAB
开发语言·数据库·算法·数学建模·matlab·机器人
Lx35224 分钟前
《从头开始学java，一天一个知识点》之：循环结构：for与while循环的使用场景
java·后端
至暗时刻darkest28 分钟前
go mod文件 项目版本管理
开发语言·后端·golang
Cache技术分享29 分钟前
15. Java 如何声明一个变量来引用数组
java·前端
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04Coze扣子平台完整体验和实践（附国内和国际版对比）05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06本地部署DeepSeek教程（Mac版本）07如何本地部署AI智能体平台，带你手搓一个AI Agent08Windows 11 安装 Dify 完整指南 非docker环境09保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型10苍穹外卖面试总结