互斥场景重入锁处理方案

乘风御浪云帆之上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`
相关推荐
Wang's Blog4 小时前
Java 项目实战: 外卖平台-启用禁用员工账号与Long精度丢失修复
java·服务器
乌暮4 小时前
Java 抽象类与接口详解：半成品图纸 vs 能力合同
java·开发语言·后端·学习
乐观的Terry4 小时前
ShipDesk 完整使用教程：从新建项目到 SSH 自动发布
开发语言
一条泥憨鱼4 小时前
苍穹外卖【day12| 工作台，通过Apache POI导入/导出运营数据】
java·后端·苍穹外卖
心平气和量大福大4 小时前
android-权限
android·java
006_4 小时前
ruoyi-vue-plus项目 minio外网访问配置
java
程序猿在线码字4 小时前
数据结构前置知识（java版）
java
步行cgn4 小时前
Spring 基于 XML 的自动装配：byType 详解
java·后端·spring
边境悍匪4 小时前
蜗牛学苑 Java 智能体学习 Day46｜贯穿项目 2 思维导图复盘
java·开发语言·vue.js·学习·spring
智慧物业老杨7 小时前
物业日常巡查的数智化重构：从“打卡式巡检“到“闭环式风控“
android·java·人工智能·系统架构·rxjava
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接04GitHub 镜像站点05微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新062026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？07人工智能（AI）发展史：详细里程碑08ZCode 周末送额度活动开启：3 亿 Token 免费领取09Telegram APK 下载安装完整指南 — 2026年最新102026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享