互斥场景重入锁处理方案

乘风御浪云帆之上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`
相关推荐
customer0822 分钟前
【开源免费】基于SpringBoot+Vue.JS体育馆管理系统（JAVA毕业设计）
java·vue.js·spring boot·后端·开源
Miketutu1 小时前
Spring MVC消息转换器
java·spring
乔冠宇1 小时前
Java手写简单Merkle树
java·区块链·merkle树
LUCIAZZZ2 小时前
简单的SQL语句的快速复习
java·数据库·sql
来恩10032 小时前
C# 类与对象详解
开发语言·c#
komo莫莫da2 小时前
寒假刷题Day19
java·开发语言
ElseWhereR3 小时前
C++ 写一个简单的加减法计算器
开发语言·c++·算法
S-X-S3 小时前
算法总结-数组/字符串
java·数据结构·算法
linwq83 小时前
设计模式学习(二)
java·学习·设计模式
※DX3906※4 小时前
cpp实战项目—string类的模拟实现
开发语言·c++
热门推荐
01DeepSeek r1本地安装全指南02【deepseek】deepseek-r1本地部署-第一步：下载LM Studio03将DeepSeek接入Word，打造AI办公助手04使用Ollama 在Ubuntu运行deepseek大模型：以DeepSeek-coder为例05新鲜速递：DeepSeek-R1开源大模型本地部署实战—Ollama + MaxKB 搭建RAG检索增强生成应用06Dell服务器升级ubuntu 22.04失败解决07DeepSeek学术写作测评第一弹：论文润色，中译英效果如何？08如何解压7z文件？8种方法（Win/Mac/手机/网页端）09半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)10DeepSeek 云端部署，释放无限 AI 潜力！