BlogJava-JAVA-文章分类-java/J2EE

分布式锁实现-redis,zk

张钊钊 — Wed, 24 Mar 2021 12:11:00 GMT

1:分布锁有好多实现方式

基于数据库实现

这个实现方式比较复杂,考虑因素比较多，比如：超时,非公平锁,非重入等会有各种各样的问题，在解决问题的过程中会使整个方案变得越来越复杂。操作数据库需要一定的开销，性能问题需要考虑

基于redis实现(这个对于不太敏感的场景可以使用，由于redis集群和单机，还有客户端，版本等多方面因素考虑情况比较多)

性能好。使用缓存实现分布式锁的缺点其数据库一样

基于zookeeper实现(这个是最终也是最好最可靠的)

创建临时节点，可以解决单机，锁无法释放，非阻塞，不可冲入，非公平的问题

总结

从理解的难易程度角度（从低到高）

数据库 > 缓存 > Zookeeper

从实现的复杂性角度（从低到高）

Zookeeper > 缓存 > 数据库

从性能角度（从高到低）

缓存 > Zookeeper >= 数据库

从可靠性角度（从高到低）

Zookeeper > 缓存 > 数据库

下面讲基于redis实现分布锁代码：RedisTemplate 客户端 lettuce

@Service
public class RedisDistributedLockUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    private static final Long RELEASE_SUCCESS = 1L;

    private static final long DEFAULT_TIMEOUT = 1000 * 10;
    //因为要使用lua 脚本是因为 redis 执行lua脚本是原子操作
    private static final String UNLOCK_LUA= "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    /**
     * 实时获取锁
     *
     * 尝试获取分布式锁将redis版本升级到2.1以上(spring-boot-starter-data-redis 版本 2.X以上)，然后使用setIfAbsent 不存在
     * 当setIfAbsent成功之后断开连接，下面设置过期时间的代码 stringRedisTemplate.expire(key,timeout);是无法执行的，这时候就会有大量没有过期时间的数据存在数据库
     * @param lockKey    锁
     * @param requestId  请求标识
     * @param expireTime 超期时间
     * @return 是否获取成功
     */
    public boolean trySetDistributedLock(String lockKey, String requestId, long expireTime) {
        return redisTemplate.opsForValue().setIfAbsent(lockKey, requestId,0 == expireTime ? DEFAULT_TIMEOUT : expireTime, TimeUnit.MILLISECONDS);
    }

    /**
     * 以阻塞方式的获取锁
     * @param key
     * @param value
     * @param timeout
     * @return
     */
    public boolean setDistributedLock(String key, String value, long timeout) {
        Boolean lock = false;
        long start = System.currentTimeMillis();
        while (!lock && (System.currentTimeMillis() - start < timeout)) {
            //执行set命令
            lock = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.MILLISECONDS);
            //不频繁去获取锁
            try {
                if (!lock) {
                    Thread.sleep(60);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return lock;
    }

    public boolean releaseLock(String key, String value) {
        // 使用Lua脚本：先判断是否是自己设置的锁，再执行删除
        // 使用lua脚本删除redis中匹配value的key，可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁
        // spring自带的执行脚本方法中，集群模式直接抛出不支持执行脚本的异常EvalSha is not supported in cluster environment
        // 所以只能拿到原redis的connection来执行脚本

        List<String> keys = new ArrayList<>();
        keys.add(key);
        List<String> args = new ArrayList<>();
        args.add(value);
        Long result = (Long)redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                Object nativeConnection = connection.getNativeConnection();
                // 集群模式和单机模式虽然执行脚本的方法一样，但是没有共同的接口，所以只能分开执行
                // 集群模式
                if (nativeConnection instanceof JedisCluster) {
                    return (Long)((JedisCluster)nativeConnection).eval(UNLOCK_LUA, keys, args);
                }
                //客户端是Jedis时候(单机模式)
                else if (nativeConnection instanceof Jedis) {
                    return (Long)((Jedis)nativeConnection).eval(UNLOCK_LUA, keys, args);
                }
                //这里使用 redisTemplate 中lettuce 客户端
                else{
                    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
                    redisScript.setScriptText(UNLOCK_LUA);
                    redisScript.setResultType(Long.class);
                    return (Long)redisTemplate.execute(redisScript, keys, value);
                }
            }
        });
        //返回最终结果
        return RELEASE_SUCCESS.equals(result);
    }
}

基于zookeeper实现下期补上：

介绍分布式锁文章写的比较详细：
https://blog.csdn.net/u010963948/article/details/79006572

张钊钊 2021-03-24 20:11 发表评论

JDK 8 函数式接口 Supplier、Function、Consumer、Predicate

张钊钊 — Fri, 24 Jul 2020 07:46:00 GMT

函数式接口的特征

1、三种方法

唯一的抽象方法
使用default定义普通方法（默认方法），通过对象调用。
使用static定义静态方法，通过接口名调用。

2、一个新注解@FunctionInterface

注解@FunctionalInterface告诉编译器这是一个函数式接口，明确这个函数中只有一个抽象方法，当你尝试在接口中编写多个抽象方法的时候编译器将不允许，但是可以有多个非抽象方法。
不过Object类的方法可以定义为抽象方法，因为接口的实现类一定是Object的子类
如果接口被标注了@FunctionalInterface，这个类就必须符合函数式接口的规范
即使一个接口没有标注@FunctionalInterface，如果这个接口满足函数式接口规则，依旧被当作函数式接口。

3、JDK 1.8 新增加的函数接口包：

    java.util.function.*
  java.util.function 它包含了很多接口，用来支持 Java的函数式编程，它们大致分为五类：



4、代码样例

/**
*JDK 8 函数式接口 Supplier、Function、Consumer、Predicate

     *
     * @param args
     * @throws Exception
     */

    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor executor = (ThreadPoolExecutor)newFixedThreadPool(10);
        //1:JDK8以前，通过匿名内部类实现函数式接口
        executor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("JDK8以前，通过匿名内部类实现函数式接口");
            }
        });
        //2:JDK8以后可以使用lambda 表达式来实现，lambda表达式就是为了优化匿名内部类而生(分开写效果)
        Thread thread = new Thread(() -> System.out.println("task running !"));
        Runnable r = () -> System.out.println("JDK8以后可以使用lambda 表达式来实现，lambda表达式就是为了优化匿名内部类而生(分开写效果)!");
        executor.submit(r);
        //3:合并起来效果
        executor.submit(() -> {
            System.out.println("JDK8以后可以使用lambda 表达式来实现，lambda表达式就是为了优化匿名内部类而生!");
        });

        //4:其它 Supplier、Function、Consumer、Predicate 都可以用lambda 表达式来实现
        Supplier<String> supplier = () -> "我是SuSupplier";
        Supplier<Integer> supplier2 = () -> new Integer(1);
        System.out.println("supplier=" + supplier.get() + ";supplier2=" + supplier2.get());

        //5: Function功能型函数式接口 Function 接受一个输入参数T，返回一个结果R
        Function<String,Integer> function=str -> Integer.parseInt(str);
        Function<Integer,String> fun2 = item -> item+"";
        System.out.println("输入字符型 1 返回int型结果："+function.apply("1"));
        System.out.println("输入整型 1 返回字符型结果："+fun2.apply(2));

        //6: Consumer 一个接受单个输入参数并且不返回结果的操作。与大多数其他函数接口不同， Consumer接口期望通过接受参数，改普通对象引用值(说明白点就是对原来的值进行加工，注意返回值 void)
        Consumer<StringBuffer> consumer= sb->sb.append("-yyy");
        StringBuffer sb1=new StringBuffer().append("111");
        consumer.accept(sb1);
        //改变sb的内部引用值
        System.out.println("=========s="+sb1.toString());

        //7: Predicate 断言型接口常用于集合的过滤，得到一个新的集合 Stream filter(Predicate predicate);
        Predicate<Integer> predicate = age -> age > 18;
        Predicate<String> predicate2 = str -> str != null;
        System.out.println(predicate.test(19));
        System.out.println(predicate2.test(null));
        //我们常用集合过滤类就是对这个接口实现类其中 filter(Predicate predicate) 用的就是这个接口
        List<String> list= Lists.newArrayList("1","2","2","3","4","4","8");
        list.stream().map(s -> Long.parseLong(s)).distinct().filter(s -> s < 10).collect(Collectors.toList()).forEach(u -> System.out.println(u));

        //总结，以上的例子其实都是JDK8 lambda 表达式简洁的写法，而且全是合并写的，并没有分开步骤写(所有函数性接口，都可以用lambda 表达式简洁写法)

        //关闭线程池
        executor.shutdownNow();
    }

张钊钊 2020-07-24 15:46 发表评论

JDK 8 CompletableFuture 详细使用介绍

张钊钊 — Thu, 23 Jul 2020 11:29:00 GMT


JDK 8 中 CompletableFuture 是对 Future 的增强 大大简化了异步编程步骤,在Spring 框架中配合@EnableAsync @Async 更加事办功倍。

1:在JDK 8 之前实现多线必需实现两个接口 Runnable 不带返回值，另一个Callable带返回值的接口,配合ThreadPoolTaskExecutor.submit(Callable callable) 返回一个Future对象。

使用Future获得异步执行结果时，要么调用阻塞方法get()，要么轮询看isDone()是否为true，这两种方法都不是很好，因为主线程也会被迫等待，而CompletableFuture出现改变了这个问题，而且提供更多并且强大的其它功能。

2：CompletableFuture简介

CompletableFuture implements Future, CompletionStage

其实CompletableFuture 除了实现原来的Future 接口外，其它大部分方法都是在CompletionStage中


大致介绍下completableFuture的命名规则：

1:按功能分类的话：
xxx()：表示该方法将继续在已有的线程中执行；

xxxAsync()：表示将异步在线程池中执行。

异步执行方法默认一个参数的话任务是在 ForkJoinPool.commonPool() 线程池中执行的，带executor 参数的使用 executor线程池异步执行。

2:按逻辑和组织方式来分话(completableFuture 中大约有50个来方法)
一种是 then 的逻辑，即前一个计算完成的时候调度后一个计算

一种是 both 的逻辑，即等待两个计算都完成之后执行下一个计算，只要能组合一个和另一个，我们就可以无限复用这个 +1 的逻辑组合任意多的计算

另一种是 either 的逻辑，即等待两个计算的其中一个完成之后执行下一个计算。注意这样的计算可以说是非确定性的。因为被组合的两个计算中先触发下一个计算执行的那个会被作为前一个计算，而这两个前置的计算到底哪一个先完成是不可预知的
3:从依赖关系和出入参数类型区别，基本分为三类：
apply 字样的方式意味着组合方式是 Function，即接受前一个计算的结果，应用函数之后返回一个新的结果

accept 字样的方式意味着组合方式是 Consumer，即接受前一个计算的结果，执行消费后不返回有意义的值

run 字样的方式意味着组合方式是 Runnable，即忽略前一个计算的结果，仅等待它完成后执行动作
其中出入参数主要有JDK8 Function，Consumer或Runnable三中函数型接口,每一种都决定了是怎么样一种依赖关系,我有一篇文章详细介绍了JDK8函数型接口用法，能有助理解completableFuture方法使用。
http://www.blogjava.net/zzzlyr/articles/435611.html
4:completableFuture 配合框架使用
  因为自从JDK8以后增强了多线程的使用便捷程度：
  1：JDk8 的函数式接口和lambda表过式
  2：completableFuture 对 Future 类的增强。
 这只是JDK 基础包中的功能，现在大部分开发都在使用框架 java 现在基本上都在使用spring框架，因为JDK基础包中的功能还是不如框架使用方便，下边文章详细介绍 springboot中对JDK基础包中多线程功能配置和使用。 
http://www.blogjava.net/zzzlyr/articles/435305.html

张钊钊 2020-07-23 19:29 发表评论

SpringBoot异步及线程池配置(jdk8新增加线程支持CompletableFuture)

张钊钊 — Wed, 25 Mar 2020 12:19:00 GMT

摘要: 如何在 Spring 使用@Async,@EnableAsync注释进行异步处理:异步处理适用那些与业务逻辑（横切关注点）不直接相关或者不作为其他业务逻辑输入的部分，也可在分布式系统中解耦。*译注：横切关注点（cross-cutting concerns）指一些具有横越多个模块的行为，使用传统的软件开发方法不能够达到有效模块化的一类特殊关注点。*Spring 中，`@Async`注解可以标记异步操... 阅读全文

张钊钊 2020-03-25 20:19 发表评论

JAVA 泛型总结！

张钊钊 — Wed, 29 Apr 2015 10:18:00 GMT

1：今天偶尔想起了泛型，都快忘记了在次总结下！
JAVA 泛型分为：泛型类，泛型接口，泛型方法，泛型继承；
泛型还可以限制参数类型的上下限等
1：自定义类泛型
public class GenericTest
2: 泛型接口(也可以自定义)，泛型继承
public interface List extends Collection
3：泛型方法
public List getListBykey(String key, Class T)
4：泛型限制参数类型上下限（例泛型类型只能是String 类和子类）
上限
public class GenericTest
下限：
public class GenericTest
其中?是通配符，代表任意类型

张钊钊 2015-04-29 18:18 发表评论

BlogJava-JAVA-文章分类-java/J2EE

分布式锁实现-redis,zk

JDK 8 函数式接口 Supplier、Function、Consumer、Predicate

1、三种方法

2、一个新注解@FunctionInterface

3、JDK 1.8 新增加的函数接口包： java.util.function.* java.util.function 它包含了很多接口，用来支持 Java的 函数式编程，它们大致分为五类： 4、代码样例

JDK 8 CompletableFuture 详细使用介绍

JDK 8 中 CompletableFuture 是对 Future 的增强 大大简化了异步编程步骤,在Spring 框架中配合@EnableAsync @Async 更加事办功倍。

1:按功能分类的话：

2:按逻辑和组织方式来分话(completableFuture 中大约有50个来方法)

3:从依赖关系和出入参数类型区别，基本分为三类：

4:completableFuture 配合框架使用

SpringBoot异步及线程池配置(jdk8新增加线程支持CompletableFuture)

JAVA 泛型总结！

3、JDK 1.8 新增加的函数接口包：

java.util.function.*
java.util.function 它包含了很多接口，用来支持 Java的函数式编程，它们大致分为五类：

4、代码样例

JDK 8 中 CompletableFuture 是对 Future 的增强大大简化了异步编程步骤,在Spring 框架中配合@EnableAsync @Async 更加事办功倍。