java key锁 实现对某个key（字符串）加同步锁 带详细注释

已于 2022-08-14 10:49:40 修改
阅读量3.1k 收藏 10
点赞数 8
分类专栏： java 文章标签： java redis 开发语言
于 2022-08-13 17:57:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010756046/article/details/126321364
版权

相信大家都用过Redis分布式锁吧 Redis分布式锁是对某个字符串来进行上锁的 用起来嘎嘎爽
于是我就想能不能自己实现一个根据key来同步的锁？下面为该锁的实现过程

若有线程安全问题或者是讲解不到位的地方，欢迎各位大佬指正。

话不多说直接开搞

首先先写一个锁

static final class Lock extends ReentrantLock {

        /**
         * 正在使用或者是准备使用该锁的数量
         */
        int using;

        /**
         * 锁的有参构造函数
         *
         * @param fair 是否公平
         */
        Lock(boolean fair) {
            super(fair);
        }
    }

这个类比较简单 继承自java.util.concurrent.locks.ReentrantLock
然后给他一个using属性

KeyLock
package cn.liziguo.util.concurrent;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Liziguo
 * @date 2022/8/12 11:15
 */
public class KeyLock<K> {

    final ConcurrentHashMap<K, Lock> map = new ConcurrentHashMap<>();

    /**
     * 是否公平锁
     */
    final boolean fair;

    /**
     * 无参构造函数 默认使用非公平锁
     */
    public KeyLock() {
        fair = false;
    }

    /**
     * 有参构造函数指定是否使用公平锁
     *
     * @param fair 是否公平
     */
    public KeyLock(boolean fair) {
        this.fair = fair;
    }

    /**
     * 从map里获取锁 如果存在则返回 不存在则创建
     * 并使其using++
     *
     * @param key key
     * @return lock
     */
    Lock getLock(K key) {
        return map.compute(key, (k, lock) -> {
            if (lock == null) {
                lock = new Lock(fair);
            }
            lock.using++;
            return lock;
        });
    }

    /**
     * 获取锁 会阻塞
     *
     * @param key key
     */
    public void lock(K key) {
        getLock(key).lock();
    }

    /**
     * 尝试获取锁 不阻塞
     *
     * @param key key
     * @return 获取成功返回true
     */
    public boolean tryLock(K key) {
        AtomicBoolean b = new AtomicBoolean();
        map.compute(key, (k, lock) -> {
            if (lock == null) {
                lock = new Lock(fair);
            }
            // 由于tryLock是非阻塞的 我们可以直接在map里进行调用
            if (lock.tryLock()) {
                // 只有申请成功了才使using++
                lock.using++;
                // 把结果传递到外部
                b.set(true);
            }
            return lock;
        });
        return b.get();
    }

    /**
     * 尝试获取锁 并指定时间
     *
     * @param key     key
     * @param timeout 过期时间
     * @param unit    时间单位
     * @return 获取成功返回true
     */
    public boolean tryLock(K key, long timeout, TimeUnit unit) {
        Lock lock = getLock(key);
        boolean b;
        try {
            b = lock.tryLock(timeout, unit);
        } catch (InterruptedException e) {
            b = false;
        }
        if (!b) {
            // 如果锁获取失败 则判断该锁是否被其他进程使用
            map.computeIfPresent(key, (k, oldLock) -> {
                // 看看别的地方有没有用着这个锁
                if (--oldLock.using == 0) {
                    // 如果没有 就释放内存
                    return null;
                } else {
                    // 否则不管
                    return oldLock;
                }
            });
        }
        return b;
    }

    /**
     * 释放锁 必须由申请锁的线程进行调用
     *
     * @param key key
     */
    public void unlock(K key) {
        map.computeIfPresent(key, (k, lock) -> {
            // 释放锁
            lock.unlock();
            // 看看别的地方有没有用着这个锁
            if (--lock.using == 0) {
                // 如果没有 就释放内存
                return null;
            } else {
                // 否则不管
                return lock;
            }
        });
    }

    static final class Lock extends ReentrantLock {

        /**
         * 正在使用或者是准备使用该锁的数量
         */
        int using;

        /**
         * 锁的有参构造函数
         *
         * @param fair 是否公平
         */
        Lock(boolean fair) {
            super(fair);
        }
    }

}

主要是借助java.util.concurrent.ConcurrentHashMap处理线程安全问题

用法

现在这个类的基本功能已经实现并且可以使用了
用法也很简单：

    public static void main(String[] args) {
        KeyLock<String> keyLock = new KeyLock<>();

        final String key = "lock:user_id:" + 10001;

        keyLock.lock(key);
        try {
            System.out.println("哈哈哈");
        } finally {
            keyLock.unlock(key);
        }
    }
扩展api

在此基础上提供几个api提高易用性

    public void lockExecute(K key, Runnable runnable) {
        lock(key);
        try {
            runnable.run();
        } finally {
            unlock(key);
        }
    }

    public <T> T lockExecute(K key, Supplier<T> supplier) {
        lock(key);
        try {
            return supplier.get();
        } finally {
            unlock(key);
        }
    }

    public boolean tryLockExecute(K key, Runnable runnable) {
        if (tryLock(key)) {
            try {
                runnable.run();
                return true;
            } finally {
                unlock(key);
            }
        }
        return false;
    }

    public <T> T tryLockExecute(K key, T failResult, Supplier<T> supplier) {
        if (tryLock(key)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

用法：

    public static void main(String[] args) {
        KeyLock<String> keyLock = new KeyLock<>();

        final String key = "lock:user_id:" + 10001;

        keyLock.lockExecute(key, () -> System.out.println("哈哈哈"));
    }
完整代码
package cn.liziguo.util.concurrent;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.*;

/**
 * @author Liziguo
 * @date 2022/8/12 11:15
 */
public class KeyLock<K> {

    final ConcurrentHashMap<K, Lock> map = new ConcurrentHashMap<>();

    /**
     * 是否公平锁
     */
    final boolean fair;

    /**
     * 无参构造函数 默认使用非公平锁
     */
    public KeyLock() {
        fair = false;
    }

    /**
     * 有参构造函数指定是否使用公平锁
     *
     * @param fair 是否公平
     */
    public KeyLock(boolean fair) {
        this.fair = fair;
    }

    /**
     * 从map里获取锁 如果存在则返回 不存在则创建
     * 并使其using++
     *
     * @param key key
     * @return lock
     */
    Lock getLock(K key) {
        return map.compute(key, (k, lock) -> {
            if (lock == null) {
                lock = new Lock(fair);
            }
            lock.using++;
            return lock;
        });
    }

    /**
     * 获取锁 会阻塞
     *
     * @param key key
     */
    public void lock(K key) {
        getLock(key).lock();
    }

    /**
     * 尝试获取锁 不阻塞
     *
     * @param key key
     * @return 获取成功返回true
     */
    public boolean tryLock(K key) {
        AtomicBoolean b = new AtomicBoolean();
        map.compute(key, (k, lock) -> {
            if (lock == null) {
                lock = new Lock(fair);
            }
            // 由于tryLock是非阻塞的 我们可以直接在map里进行调用
            if (lock.tryLock()) {
                // 只有申请成功了才使using++
                lock.using++;
                // 把结果传递到外部
                b.set(true);
            }
            return lock;
        });
        return b.get();
    }

    /**
     * 尝试获取锁 并指定时间
     *
     * @param key     key
     * @param timeout 过期时间
     * @param unit    时间单位
     * @return 获取成功返回true
     */
    public boolean tryLock(K key, long timeout, TimeUnit unit) {
        Lock lock = getLock(key);
        boolean b;
        try {
            b = lock.tryLock(timeout, unit);
        } catch (InterruptedException e) {
            b = false;
        }
        if (!b) {
            // 如果锁获取失败 则判断该锁是否被其他进程使用
            map.computeIfPresent(key, (k, oldLock) -> {
                // 看看别的地方有没有用着这个锁
                if (--oldLock.using == 0) {
                    // 如果没有 就释放内存
                    return null;
                } else {
                    // 否则不管
                    return oldLock;
                }
            });
        }
        return b;
    }

    /**
     * 释放锁 必须由申请锁的线程进行调用
     *
     * @param key key
     */
    public void unlock(K key) {
        map.computeIfPresent(key, (k, lock) -> {
            // 释放锁
            lock.unlock();
            // 看看别的地方有没有用着这个锁
            if (--lock.using == 0) {
                // 如果没有 就释放内存
                return null;
            } else {
                // 否则不管
                return lock;
            }
        });
    }

    public void lockExecute(K key, Runnable runnable) {
        lock(key);
        try {
            runnable.run();
        } finally {
            unlock(key);
        }
    }

    public boolean lockExecute(K key, BooleanSupplier supplier) {
        lock(key);
        try {
            return supplier.getAsBoolean();
        } finally {
            unlock(key);
        }
    }

    public int lockExecute(K key, IntSupplier supplier) {
        lock(key);
        try {
            return supplier.getAsInt();
        } finally {
            unlock(key);
        }
    }

    public long lockExecute(K key, LongSupplier supplier) {
        lock(key);
        try {
            return supplier.getAsLong();
        } finally {
            unlock(key);
        }
    }

    public double lockExecute(K key, DoubleSupplier supplier) {
        lock(key);
        try {
            return supplier.getAsDouble();
        } finally {
            unlock(key);
        }
    }

    public <T> T lockExecute(K key, Supplier<T> supplier) {
        lock(key);
        try {
            return supplier.get();
        } finally {
            unlock(key);
        }
    }

    public boolean tryLockExecute(K key, Runnable runnable) {
        if (tryLock(key)) {
            try {
                runnable.run();
                return true;
            } finally {
                unlock(key);
            }
        }
        return false;
    }

    public boolean tryLockExecute(K key, boolean failResult, BooleanSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsBoolean();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public int tryLockExecute(K key, int failResult, IntSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsInt();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public long tryLockExecute(K key, long failResult, LongSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsLong();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public double tryLockExecute(K key, double failResult, DoubleSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsDouble();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public <T> T tryLockExecute(K key, T failResult, Supplier<T> supplier) {
        if (tryLock(key)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public boolean tryLockExecute(K key, BooleanSupplier failSupplier, BooleanSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsBoolean();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsBoolean();
    }

    public int tryLockExecute(K key, IntSupplier failSupplier, IntSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsInt();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsInt();
    }

    public long tryLockExecute(K key, LongSupplier failSupplier, LongSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsLong();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsLong();
    }

    public double tryLockExecute(K key, DoubleSupplier failSupplier, DoubleSupplier supplier) {
        if (tryLock(key)) {
            try {
                return supplier.getAsDouble();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsDouble();
    }

    public <T> T tryLockExecute(K key, Supplier<T> failSupplier, Supplier<T> supplier) {
        if (tryLock(key)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.get();
    }

    public boolean tryLockExecute(K key, long timeout, Runnable runnable) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                runnable.run();
                return true;
            } finally {
                unlock(key);
            }
        }
        return false;
    }

    public boolean tryLockExecute(K key, long timeout, boolean failResult, BooleanSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsBoolean();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public int tryLockExecute(K key, long timeout, int failResult, IntSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsInt();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public long tryLockExecute(K key, long timeout, long failResult, LongSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsLong();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public double tryLockExecute(K key, long timeout, double failResult, DoubleSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsDouble();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public <T> T tryLockExecute(K key, long timeout, T failResult, Supplier<T> supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public boolean tryLockExecute(K key, long timeout, BooleanSupplier failSupplier, BooleanSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsBoolean();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsBoolean();
    }

    public int tryLockExecute(K key, long timeout, IntSupplier failSupplier, IntSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsInt();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsInt();
    }

    public long tryLockExecute(K key, long timeout, LongSupplier failSupplier, LongSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsLong();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsLong();
    }

    public double tryLockExecute(K key, long timeout, DoubleSupplier failSupplier, DoubleSupplier supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.getAsDouble();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsDouble();
    }

    public <T> T tryLockExecute(K key, long timeout, Supplier<T> failSupplier, Supplier<T> supplier) {
        if (tryLock(key, timeout, TimeUnit.MILLISECONDS)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.get();
    }

    public boolean tryLockExecute(K key, long timeout, TimeUnit unit, Runnable runnable) {
        if (tryLock(key, timeout, unit)) {
            try {
                runnable.run();
                return true;
            } finally {
                unlock(key);
            }
        }
        return false;
    }

    public boolean tryLockExecute(K key, long timeout, TimeUnit unit, boolean failResult, BooleanSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsBoolean();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public int tryLockExecute(K key, long timeout, TimeUnit unit, int failResult, IntSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsInt();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public long tryLockExecute(K key, long timeout, TimeUnit unit, long failResult, LongSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsLong();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public double tryLockExecute(K key, long timeout, TimeUnit unit, double failResult, DoubleSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsDouble();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public <T> T tryLockExecute(K key, long timeout, TimeUnit unit, T failResult, Supplier<T> supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failResult;
    }

    public boolean tryLockExecute(K key, long timeout, TimeUnit unit, BooleanSupplier failSupplier, BooleanSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsBoolean();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsBoolean();
    }

    public int tryLockExecute(K key, long timeout, TimeUnit unit, IntSupplier failSupplier, IntSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsInt();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsInt();
    }

    public long tryLockExecute(K key, long timeout, TimeUnit unit, LongSupplier failSupplier, LongSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsLong();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsLong();
    }

    public double tryLockExecute(K key, long timeout, TimeUnit unit, DoubleSupplier failSupplier, DoubleSupplier supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.getAsDouble();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.getAsDouble();
    }

    public <T> T tryLockExecute(K key, long timeout, TimeUnit unit, Supplier<T> failSupplier, Supplier<T> supplier) {
        if (tryLock(key, timeout, unit)) {
            try {
                return supplier.get();
            } finally {
                unlock(key);
            }
        }
        return failSupplier.get();
    }

    static final class Lock extends ReentrantLock {

        /**
         * 正在使用或者是准备使用该锁的数量
         */
        int using;

        /**
         * 锁的有参构造函数
         *
         * @param fair 是否公平
         */
        Lock(boolean fair) {
            super(fair);
        }
    }

}

都看到这了 点赞+关注一波咯

李子果
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
autohotkey-scripts:有用的带有注释的AutoHotkey操作
03-06
1. **AutoHotkey基本概念**：AutoHotkey是一个开源工具，允许用户创建自定义的热键、热字符串和宏来自动化重复性任务。它的语法简洁易懂，适合初学者和高级用户。 2. **脚本注释**：压缩包中的脚本带有注释，这对于...
java如何实现对同一个字符串key加锁，不同字符串key支持并发 处理
coderyqwh的博客
04-23 795
【代码】java如何实现对同一个字符串key加锁，不同字符串key支持并发 处理。
字符串为什么不建议作为synchronized的锁对象
weixin_45500957的博客
06-07 1120
使用特定的锁对象而不是字符串进行同步是推荐的最佳实践。这种方式避免了字符串常量池带来的潜在问题，确保锁的唯一性和同步操作的安全性。在多线程环境中，这样的做法可以避免意外的锁共享，提高程序的稳定性和可维护性。字符串常量池是 JVM 用于优化内存和提高性能的一种机制，通过共享相同内容的字符串对象来减少内存开销。由于字符串常量池的存在，直接使用字符串字面量作为锁对象可能导致意外的锁共享。因此，在需要细粒度控制的场景中，推荐使用独立的锁对象来实现同步。
使用Java和Redisson实现分布式锁与同步控制
最新发布
技术研究中心
07-18 258
通过添加Redisson依赖，编写分布式锁管理器，并在Spring Boot服务中应用这些技术，我们可以确保在分布式环境中安全地执行同步任务。Redisson是一个基于Redis的Java驱动库，提供了丰富的分布式对象和服务，包括分布式锁、分布式集合、分布式对象等。在分布式锁领域，Redisson提供了多种实现方式，如公平锁、可重入锁、读写锁等，能够满足不同场景的需求。本文将介绍如何利用Redisson这一Java实现的分布式锁框架，实现分布式环境下的锁定和同步控制。
Java 根据某个 key 加锁的实现方式
明明如月的技术博客
03-15 2987
日常开发中，有时候需要根据某个 key 加锁，确保多线程情况下，对该 key 的加锁和解锁之间的代码串行执行。 大家可以借助每个 key 对应一个 ReentrantLock ，让同一个 key 的线程使用该 lock 加锁；每个 key 对应一个 Semaphore ，让同一个 key 的线程使用 Semaphore 控制同时执行的线程数。
java实现key锁 对字符串key加同步锁或超时锁
weixin_40452750的博客
10-16 550
java实现key锁 对字符串key加同步锁或超时锁
Java 中通过 key 获取锁的正确方式
weixin_49934658的博客
05-06 227
我们可以使用 ReentrantLock 来实行线程阻塞。我们通过内部类来封装 Lock。该类统计某个 key 上执行的线程数。暴露两个方法，一个是线程数增加，一个是减少线程数。
java使用字符串作为锁，并且保证相同内容是同一把锁
Aesop的博客
06-14 811
java使用字符串作为锁，并且保证字符串内容相同是同一把锁。
字符串常量加锁的正确写法
weixin_36802143的博客
01-17 591
字符串常量加锁 错误的写法 static private final String LOCK = "LOCK"; void testMethod() { synchronized(LOCK) { ... } } 正确的写法 static private final Object LOCK = new Object(); void testMethod() { sy...
Java Web程序实现返回JSON字符串的方法总结
10-22
本文将详细介绍如何使用Java Web技术实现返回JSON字符串的过程，包括常用的JSON处理库和如何对库进行定制以满足特定需求。 首先，要实现将Java对象转换成JSON字符串的功能，我们可以在服务器端利用各种现有的JSON...
JAVA实现AES加密和解密
08-15
本文将详细介绍如何使用Java实现AES的加密和解密过程，特别是针对16位长度的秘钥，并解决加解密过程中可能出现的乱码问题。 首先，AES加密算法有多种工作模式，如ECB（Electronic Codebook）、CBC（Cipher Block ...
iOS安全防护系列之字符串及系统函数隐藏详解
08-27
本文将详细讲解如何进行iOS安全防护，特别是关于字符串加密和系统函数隐藏的策略。 一、字符串加密 1. **避免字符串常量区暴露**：在iOS应用的Mach-O文件中，未加密的字符串会被直接存储在常量区，这使得逆向...
jenkins-build-annotator:使用键值字符串注释 jenkins 构建摘要页面
06-12
键值字符串的格式通常为“key=value”，多个注释之间用分号隔开。 **6. 应用场景** - **调试与故障排查**：当构建失败时，注释可以提供关于失败原因的即时反馈。 - **性能监控**：记录构建过程中的性能指标，如编译...
java使用ConcurrentHashMap对key进行加锁防止线程阻塞
qq_36635569的博客
03-23 3928
java使用ConcurrentHashMap对key进行加锁防止线程阻塞
JAVA RedisTemplate实现(加锁/解锁) 解决高并发问题
qq_40083897的博客
12-04 9760
基于传统的单机模式下的并发锁，已远远不能满足当下高并发大负载的情况，当下常用的并发处理如下 1、使用synchronized关键字 2、select for update 乐观锁 3、使用redis实现同步锁 方案一 适合单机模式， 方案二 虽然满足多节点服务实例但 对变更操作的吞吐量有影响 方案三 基于redis nosql数据库 在效率与横向扩展方面都大大优于前两种方案 redis 单线程 在自身设计上一定程度可避免想成不安全...
8.ReentrocLock
qq_25830587的博客
07-09 156
这里非公平锁NonFairSync的源码跟之前公平锁的tryAcquire方法源码几乎一致。（1）公平锁：唯一不同的是公平锁在资源state == 0也就是没人加锁的时候，通过hasQueuedPrecessors()方法判断等待队列有没有在等待，如果有人在等待则它立马放弃去加锁。（2）非公平锁：非公平锁在state == 0 也就是没人加锁的时候，才不管你等待队列有没有人在等待，它不在乎，比较自私一点，直接就去争抢锁，成功就返回了。
JUC高级二: Java锁(上篇)
qq_31745863的博客
03-19 459
锁一锁二一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法锁三锁四加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立刻变化,即两把锁不会锁住对方锁五锁六对于。
Java实现对某个值加同步锁
u012198023的博客
02-11 4406
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录适用场景一、synchronized(this)二、synchronized(Object)三、借用对象加锁四、最终版 适用场景 在一些场景下，我们需要对某一个值进行加锁，比如支付的订单id，同一时间一个订单只允许一个线程进行操作。 以下是本篇文章正文内容，下面案例可供参考 一、synchronized(this) @GetMapping("thread") public void thread(String id)
java-业务加锁
weixin_45547998的博客
03-23 2062
给 业务加锁： 背景: 有些业务需要加锁，避免多个用户同事操作，比如10个用户同事点击修改某条数据。 方案:使用redis 进行加锁。redis缓存使用 步骤: 使用位置 @NoRepeatSubmit(timeInterval = 2) #限流注解 @RequestMapping(value = “contract/scene_sign”, method = RequestMethod.POST) @ApiOperation(“场景签名”) @ResponseBody 自定义注解接口 import jav
对上面python加解密邮件和签名等操作进行详细注释
06-09
好的，下面是对上面Python加解密邮件和签名等操作的详细注释： ```python import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.mime.application import MIMEApplication from cryptography.hazmat.primitives.asymmetric import padding, rsa from cryptography.hazmat.primitives import serialization, hashes from cryptography.hazmat.primitives.asymmetric.utils import ( encode_dss_signature, decode_dss_signature) from cryptography.hazmat.primitives import serialization, asymmetric from cryptography.hazmat.backends import default_backend # 生成RSA密钥对 private_key = rsa.generate_private_key( public_exponent=65537, key_size=2048, backend=default_backend()) public_key = private_key.public_key() # 将私钥序列化为PEM格式的字符串 private_key_pem = private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption()) # 将公钥序列化为PEM格式的字符串 public_key_pem = public_key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo) # 创建邮件正文 msg = MIMEMultipart() body = "This is a test email." msg.attach(MIMEText(body)) # 创建邮件附件 with open("test.txt", "rb") as f: attachment = MIMEApplication(f.read(), _subtype="txt") attachment.add_header( "Content-Disposition", "attachment", filename="test.txt") msg.attach(attachment) # 对邮件内容进行数字签名 message = body.encode("utf-8") + attachment.get_payload(decode=True) signature = private_key.sign( message, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) # 将数字签名附加到邮件正文中 signature_str = ",".join(str(x) for x in signature) msg.attach(MIMEText(signature_str, _subtype="signature")) # 使用公钥对邮件内容进行加密 encrypted_message = public_key.encrypt( message, padding.OAEP( mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None ) ) # 将加密后的内容附加到邮件正文中 msg.attach(MIMEText(encrypted_message, _subtype="encrypted")) # 发送邮件 smtp_host = "smtp.gmail.com" smtp_port = 587 smtp_user = "your_email@gmail.com" smtp_password = "your_password" from_addr = "your_email@gmail.com" to_addr = "recipient_email@gmail.com" server = smtplib.SMTP(smtp_host, smtp_port) server.starttls() server.login(smtp_user, smtp_password) server.sendmail(from_addr, to_addr, msg.as_string()) server.quit() ``` 上述代码实现了对邮件内容进行数字签名和加密的操作，具体步骤如下： 1. 生成RSA密钥对，其中私钥用于签名，公钥用于加密。 2. 将私钥序列化为PEM格式的字符串，用于后续的签名操作。 3. 将公钥序列化为PEM格式的字符串，用于后续的加密操作。 4. 创建邮件正文，并将其作为MIMEMultipart对象的一个部分。 5. 创建邮件附件，并将其作为MIMEMultipart对象的一个部分。 6. 对邮件内容进行数字签名，使用私钥对邮件内容进行签名，并将数字签名附加到邮件正文中。 7. 使用公钥对邮件内容进行加密，使用公钥对邮件内容进行加密，并将加密后的内容附加到邮件正文中。 8. 发送邮件，使用SMTP服务器发送邮件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值