MisakaTang's Blog

发表于 更新于 分类于

XMind

在看了【软件分享 | 硬核】真●全栈工程师的桌面是什么样的？之后决定尝试使用一下xmind来做一些知识和思路的整理,在使用了一段时间之后发现确实是不错,就是画流程图有点累人.前几个blog也是用xmind来整理知识的架构了.

学了点前端

在摸🐟期间尝试学习了一点前端,看了一些JavaScript的语法和历史,大概了解一下node js. 从一个Java程序员的视角来看也就是一个JVM吧,npm也就是maven.然后就开始尝试切入前端的组件架构,决定先学一学react.js

然后开始看React.js 小书学一点前端框架,虽然一开始也看了一下typescript但是还是决定先练练手再学学ts这样的强类型语言和整合.

如何阅读一本书

鉴于已经完全忘记了这本书的内容,所以决定重拾起来再看一遍,顺便用思维导图整理整理.

RAINDROP

需求的来源是现在同时使用chrome和Firefox导致标签的整理变得很困难,所以就尝试找一个页面整理和收集的工具,在一顿尝试之后目前觉得还不错.

Huginn

主要来源一个自己的想法,想把各个网站上收藏的东西都收集到一个地方.

在发现了rsshub之后想到可以把视频列表做成rss源,于是就找到了Huginn这个工具

现在的尝试是把YouTube的视频列表进行rss然后保存到raindrop中,鉴于raindrop提供的openAPI,所以就变得比较简单了.

另一个是TTRSS现在收藏的网页,通过发布RSS的形式也进行了一次RSS然后保存到raindrop中.

后面打算进行一个全集成,把全部的东西都RSS起来聚合到一起.现在还在探索有没有更好的方案.

The Log: What every software engineer should know about real-time data’s unifying abstraction

据说是史诗级程序员必读文章,于是就看了一下. 详细的整理应该还能再憋一篇blog出来吧

Bash 脚本教程

ruanyifeng推荐教程,看了一遍写的还是非常不错的,很详细.

现代 JavaScript 教程

一个很不错的js教程网站,主要是使用导航的形式可以分类查看

发表于 更新于 分类于

leancloud_counter_security插件生成的leancoud.memo问题

之前在配置了leancloud_counter_security插件之后就没有在意了,但是最近注意到没有收到ci的构建邮件了就去重新看了一下ci配置,果然还是问题重重.

Travis CI 整合 leancloud_counter_security

因为一开始做ci的整合的时候对ci脚本并没有很深的理解,所以也就是拿来就用,在熟悉了ci后的现在再来审视脚本就感觉有很多可以调整的地方.

首先是完全忘记了安装插件 … 因为之前集成的时候只是在本地测试了一下,并没有注意到ci脚本需要修改而遗留的问题

npm install hexo-leancloud-counter-security

leancloud.memo

这个文件主要是因为在blog过多之后如果继续使用白嫖的leancoud服务的话就容易报Too Many Request的问题而做的改进,在每次deploy的时候会对数据做一个本地备份,而在ci脚本中,之前完全没有意识到这个问题,从而导致了每次在ci服务器上生成的.memo文件生成完就被丢弃了,可以说完全没有起作用,所以主要也是要解决leancloud.memo的持久化问题.

思路

因为在配置Travis CI的时候已经授权过一个access token了,所以可以直接借用这个token来进行操作.

直接使用https的形式来进行文件的push:

git push -u https://${Travis_CI}@github.com/TangMisaka23001/TangMisaka23001.github.io.git source

只需要每次在deploy之后往源文件的仓库把memo文件的更新push进去就可以了.

添加的脚本如下:

1
2
3
4
5
6
7
8
# leancloud统计相关
# checkout命令比较玄学,个人并不是很理解因为clone下来的应该就是source分支的代码
# 当时也被这个坑了很久,猜测可能是在deploy的时候影响了仓库的分支吧
- git checkout source
- git add source/leancloud.memo
# [skip ci] 用于跳过因为这次commit而产生的ci构建防止构建套娃 (因为现在只检测 source分支有变动就会进行一次构建)
- git commit -m "update leancloud.memo [skip ci]"
- git push -u https://${Travis_CI}@github.com/TangMisaka23001/TangMisaka23001.github.io.git source

所以说持续保持ci脚本的正确性还是很重要的 !!!

现在ci脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
language: node_js   #设置语言
node_js: stable     #设置相应的版本
notifications: #开启邮件通知
  email:
    recipients:
    - mikasatang@gmail.com  
    on_success: always
    on_failure: always
cache:
    directories:
        - node_modules    #据说可以减少travis构建时间
before_install:
  - npm install -g hexo-cli
install:
  - npm install   #安装hexo及插件
  - npm install hexo-deployer-git --save
  - npm install hexo-git-backup --save
  - npm install hexo-leancloud-counter-security
script:
  - hexo clean
  - hexo g   #生成
after_script:
  # 替换同目录下的_config.yml文件中gh_token字符串为travis后台刚才配置的变量，注意此处sed命令用了双引号。单引号无效！
  - sed -i "s/gh_token/${Travis_CI}/g" ./_config.yml
  # 部署博客相关命令
  - echo "misakatang.cn" > ./public/CNAME
  - cp LICENSE ./public
  - cp README.md ./public
  - git config --global user.name "misakatang"
  - git config --global user.email "mikasatang@gmail.com"
  - hexo deploy
  # leancloud统计相关
  - git checkout source
  - git add source/leancloud.memo
  - git commit -m "update leancloud.memo [skip ci]"
  - git push -u https://${Travis_CI}@github.com/TangMisaka23001/TangMisaka23001.github.io.git source
branches:
  only:
  - source  #只监测这个分支，一有动静就开始构建

发表于 更新于 分类于

Redlock.xmind

参考文章

Distributed locks with Redis

分布式锁需求

  1. 互斥
  2. 过期锁的释放
  3. 容错能力

算法设计(主要是获取锁)

  1. 获取当前服务时间
  2. 尝试从全部N个实例获取锁
  3. 每个实例计算锁的有效时间为: 需要加锁时间-获取锁消耗时间
  4. 只有大部分实例成功获取锁这次加锁才能成功
  5. 如果加锁成功,锁的有效时间为所有实例有效时间中最短时间
  6. 加锁失败就请求所有实例释放该锁(无论是否加锁)

Java代码实现

Redisson的RedLock实现–加锁部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
    long newLeaseTime = -1;
    if (leaseTime != -1) {
        if (waitTime == -1) {
            newLeaseTime = unit.toMillis(leaseTime);
        } else {
            newLeaseTime = unit.toMillis(waitTime)*2;
        }
    }
    
    long time = System.currentTimeMillis();
    long remainTime = -1;
    if (waitTime != -1) {
        remainTime = unit.toMillis(waitTime);
    }
    long lockWaitTime = calcLockWaitTime(remainTime);
    
    int failedLocksLimit = failedLocksLimit();
    List<RLock> acquiredLocks = new ArrayList<>(locks.size());
    // 遍历所有的实例
    for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
        RLock lock = iterator.next();
        boolean lockAcquired;
        try {
            // 尝试加锁
            if (waitTime == -1 && leaseTime == -1) {
                lockAcquired = lock.tryLock();
            } else {
                long awaitTime = Math.min(lockWaitTime, remainTime);
                lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
            }
        } catch (RedisResponseTimeoutException e) {
            // 加锁失败全部释放
            unlockInner(Arrays.asList(lock));
            lockAcquired = false;
        } catch (Exception e) {
            lockAcquired = false;
        }
        
        // 获取锁成功加入acquiredLocks List
        if (lockAcquired) {
            acquiredLocks.add(lock);
        } else {
            if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
                break;
            }

            if (failedLocksLimit == 0) {
                unlockInner(acquiredLocks);
                if (waitTime == -1) {
                    return false;
                }
                failedLocksLimit = failedLocksLimit();
                acquiredLocks.clear();
                // reset iterator
                while (iterator.hasPrevious()) {
                    iterator.previous();
                }
            } else {
                failedLocksLimit--;
            }
        }
        
        if (remainTime != -1) {
            remainTime -= System.currentTimeMillis() - time;
            time = System.currentTimeMillis();
            if (remainTime <= 0) {
                unlockInner(acquiredLocks);
                return false;
            }
        }
    }
    // 遍历循环结束

    if (leaseTime != -1) {
        List<RFuture<Boolean>> futures = new ArrayList<>(acquiredLocks.size());
        // 循环全部成功获取锁的实例异步加锁
        for (RLock rLock : acquiredLocks) {
            RFuture<Boolean> future = ((RedissonLock) rLock).expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);
            futures.add(future);
        }
        
        for (RFuture<Boolean> rFuture : futures) {
            rFuture.syncUninterruptibly();
        }
    }
    
    return true;
}
0%