DevilKing's blog

自取其辱

Posted on 2020-08-29 In weekly

自己就是自取其辱，明知道结果，又何必尝试。。。

还是做好自己可以做的，其他多余的不要幻想了。。。

时间管理上，尽量不要拖延，一件事，一件事地做完，努力做好自己可以做的，坚持自己可以做的事情，至于结果如何，就不是自己可以解决的。。。

k8s network sdn

Posted on 2020-08-13 In k8s

主要是flannel网络模式

Node Network：承载 kubernetes 集群中各个“物理” 节点通信的网络
Service Network：由 kubernetes 集群中的 Services 所组成的”网络”
Flannel Network：即 Pod 网络，集群中承载各个 Pod 相互通信的网络

Redis Distribute Lock

Posted on 2020-08-10 In redis

原文链接

分布式锁一般有如下的特点：

互斥性：同一时刻只能有一个线程持有锁
可重入性：同一节点上的同一个线程如果获取了锁之后能够再次获取锁
锁超时：和J.U.C中的锁一样支持锁超时，防止死锁
高性能和高可用：加锁和解锁需要高效，同时也需要保证高可用，防止分布式锁失效
具备阻塞和非阻塞性：能够及时从阻塞状态中被唤醒

lua脚本的方式，放在一个事务中去

public boolean tryLock_with_lua(String key, String UniqueId, int seconds) {
    String lua_scripts = "if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then" +
            "redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end";
    List<String> keys = new ArrayList<>();
    List<String> values = new ArrayList<>();
    keys.add(key);
    values.add(UniqueId);
    values.add(String.valueOf(seconds));
    Object result = jedis.eval(lua_scripts, keys, values);
    //判断是否成功
    return result.equals(1L);
}

SET key value[EX seconds][PX milliseconds][NX|XX]

EX seconds: 设定过期时间，单位为秒
PX milliseconds: 设定过期时间，单位为毫秒
NX: 仅当key不存在时设置值
XX: 仅当key存在时设置值

释放锁的情况，需要对value进行验证，仅释放自己设置的锁？

针对redis集群的方式，采用投票的机制来决定是否真正算获得了锁，也就是所谓的redLock算法

    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws
            InterruptedException {
// 实现要点之允许加锁失败节点限制（N-(N/2+1)）
        int failedLocksLimit = failedLocksLimit();
        List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size());
// 实现要点之遍历所有节点通过EVAL命令执行lua加锁
        for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext(); ) {
            RLock lock = iterator.next();
            boolean lockAcquired;
            try {
// 对节点尝试加锁
                lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
            } catch (RedisConnectionClosedException | RedisResponseTimeoutException e) {
// 如果抛出这类异常，为了防止加锁成功，但是响应失败，需要解锁
                unlockInner(Arrays.asList(lock));
                lockAcquired = false;
            } catch (Exception e) {
// 抛出异常表示获取锁失败
                lockAcquired = false;
            }
            if (lockAcquired) {
// 成功获取锁集合
                acquiredLocks.add(lock);
            } else {
// 如果达到了允许加锁失败节点限制，那么break，即此次Redlock加锁失败
                if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
                    break;
                }
            }
        }
        return true;
    }