TungSing's Blog 用心记录一切！ 2020-01-19T08:41:59.103Z http://tungsing.cc/ tungSing Hexo 常见限流算法 http://tungsing.cc/2020/01/19/java/limiter/ 2020-01-19T06:59:57.571Z 2020-01-19T08:41:59.103Z 前言

工作中遇到了限制请求数的场景，学习和记录一下解决办法。

总结

在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流
缓存:缓存的目的是提升系统访问速度和增大系统处理容量
降级:降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行
限流:限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理

限流

常见的限流算法有计数器、令牌桶和漏桶算法

计算器算法

计数器算法是限流算法里最简单也是最容易实现的一种算法
示例1：用AomicInteger来记录并发数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class CountRateLimiter {
    private static AtomicInteger count = new AtomicInteger(0);
    public void exec() {
        if (count.get() >= 10) {
            System.out.println("请求用户过多，请稍后在试！" + System.currentTimeMillis() / 1000);
        } else {
            count.incrementAndGet();
            try {
                // 处理核心逻辑
                TimeUnit.SECONDS.sleep(1);
                System.out.println("--" + System.currentTimeMillis() / 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                count.decrementAndGet();
            }
        }
    }
}

示例2：使用信号量来控制并发的次数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class CountRateLimiterSmp {
    private static Semaphore semaphore = new Semaphore(10);
    public void exec() {
        try {
            semaphore.acquire();
            // 处理核心逻辑
            TimeUnit.SECONDS.sleep(1);
            System.out.println("--" + System.currentTimeMillis() / 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

用Atomic和Semaphore的最大区别为，如果是瞬时的高并发，可以使请求在阻塞队列中排队，而不是马上拒绝请求，从而达到一个流量削峰的目的。

令牌桶算法

令牌桶算法概念如下：

  • 令牌以固定速率生成；
  • 生成的令牌放入令牌桶中存放，如果令牌桶满了则多余的令牌会直接丢弃，当请求到达时，会尝试从令牌桶中取令牌，取到了令牌的请求可以执行；
  • 如果桶空了，那么尝试取令牌的请求会被直接丢弃。

令牌桶算法既能够将所有的请求平均分布到时间区间内，又能接受服务器能够承受范围内的突发请求，因此是目前使用较为广泛的一种限流算法。Google 的开源项目 guava 提供了 RateLimiter 类，实现了单点的令牌桶限流。为了学习,模拟一下该算法的实现

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
/**
 * 简单限流器-令牌桶算法<br/>
 * 只需要记录一个下一令牌产生的时间，并动态更新它，就能够轻松完成限流功能
 */
public class SimpleLimiter {
    // 当前令牌桶中的令牌数量
    long storedPermits = 0;
    // 令牌桶的容量
    long maxPermits = 3;
    // 下一令牌产生时间
    long next = System.nanoTime();
    // 发放令牌间隔：纳秒
    long interval = 1000_000_000;
    // 请求时间在下一令牌产生时间之后,则
    // 1.重新计算令牌桶中的令牌数
    // 2.将下一个令牌发放时间重置为当前时间
    void resync(long now) {
        if (now > next) {
            // 新产生的令牌数
            long newPermits = (now - next) / interval;
            // 新令牌增加到令牌桶
            storedPermits = Math.min(maxPermits, storedPermits + newPermits);
            // 将下一个令牌发放时间重置为当前时间
            next = now;
        }
    }
    // 预占令牌，返回能获取令牌的时间
    synchronized long reserve(long now) {
        resync(now);
        // 能够获取令牌的时间
        long at = next;
        // 令牌桶中能提供的令牌
        long fb = Math.min(1, storedPermits);
        // 令牌净需求：首先减掉令牌桶中的令牌
        long nr = 1 - fb;
        // 重新计算下一令牌产生时间
        next = next + nr * interval;
        // 重新计算令牌桶中的令牌
        this.storedPermits -= fb;
        return at;
    }
    // 申请令牌
    void acquire() {
        // 申请令牌的时间
        long now = System.nanoTime();
        // 预占令牌
        long at = reserve(now);
        long waitTime = Math.max(at - now, 0);
        // 按照条件等待
        if (waitTime > 0) {
            try {
                TimeUnit.NANOSECONDS.sleep(waitTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试代码

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
    public static void main(String[] args) {
        // 限流器流速
        SimpleLimiter limiter = new SimpleLimiter();
        // 执行任务的线程池
        ExecutorService es = Executors.newFixedThreadPool(20);
        // 记录上一次执行时间
        long prev = System.nanoTime();
        // 测试执行20次
        for (int i = 0; i < 20; i++) {
            // 限流器限流
            limiter.acquire();
            // 提交任务异步执行
            long cur = System.nanoTime();
            es.execute(new Task(prev, cur, i));
            prev = cur;
        }
        es.shutdown();
    }
class Task implements Runnable {
    private long prev;
    private long cur;
    private int index;
    public Task(long prev, long cur, int index) {
        this.prev = prev;
        this.cur = cur;
        this.index = index;
    }
    @Override
    public void run() {
        // 打印时间间隔:毫秒
        System.out.println(index + " : " + (cur - prev) / 1000_000);
    }
}

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>工作中遇到了限制请求数的场景，学习和记录一下解决办法。</p> </blockquote> <h4 id="总结"><a href="#总结" class="headerlink" title="总结"></a>总结</h4><p>在开发高并发系统时有三把利器用来保护系统：<strong>缓存</strong>、<strong>降级</strong>和<strong>限流</strong><br><strong>缓存</strong>:缓存的目的是提升系统访问速度和增大系统处理容量<br><strong>降级</strong>:降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行<br><strong>限流</strong>:限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理 </p> <h4 id="限流"><a href="#限流" class="headerlink" title="限流"></a>限流</h4><p>常见的限流算法有计数器、令牌桶和漏桶算法</p> volitile 关键字 http://tungsing.cc/2019/05/26/java/thread/chapter04/ 2019-05-26T07:16:45.868Z 2019-05-27T01:05:10.847Z 常用方法

volatile:解决的是变量在多线程之间的可见性
synchronized: 解决的是多线程之间访问资源的同步性

volatile轻量级的线性间通信

]]> <h3 id="常用方法"><a href="#常用方法" class="headerlink" title="常用方法"></a>常用方法</h3><p>volatile:解决的是变量在多线程之间的可见性<br>synchronized: 解决的是多线程之间访问资源的同步性</ 自己实现本地缓存 http://tungsing.cc/2019/05/17/cache/local_cache/ 2019-05-17T14:27:00.175Z 2019-05-18T08:35:05.324Z 前言

在扩展框架中的缓存组件相关功能时浏览了本地缓存的实现，其核心是LUR算法，记录下LUR的相关内容加深记忆和理解

环境

  • windows 10
  • jdk7

LUR

LRU全称是Least Recently Used，即最近最久未使用的意思。 LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。

思路分析

对cache的基本操作有：插入(insert)、替换(replace)、查找(lookup)
为了能够快速删除最久没有访问的数据项和插入最新的数据项，我们使用双向链表连接Cache中的数据项，并且保证链表维持数据项从最近访问到最旧访问的顺序。

  • 插入：当Cache未满时，新的数据项只需插到双链表头部即可。时间复杂度为O(1).
  • 替换：当Cache已满时，将新的数据项插到双链表头部，并删除双链表的尾结点即可。时间复杂度为O(1).
  • 查找：每次数据项被查询到时，都将此数据项移动到链表头部。

经过分析，我们知道使用双向链表可以保证插入和替换的时间复杂度是O(1)，但查询的时间复杂度是O(n)，因为需要对双链表进行遍历。为了让查找效率也达到O(1)，很自然的会想到使用 hash table 。

代码实现

从上述分析可知，我们需要使用两种数据结构：

  1. 双向链表(Doubly Linked List)
  2. 哈希表(Hash Table)

Java中的LinkedHashMap正好满足这两种数据结构，直接用LinkedHashMap来实现(框架代码就是基于LinkedHashMap实现的)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = -1456882507664137630L;
    //缓存的最大容量
    private final int MAX_CACHE_SIZE;
    public LRUCache(int cacheSize) {
        // true:按访问排序
        // 初始值必须是2 的N次方，最大容量2 的30次方
        // 初始值16
        super(1 << 4, 0.75F, true);
        MAX_CACHE_SIZE = cacheSize;
    }
    @Override
    protected boolean removeEldestEntry(Entry<K, V> eldest) {
        return size() > MAX_CACHE_SIZE;
    }
}

核心实现只需要继承LinkedHashMap，扩展它的removeEldestEntry方法即可，在多线程环境使用时使用 Collections.synchronizedMap()方法实现线程安全操作。框架中的细节代码就很多了。

简单测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
    LRUCache<Object, Object> cache = new LRUCache<Object, Object>(8);
    cache.put("0", "0");
    cache.put("1", "1");
    cache.put("2", "2");
    cache.put("3", "3");
    cache.put("4", "4");
    cache.put("5", "5");
    cache.put("6", "6");
    cache.put("7", "7");
    cache.get("6");
    cache.get("5");
    cache.put("8", "8");
    for (Entry<Object, Object> entry : cache.entrySet()) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }
}

输出结果：

1
2
3
4
5
6
7
8
1:1
2:2
3:3
4:4
7:7
6:6
5:5
8:8

观察结果当超出最大容量自动删除了最久未使用的数据，访问过的数据排到了链表前端，符合预期

结语

了解原理后不管是解决问题还是重复造轮子都会得心应手。但不推荐重复造轮子，google guava cache 就是基于LUR算法实现的一个基础类库。

参考资料

1.设计并实现一个LRU Cache

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>在扩展框架中的缓存组件相关功能时浏览了本地缓存的实现，其核心是LUR算法，记录下LUR的相关内容加深记忆和理解</p> </blockquote> <h4 id="环境"><a href="#环境" class="headerlink" title="环境"></a>环境</h4><ul> <li>windows 10</li> <li>jdk7</li> </ul> <h4 id="LUR"><a href="#LUR" class="headerlink" title="LUR"></a>LUR</h4><p>LRU全称是Least Recently Used，即<strong>最近最久未使用</strong>的意思。 LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。</p> golang 学习 http://tungsing.cc/2019/05/11/golang/golang-leaning/ 2019-05-11T14:03:57.100Z 2019-05-18T09:55:10.893Z 前言

为了看懂某站的源代码,就学了一下golang,记录一下学习过程慢慢积累

学习记录

代码记录在github上面,下面列举一下文件夹的内容，以防忘记

文件夹 内容 备注
chapter01 经典Hello World
chapter02 基础语法
chapter03 数据类型
chapter04 变量
chapter05 常量
chapter06 运算符
chapter07 流程控制
chapter08 函数
chapter09 方法
chapter10 接口
chapter11 错误
chapter12 异常
chapter13 单元测试
chapter14 并发
cmd main 主程序

参考

  1. 官网
  2. golang
  3. Go 语言教程
  4. 理解Go import
]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>为了看懂某站的源代码,就学了一下golang,记录一下学习过程慢慢积累</p> </blockquote> <h4 id="学习记录"><a href="#学习记录" class="headerlink" title="学习记录"></a>学习记录</h4><p>代码记录在<a href="https://github.com/tungSing/golang-learning">github</a>上面,下面列举一下文件夹的内容，以防忘记<br> golang import 理解 http://tungsing.cc/2019/04/25/golang/golang-import/ 2019-04-25T03:09:58.634Z 2019-05-18T09:55:16.438Z 包的理解

Golang中有package的概念。在go源码文件的第一行就是先声明包名：

1
package xxx

这里的包名相当于一个标签，不是字符串。和所在文件夹没有关系，比如:上述源码在GOPATH/golang-learning/chapter06/文件夹下，它的包名就是xxx

导入包

用improt关键字导入包，包的导入路径是基于工作目录的。因此Go会在工作目录src子目录下查找包

  • 导入标准包使用的是给定的短路径，如“fmt”、“net/http”

    $GOPATH/src/learning/chapter01/hello.go

    1
    2
    3
    4
    5
    6
    7
    package hello
    import "fmt"
    func SayHello()  {
        fmt.Println("Hello,World!");
    }

  • 项目的包，需要在工作目录下指定一个目录

    $GOPATH/src/learning/cmd/main.go

    1
    2
    3
    4
    5
    6
    7
    package main
    import "learning/chapter01"
    func main() {
        hello.SayHello()
    }

    注意:同一个路径下不支持定义多个包，会报编译错误

导入包的方式

导入使用包有四种方式，不同方式用途不一样

  1. import “learning/chapter01”
    常规方式，通过包名hello调用SayHello方法。hello.SayHello()

  2. import h “learning/chapter01”
    这里的 h 是包名 hello 的别名，h.SyayHello() 。该方式合适的场景

    • 包名过于复杂或者意思不明确
      我写的代码其实就很不明确，所以最好要起别名来明确含义

      1
      import hello "learning/chapter01"

    • 包名和其他包冲突
      随着项目代码的不断增加或引入第三方包，很大概率大家会用相同的包名，就需要用别名来区别

      1
      2
      3
      4
      import (
         "errors"
         bizError "learning/chapter11"
      )

  3. import . “learning/chapter01”
    这里的点”.”符号表示，对包 hello 的调用直接省略包名，你我以后就是一家人，不分彼此，你的东西就像我就的一样，随便用。

    1
    2
    3
    4
    5
    6
    7
    package main
    import . "learning/chapter01"
    func main() {
        SayHello()
    }

  4. improt _ “learning/chapter01”
    当导入一个包时，该包下的文件里所有init()函数都会被执行,我们就需要用“_”符合来导入包

    1
    2
    3
    4
    5
    6
    package main
    import _ "learning/chapter01"
    func main() {
    }

参考

  1. 理解Go import
]]> <h4 id="包的理解"><a href="#包的理解" class="headerlink" title="包的理解"></a>包的理解</h4><p>Golang中有package的概念。在go源码文件的第一行就是先声明包名：<br><figure class="highlight plain"><table><tr><td class="gutter"><pre><div class="line">1</div></pre></td><td class="code"><pre><div class="line">package xxx</div></pre></td></tr></table></figure></p> <p>这里的包名相当于一个标签，不是字符串。和所在文件夹没有关系，比如:上述源码在GOPATH/golang-learning/chapter06/文件夹下，它的包名就是<strong>xxx</strong></p> golang 项目组织 http://tungsing.cc/2019/04/25/golang/golang-project/ 2019-04-25T02:59:17.907Z 2019-05-12T01:47:20.861Z 前言

项目目录结构如何组织，一般语言都是没有规定。但Go语言这方面做了规定，这样可以保持一致性

环境变量

  1. GOROOT就是Go被安装的地方
  2. GOPATH指向你的工作区,这就是如何让Go找到你的代码
  3. 其他环境变量,一般情况不需要设置，要查看所有Go环境变量，请输入:go env
    1
    2
    3
    4
    5
    6
    7
    8
    9
    C:\Users\tungS>go env
    set GOARCH=amd64
    set GOBIN=
    set GOCACHE=C:\Users\tungS\AppData\Local\go-build
    set GOEXE=.exe
    set GOFLAGS=
    set GOHOSTARCH=amd64
    set GOHOSTOS=windows
    .....

代码组织结构

  1. 一般的，一个Go项目在GOPATH下，会有如下三个目录：

    1
    2
    3
    |--bin
    |--pkg
    |--src

    bin存放编译后的可执行文件；
    pkg存放编译后的包文件；
    src存放项目源文件。
    一般，bin和pkg目录可以不创建，go命令会自动创建（如 go install），只需要创建src目录即可。对于pkg目录，曾经有人问：我把Go中的包放入pkg下面，怎么不行啊？他直接把Go包的源文件放入了pkg中。这显然是不对的。pkg中的文件是Go编译生成的，而不是手动放进去的。（一般文件后缀.a）对于src目录，存放源文件，Go中源文件以包（package）的形式组织。通常，新建一个包就在src目录中新建一个文件夹。

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>项目目录结构如何组织，一般语言都是没有规定。但Go语言这方面做了规定，这样可以保持一致性</p> </blockquote> <h4 id="环境变量"><a href="#环境变量" class="headerlink" title="环境变量"></a>环境变量</h4><ol> <li>GOROOT就是Go被安装的地方</li> <li>GOPATH指向你的工作区,这就是如何让Go找到你的代码</li> <li>其他环境变量,一般情况不需要设置，要查看所有Go环境变量，请输入:go env<figure class="highlight plain"><table><tr><td class="gutter"><pre><div class="line">1</div><div class="line">2</div><div class="line">3</div><div class="line">4</div><div class="line">5</div><div class="line">6</div><div class="line">7</div><div class="line">8</div><div class="line">9</div></pre></td><td class="code"><pre><div class="line">C:\Users\tungS&gt;go env</div><div class="line">set GOARCH=amd64</div><div class="line">set GOBIN=</div><div class="line">set GOCACHE=C:\Users\tungS\AppData\Local\go-build</div><div class="line">set GOEXE=.exe</div><div class="line">set GOFLAGS=</div><div class="line">set GOHOSTARCH=amd64</div><div class="line">set GOHOSTOS=windows</div><div class="line">.....</div></pre></td></tr></table></figure> </li> </ol> golang IDE 选择 http://tungsing.cc/2019/04/25/golang/golang-ide/ 2019-04-25T02:54:18.830Z 2019-04-25T02:57:55.774Z 前言

IDE有事半功倍效果，所以选择一个，但IDE对原理理解有影响

选择

据说JetBrains家的IDE比较好用所以直接选择GoLand

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>IDE有事半功倍效果，所以选择一个，但IDE对原理理解有影响</p> </blockquote> <h4 id=" golang 环境搭建 http://tungsing.cc/2019/04/21/golang/golang-install/ 2019-04-21T14:12:29.323Z 2019-05-11T14:41:47.072Z 前言

开始学习golang

环境说明

centos7

环境搭建

  1. go官网下载安装包
1
# wget https://dl.google.com/go/go1.12.4.linux-amd64.tar.gz
  1. 根据自己需要解压安装
1
# tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz

  1. 配置环境变量
    在/etc/profile文件中添加export PATH=$PATH:/usr/local/go/bin

    1
    2
    # vi /etc/profile
    # source /etc/profile

  2. 测试是否安装成功

1
2
# go version
go version go1.12.4 linux/amd64

参考

  1. 官网
  2. 安装go
]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>开始学习golang</p> </blockquote> <h4 id="环境说明"><a href="#环境说明" class="headerlink" title="环境说明"></a>环境说明</h4><p>centos7</p> <h4 id="环境搭建"><a href="#环境搭建" class="headerlink" title="环境搭建"></a>环境搭建</h4><ol> <li><a href="https://golang.org/dl/">go官网</a>下载安装包</li> </ol> <figure class="highlight plain"><table><tr><td class="gutter"><pre><div class="line">1</div></pre></td><td class="code"><pre><div class="line"># wget https://dl.google.com/go/go1.12.4.linux-amd64.tar.gz</div></pre></td></tr></table></figure> DataUtils工具类优化 http://tungsing.cc/2019/03/22/java/date-util/ 2019-03-22T02:25:45.542Z 2019-03-22T06:07:36.605Z 前言

之前就看资料说SimpleDateFormat是线程不安全的，正好框架里面有自己的DataUtils类，正好优化并学习一下

环境

jdk1.7

测试框架中代码

开20个线程去格式日期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args) throws InterruptedException {
    ExecutorService service = Executors.newFixedThreadPool(100);
    // 开启20个线程
    for (int i = 0; i < 20; i++) {
        service.execute(new Runnable() {
            @Override
            public void run() {
                for (int j = 0; j < 10; j++) {
                    System.out.println(DateUtils.parseDate("2019-03-22 10:03:25"));
                }
            }
        });
    }
    service.shutdown();
    service.awaitTermination(1, TimeUnit.DAYS);
}

运行结果

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Sun Mar 01 10:03:25 CST 1970
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
java.lang.NumberFormatException: For input string: "33E"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
    at java.lang.Long.parseLong(Long.java:419)
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
    at java.lang.Long.parseLong(Long.java:468)Thu Jan 01 00:03:25 CST 1970
    at java.text.DigitList.getLong(DigitList.java:177)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1297)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1934)
Fri Mar 22 10:03:25 CST 2019
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
Fri Mar 22 10:03:25 CST 2019
    at java.text.DateFormat.parse(DateFormat.java:335)
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
Fri Mar 22 10:03:25 CST 2019
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
Fri Mar 22 10:03:25 CST 2019    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
Fri Mar 22 10:03:25 CST 2019    at java.lang.Thread.run(Thread.java:662)
null
java.lang.NumberFormatException: For input string: ""Tue Jan 01 00:03:25 CST 2019
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)Thu Jan 22 10:03:25 CST 1970
    at java.lang.Long.parseLong(Long.java:431)
Wed Dec 31 00:00:00 CST 1969
    at java.lang.Long.parseLong(Long.java:468)
    at java.text.DigitList.getLong(DigitList.java:177)
Tue Jan 01 00:03:25 CST 2019
    at java.text.DecimalFormat.parse(DecimalFormat.java:1297)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1589)
Tue Jan 01 00:03:25 CST 2019
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
    at java.text.DateFormat.parse(DateFormat.java:335)Thu Jan 22 00:00:25 CST 1970
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
Tue Jan 01 00:00:25 CST 2019    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
Thu Jan 01 00:44:40 CST 1970
    at java.lang.Thread.run(Thread.java:662)
Tue Jan 01 03:03:25 CST 2019
nulljava.lang.NumberFormatException: For input string: ""
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
    at java.lang.Long.parseLong(Long.java:431)
Thu Jan 01 00:00:25 CST 1970
    at java.lang.Long.parseLong(Long.java:468)
    at java.text.DigitList.getLong(DigitList.java:177)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1297)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1589)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
    at java.text.DateFormat.parse(DateFormat.java:335)
Fri Mar 22 10:03:25 CST 2019
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
    at java.lang.Thread.run(Thread.java:662)
java.lang.NumberFormatException: multiple pointsnull
Fri Mar 22 10:03:25 CST 2019
    at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1082)
    at java.lang.Double.parseDouble(Double.java:510)
Fri Mar 22 10:03:25 CST 2019
    at java.text.DigitList.getDouble(DigitList.java:151)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1302)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1934)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
Thu Jul 10 10:03:25 CST 5881580
    at java.text.DateFormat.parse(DateFormat.java:335)
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
Fri Mar 22 10:03:25 CST 2019
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
    at java.lang.Thread.run(Thread.java:662)
null
java.lang.NumberFormatException: multiple points
Fri Mar 22 10:03:25 CST 2019    at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1082)
    at java.lang.Double.parseDouble(Double.java:510)
    at java.text.DigitList.getDouble(DigitList.java:151)Fri Mar 22 10:03:25 CST 2019
    at java.text.DecimalFormat.parse(DecimalFormat.java:1302)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1934)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
    at java.text.DateFormat.parse(DateFormat.java:335)
Fri Mar 22 10:03:25 CST 2019
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
......
java.lang.NumberFormatException: For input string: "1.01"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
    at java.lang.Long.parseLong(Long.java:419)
    at java.lang.Long.parseLong(Long.java:468)
    at java.text.DigitList.getLong(DigitList.java:177)
Fri Mar 22 10:03:25 CST 2019
    at java.text.DecimalFormat.parse(DecimalFormat.java:1297)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1934)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
    at java.text.DateFormat.parse(DateFormat.java:335)
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
Fri Mar 22 10:03:25 CST 2019
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
    at java.lang.Thread.run(Thread.java:662)
null
java.lang.NumberFormatException: For input string: ""
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
    at java.lang.Long.parseLong(Long.java:431)
Fri Mar 22 10:03:25 CST 2019
    at java.lang.Long.parseLong(Long.java:468)
    at java.text.DigitList.getLong(DigitList.java:177)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1297)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1934)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
    at java.text.DateFormat.parse(DateFormat.java:335)
Fri Mar 22 10:03:25 CST 2019
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
    at java.lang.Thread.run(Thread.java:662)
null
java.lang.NumberFormatException: For input string: ""
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
    at java.lang.Long.parseLong(Long.java:431)
    at java.lang.Long.parseLong(Long.java:468)
    at java.text.DigitList.getLong(DigitList.java:177)
    at java.text.DecimalFormat.parse(DecimalFormat.java:1297)
    at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1589)
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1311)
    at java.text.DateFormat.parse(DateFormat.java:335)
    at com.resoft.original.framework.common.OriginalDateUtils.parseDate(OriginalDateUtils.java:275)
    at com.resoft.original.framework.common.Test$1.run(Test.java:35)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
    at java.lang.Thread.run(Thread.java:662)
null
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019

分析错误日志有如下错误

  • 会出现日期不对的情况
  • java.lang.NumberFormatException: For input string xxx
  • java.lang.NumberFormatException: multiple points

错误原因分析

首先看代码是如何写的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private static Map<DateFormat, SimpleDateFormat> dateFormaters = new HashMap<DateFormat, SimpleDateFormat>(3, 0.2f);
private static SimpleDateFormat getDateFormater(DateFormat format) {
    SimpleDateFormat dateFormater = null;
    if ((dateFormater = dateFormaters.get(format)) == null) {
        dateFormater = new SimpleDateFormat(format.format);
        dateFormaters.put(format, dateFormater);
    }
    return dateFormater;
}
public static java.util.Date parseDate(String dateStr) {
    return getDateFormater(DateFormat.YMDHMS_HYPHEN).parse(
                            dateStr);
}

DateFormat是枚举，定义了各种日期格式
代码本质还是获取一个 静态 的 SimpleDateFormat 对象，引入Map是为了提高效率。
那么在多线程的情况下SimpleDateFormat对象实例就会 被多个线程共享 ，通过看源码找原因

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
90
91
92
public Date parse(String text, ParsePosition pos) {
    checkNegativeNumberExpression();
    int start = pos.index;
    int oldStart = start;
    int textLength = text.length();
    calendar.clear(); // Clears all the time fields
    boolean[] ambiguousYear = { false };
    for (int i = 0; i < compiledPattern.length;) {
        int tag = compiledPattern[i] >>> 8;
        int count = compiledPattern[i++] & 0xff;
        if (count == 255) {
            count = compiledPattern[i++] << 16;
            count |= compiledPattern[i++];
        }
        switch (tag) {
        case TAG_QUOTE_ASCII_CHAR:
            if (start >= textLength || text.charAt(start) != (char) count) {
                pos.index = oldStart;
                pos.errorIndex = start;
                return null;
            }
            start++;
            break;
        case TAG_QUOTE_CHARS:
            while (count-- > 0) {
                if (start >= textLength || text.charAt(start) != compiledPattern[i++]) {
                    pos.index = oldStart;
                    pos.errorIndex = start;
                    return null;
                }
                start++;
            }
            break;
        default:
            boolean obeyCount = false;
            boolean useFollowingMinusSignAsDelimiter = false;
            if (i < compiledPattern.length) {
                int nextTag = compiledPattern[i] >>> 8;
                if (!(nextTag == TAG_QUOTE_ASCII_CHAR || nextTag == TAG_QUOTE_CHARS)) {
                    obeyCount = true;
                }
                if (hasFollowingMinusSign && (nextTag == TAG_QUOTE_ASCII_CHAR || nextTag == TAG_QUOTE_CHARS)) {
                    int c;
                    if (nextTag == TAG_QUOTE_ASCII_CHAR) {
                        c = compiledPattern[i] & 0xff;
                    } else {
                        c = compiledPattern[i + 1];
                    }
                    if (c == minusSign) {
                        useFollowingMinusSignAsDelimiter = true;
                    }
                }
            }
            start = subParse(text, start, tag, count, obeyCount, ambiguousYear, pos, useFollowingMinusSignAsDelimiter);
            if (start < 0) {
                pos.index = oldStart;
                return null;
            }
        }
    }
    pos.index = start;
    Date parsedDate;
    try {
        if (ambiguousYear[0]) {
            Calendar savedCalendar = (Calendar) calendar.clone();
            parsedDate = calendar.getTime();
            if (parsedDate.before(defaultCenturyStart)) {
                savedCalendar.set(Calendar.YEAR, defaultCenturyStartYear + 100);
                parsedDate = savedCalendar.getTime();
            }
        } else
            parsedDate = calendar.getTime();
    } catch (IllegalArgumentException e) {
        pos.errorIndex = start;
        pos.index = oldStart;
        return null;
    }
    return parsedDate;
}

重点关注 calendar.clear() , calendar.getTime() 方法，SimpleDateFormat的parse方法实际操作的就是 Calendar 。

因为我们声明SimpleDateFormat为static变量，那么它的Calendar变量也就是一个共享变量，可以被多个线程访问。

假设线程A执行完calendar.clear()方法，这时候被挂起，线程B获得CPU执行权。线程B执行到了calendar.getTime()方法就获取到空值了，而这就是引发问题的根源，出现时间不对，线程挂死等等。

其实SimpleDateFormat源码上作者也给过我们提示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 * <h4><a name="synchronization">Synchronization</a></h4>
 *
 * <p>
 * Date formats are not synchronized.
 * 日期格式不同步。
 * It is recommended to create separate format instances for each thread.
 * 建议为每个线程创建单独的格式实例。
 * If multiple threads access a format concurrently, it must be synchronized
 * externally.
 * 如果多个线程同时访问一种格式，则必须在外部同步该格式。
 *
 * @see          <a href="http://java.sun.com/docs/books/tutorial/i18n/format/simpleDateFormat.html">Java Tutorial</a>
 * @see          java.util.Calendar
 * @see          java.util.TimeZone
 * @see          DateFormat
 * @see          DateFormatSymbols
 * @version      %I%, %G% 
 * @author       Mark Davis, Chen-Lieh Huang, Alan Liu
 */
public class SimpleDateFormat extends DateFormat {

解决办法

  1. 只要在用的时候创建新实例，不用static修饰。

    1
    2
    3
    4
    public static Date parse(String strDate) throws ParseException{
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.parse(strDate);
    }

    如上代码，仅在需要用到的地方创建一个新的实例，就没有线程安全问题，不过也加重了创建对象的负担，会频繁地创建和销毁对象，效率较低。

  2. 使用synchronized来SimpleDateFormat对象

    1
    2
    3
    4
    5
    6
    7
    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
    public static Date parse(String strDate) throws ParseException{
        synchronized(sdf){
            return sdf.parse(strDate);
        }
    }

    当线程较多时，当一个线程调用该方法时，其他想要调用此方法的线程就要block，多线程并发量大的时候会对性能有一定的影响。

  3. 使用ThreadLocal

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };
    public static Date parse(String dateStr) throws ParseException {
        return threadLocal.get().parse(dateStr);
    }

    使用ThreadLocal, 也是将共享变量变为独享，线程独享肯定能比方法独享在并发环境中能减少不少创建对象的开销。如果对性能要求比较高的情况下，一般推荐使用这种方法。

优化框架代码

作为框架代码必须要保证性能要求，用ThreadLocal来优化代码

1
2
3
4
5
6
7
8
9
10
11
12
private static ThreadLocal<java.text.DateFormat> threadLocal = new ThreadLocal<java.text.DateFormat>();
private static java.text.DateFormat getDateFormater(DateFormat format) {
    java.text.DateFormat dateFormater = threadLocal.get();
    if (dateFormater == null) {
        dateFormater = new SimpleDateFormat(format.format);
        threadLocal.set(dateFormater);
    }
    return dateFormater;
}

用同样的测试代码测试，结果如下

1
2
3
4
Fri Mar 22 10:03:25 CST 2019
Fri Mar 22 10:03:25 CST 2019
......
Fri Mar 22 10:03:25 CST 2019

结语

我们要站在巨人的肩膀上来做事，如果是jdk1.8 可以使用DateTimeFormatter对象来解析或格式化日期;或直接使用Joda-Time类库来处理时间相关问题。

参考

还在使用SimpleDateFormat？你的项目崩没？
深入理解Java：SimpleDateFormat安全的时间格式化

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>之前就看资料说SimpleDateFormat是线程不安全的，正好框架里面有自己的DataUtils类，正好优化并学习一下</p> </blockquote> <h4 id="环境"><a href="#环境" class="headerlink" title="环境"></a>环境</h4><p>jdk1.7</p> Redhat7.5 安装 使用 GitLab http://tungsing.cc/2019/02/28/git/gitlab_install/ 2019-02-28T08:00:10.908Z 2019-05-18T08:36:00.968Z 版本选择

如果想安装指定版本，需要在下面的网站中下载指定版本。

  1. GitLab资源库
  2. GitLab资源库社区版
  3. GitLab资源库企业版

安装社区版

官方安装文档

  1. 安装并配置依赖(必要)

    1
    2
    3
    4
    5
    6
    # sudo yum install -y curl policycoreutils-python openssh-server
    # sudo systemctl enable sshd
    # sudo systemctl start sshd
     
    # sudo firewall-cmd --permanent --add-service=http
    # sudo systemctl reload firewalld

  2. 安装Postfix(用来发送通知电子邮件)

    1
    2
    3
    # sudo yum -y install postfix
    # sudo systemctl enable postfix
    # sudo systemctl start postfix

  3. 添加GitLab包存储库

    1
    # curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | sudo bash

  4. 安装GitLab包(将http://gitlab.resoft.css.com.cn作为您要访问GitLab的域名。安装过程将自动配置并启动该域名的GitLab)

    1
    # EXTERNAL_URL="http://gitlab.resoft.css.com.cn" yum install -y gitlab-ce

  5. 相关命令

    • 查看运行状态

      1
      # sudo gitlab-ctl status

    • 启动

      1
      # sudo gitlab-ctl start

    • 停止

      1
      # sudo gitlab-ctl stop

    • 重启

      1
      # sudo gitlab-ctl restart

    • 查看版本

      1
      2
      # cat /opt/gitlab/embedded/service/gitlab-rails/VERSION
      11.4.3-ee

配置并使用

  1. 浏览域名(http://gitlab.resoft.css.com.cn)并登陆
    首次访问时，您将被重定向到密码重置页面。设置初始管理员帐户的密码。使用默认帐户的用户名root登录。
  2. 配置语言
    选择用户头像->点Setting->选择Profile，将Preferred Language改成简体中文后保存即可

参考

在CentOS 7 1804 中 安装 使用 GitLab

]]> <h4 id="版本选择"><a href="#版本选择" class="headerlink" title="版本选择"></a>版本选择</h4><p>如果想安装指定版本，需要在下面的网站中下载指定版本。</p> <ol> <li><a href="https://packages.gitlab.com/gitlab/">GitLab资源库</a></li> <li><a href="https://packages.gitlab.com/gitlab/gitlab-ce">GitLab资源库社区版</a></li> <li><a href="https://packages.gitlab.com/gitlab/gitlab-ee">GitLab资源库企业版</a></li> </ol> Sonatype Nexus Repository Manager私服搭建 http://tungsing.cc/2019/02/28/nexus/nexus/ 2019-02-28T05:53:40.687Z 2019-02-28T06:55:58.858Z 前言

在使用java开发用maven来管理工程常常会从远程仓库下载jar包，由于网络原因有时候会下载很慢；还有公司内部产品开发的代码又不能上传到中央仓库；故需要搭建一个maven的私有仓库。选择Sonatype Nexus来作为maven的私有仓库，Sonatype Nexus还可以做docker、npm等等的私有仓库。

环境

  • Redhat 7.5 操作系统
  • Sonatype Nexus Repository Manager 3.15
  • jdk1.8

下载安装包

  1. 下载jdk安装包
  2. 官网下载Sonatype Nexus Repository Manager安装包
    1
    # wget http://download.sonatype.com/nexus/3/nexus-3.15.2-01-unix.tar.gz

准备

  1. 修改最大文件打开数
    nexus要求最大文件打开数不小于65536，默认1024
    打开文件/etc/security/limits.conf在文件末尾添加配置

    1
    2
    3
    4
    * soft nofile 204800  
    * hard nofile 204800  
    * soft nproc 204800  
    * hard nproc 204800

    * 代表针对所有用户
    noproc 是代表最大进程数
    nofile 是代表最大文件打开数

  2. 创建用户组及用户并设置密码
    Sonatype Nexus 不推荐root

    1
    2
    3
    groupadd nexus
    useradd -g nexus nexus
    passwd xxx

    xxx:你的密码

安装

  1. 解压到/opt/nexus目录
    1
    # tar -zvxf nexus-3.15.2-01-unix.tar.gz

配置

  1. 配置jdk

    1
    # vi /opt/nexus/nexus-3.15.2-01/bin/nexus

    找到INSTALL4J_JAVA_HOME_OVERRIDE添加java home目录

    1
    INSTALL4J_JAVA_HOME_OVERRIDE=/opt/java/jdk1.8.0_131

  2. 配置启动用户

    1
    # vi /opt/nexus/nexus-3.15.2-01/bin/nexus.rc

    默认为nexus用户修改root用户

    1
    run_as_user="root"

  3. 配置WEB端口为80。默认为8081，如何不修改默认端口，启动用户无需配置

    1
    # /opt/nexus/nexus-3.15.2-01/etc/nexus-default.properties

  4. 配置开机启动
    在目录/etc/systemd/system/添加nexus.service文件

    1
    # vi /etc/systemd/system/nexus.service

    添加如下内容

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    [Unit]
    Description=nexus service
    After=network.target
      
    [Service]
    Type=forking
    LimitNOFILE=65536
    ExecStart=/opt/nexus/nexus-3.15.2-01/bin/nexus start
    ExecStop=/opt/nexus/nexus-3.15.2-01/bin/nexus stop
    User=root
    Restart=on-abort
      
    [Install]
    WantedBy=multi-user.target

    激活服务并添加开机启动

    1
    2
    # systemctl daemon-reload
    # systemctl enable nexus.service

启动

1
# systemctl start nexus.service

查看日志，监控是否成功

1
# tail -f /opt/nexus/sonatype-work/nexus3/log/nexus.log

说明

我想用80端口，所以用root用户启动。用nexus用户启动无法用80端口，会报一个错误，没找到解决办法

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
jvm 1    | 2017-04-28 11:20:10,040+0800 WARN  [jetty-main-1] *SYSTEM org.eclipse.jetty.util.component.AbstractLifeCycle - FAILED InstrumentedSelectChannelCon
nector@0.0.0.0:80: java.net.SocketException: Permission denied
jvm 1    | java.net.SocketException: Permission denied
jvm 1    |      at sun.nio.ch.Net.bind0(Native Method) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.Net.bind(Net.java:433) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.Net.bind(Net.java:425) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.ServerSocketChannelImpl.bind(ServerSocketChannelImpl.java:223) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.ServerSocketAdaptor.bind(ServerSocketAdaptor.java:74) ~[na:1.8.0_131]
jvm 1    |      at org.eclipse.jetty.server.nio.SelectChannelConnector.open(SelectChannelConnector.java:187) ~[jetty-server-8.1.16.v20140903.jar:8.1.16.v2014
0903]
jvm 1    |      at org.eclipse.jetty.server.AbstractConnector.doStart(AbstractConnector.java:316) ~[jetty-server-8.1.16.v20140903.jar:8.1.16.v20140903]
jvm 1    |      at org.eclipse.jetty.server.nio.SelectChannelConnector.doStart(SelectChannelConnector.java:265) ~[jetty-server-8.1.16.v20140903.jar:8.1.16.v2
0140903]
jvm 1    |      at org.sonatype.nexus.bootstrap.jetty.InstrumentedSelectChannelConnector.doStart(InstrumentedSelectChannelConnector.java:85) ~[nexus-bootstra
p-2.12.0-01.jar:2.12.0-01]
jvm 1    |      at org.eclipse.jetty.util.component.AbstractLifeCycle.start(AbstractLifeCycle.java:64) [jetty-util-8.1.16.v20140903.jar:8.1.16.v20140903]
jvm 1    |      at org.eclipse.jetty.server.Server.doStart(Server.java:293) [jetty-server-8.1.16.v20140903.jar:8.1.16.v20140903]
jvm 1    |      at org.eclipse.jetty.util.component.AbstractLifeCycle.start(AbstractLifeCycle.java:64) [jetty-util-8.1.16.v20140903.jar:8.1.16.v20140903]
jvm 1    |      at org.sonatype.nexus.bootstrap.jetty.JettyServer$JettyMainThread.run(JettyServer.java:247) [nexus-bootstrap-2.12.0-01.jar:2.12.0-01]
jvm 1    | 2017-04-28 11:20:10,041+0800 WARN  [jetty-main-1] *SYSTEM org.eclipse.jetty.util.component.AbstractLifeCycle - FAILED org.eclipse.jetty.server.Server@7fafc8f3: java.net.SocketException: Permission denied
jvm 1    | java.net.SocketException: Permission denied
jvm 1    |      at sun.nio.ch.Net.bind0(Native Method) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.Net.bind(Net.java:433) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.Net.bind(Net.java:425) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.ServerSocketChannelImpl.bind(ServerSocketChannelImpl.java:223) ~[na:1.8.0_131]
jvm 1    |      at sun.nio.ch.ServerSocketAdaptor.bind(ServerSocketAdaptor.java:74) ~[na:1.8.0_131]
jvm 1    |      at org.eclipse.jetty.server.nio.SelectChannelConnector.open(SelectChannelConnector.java:187) ~[jetty-server-8.1.16.v20140903.jar:8.1.16.v20140903]
jvm 1    |      at org.eclipse.jetty.server.AbstractConnector.doStart(AbstractConnector.java:316) ~[jetty-server-8.1.16.v20140903.jar:8.1.16.v20140903]
jvm 1    |      at org.eclipse.jetty.server.nio.SelectChannelConnector.doStart(SelectChannelConnector.java:265) ~[jetty-server-8.1.16.v20140903.jar:8.1.16.v20140903]

参考

centos7 开机启动

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>在使用java开发用maven来管理工程常常会从远程仓库下载jar包，由于网络原因有时候会下载很慢；还有公司内部产品开发的代码又不能上传到中央仓库；故需要搭建一个maven的私有仓库。选择Sonatype Nexus来作为maven的私有仓库，Sonatype Nexus还可以做docker、npm等等的私有仓库。</p> </blockquote> <h4 id="环境"><a href="#环境" class="headerlink" title="环境"></a>环境</h4><ul> <li>Redhat 7.5 操作系统</li> <li>Sonatype Nexus Repository Manager 3.15</li> <li>jdk1.8</li> </ul> Redhat7.5 替换免费的yum http://tungsing.cc/2019/02/28/linux/linux-yum/ 2019-02-28T01:18:23.901Z 2019-02-28T06:58:04.436Z 前言

在没有激活的机器上使用yum命令无法使用，临时替换免费版。推荐使用正版！

步骤

  1. 检查已经安装yum包

    1
    # rpm -qa | grep yum

  2. 删除已安装的yum包

    1
    # rpm -qa | grep yum|xargs rpm -e --nodeps

  3. 下载yum相关包
    浏览器打开阿里镜像站,网址可能会变

    1
    2
    3
    # wget https://mirrors.aliyun.com/centos/7.6.1810/os/x86_64/Packages/yum-3.4.3-161.el7.centos.noarch.rpm
    # wegt https://mirrors.aliyun.com/centos/7.6.1810/os/x86_64/Packages/yum-metadata-parser-1.1.4-10.el7.x86_64.rpm
    # wget https://mirrors.aliyun.com/centos/7.6.1810/os/x86_64/Packages/yum-plugin-fastestmirror-1.1.31-50.el7.noarch.rpm

  4. 安装yum

    1
    # rpm -ivh yum-*

  5. 下载源地址文件

    1
    2
    # cd /etc/yum.repos.d
    # wget http://mirrors.aliyun.com/repo/Centos-7.repo

  6. 备份原源地址文件

    1
    # mv /etc/yum.repos.d/redhat.repo /etc/yum.repos.d/redhat.repo.bak

  7. 修改阿里源地址文件

    1
    # sed -i "s;\$releasever;7.6.1810;g" /etc/yum.repos.d/Centos-7.repo

    7.6.1810为版本号

  8. 清理缓存和重新生成缓存

    1
    2
    # yum clean all
    # yum makecache

参考

RedHat 7替换yum为免费版 CentOS7 yum

]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>在没有激活的机器上使用yum命令无法使用，临时替换免费版。推荐使用正版！</p> </blockquote> <p><img src="/images/linux/redhat_yum.jpg" alt=""></p> OpenSSL 生成自定义证书 http://tungsing.cc/2019/01/06/web/container/ssl_cert/ 2019-01-06T07:29:37.157Z 2019-05-18T08:37:38.480Z 前言

本文用来记录通过OpenSSL生成自定义证书并在浏览器设置可信任

准备

  • Linux CentOS7 系统
  • nginx 1.12.2
  • Windows 10
  • IE 11
  • chrome 71

OpenSSL配置

在linux系统中修改OpenSSL配置是为了,让chrome浏览器对为网站可信任

  1. 拷贝OpenSSL配置文件准备修改

    1
    2
    # cd /etc/pki/tls/
    # cp openssl.cnf openssl_m.cnf

  2. 修改openssl_m.cnf文件

    1
    # vi /etc/pki/tls/openssl_m.cnf

    a. 找到[ req ] 段落，添加req_extentions = v3_req配置：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    ####################################################################
    [ req ]
    default_bits        = 2048
    default_md      = sha256
    default_keyfile     = privkey.pem
    distinguished_name  = req_distinguished_name
    attributes      = req_attributes
    x509_extensions = v3_ca # The extentions to add to the self signed cert
    #需要添加的配置
    req_extentions  = v3_req

    b. 添加v3_req配置信息

    1
    2
    3
    4
    5
    6
    7
    8
    [ v3_req ]
    # Extensions to add to a certificate request
    basicConstraints = CA:FALSE
    keyUsage = nonRepudiation, digitalSignature, keyEncipherment
    #需要添加的配置
    subjectAltName = @alt_names

    c. 添加alt_names配置信息,可以添加多个

    1
    2
    [ alt_names ]
    DNS.1 = www.test.com

    注：这里填入的即为Subject Alternative Names的域名名称

生成证书

直接用脚本生成

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
#!/bin/sh
# create self-signed server certificate:
read -p "Enter your domain [www.example.com]: " DOMAIN
echo "Create server key..."
openssl genrsa -des3 -out $DOMAIN.key 2048
echo "Create server certificate signing request..."
SUBJECT="/C=US/ST=Mars/L=iTranswarp/O=iTranswarp/OU=iTranswarp/CN=$DOMAIN"
#openssl req -new  -subj $SUBJECT -key $DOMAIN.key -out $DOMAIN.csr -extensions v3_req
openssl req -new -subj $SUBJECT  -key $DOMAIN.key -out $DOMAIN.csr
echo "Remove password..."
mv $DOMAIN.key $DOMAIN.origin.key
openssl rsa -in $DOMAIN.origin.key -out $DOMAIN.key
echo "Sign SSL certificate..."
openssl x509 -req -days 3650 -extfile /etc/pki/tls/openssl_m.cnf  -extensions v3_req   -in $DOMAIN.csr -signkey $DOMAIN.key -out $DOMAIN.crt
echo "TODO:"
echo "Copy $DOMAIN.crt to /etc/nginx/ssl/$DOMAIN.crt"
echo "Copy $DOMAIN.key to /etc/nginx/ssl/$DOMAIN.key"
echo "Add configuration in nginx:"
echo "server {"
echo "    ..."
echo "    listen 443 ssl;"
echo "    ssl_certificate     /etc/nginx/ssl/$DOMAIN.crt;"
echo "    ssl_certificate_key /etc/nginx/ssl/$DOMAIN.key;"
echo "}"

关键点就是：-extfile /etc/pki/tls/openssl_m.cnf -extensions v3_req给证书添加上扩展属性

配置nginx

  1. 把生成的xxx.crt 和xxx.key 拷贝到/etc/nginx/ssl/

  2. 修改nginx.conf

    1
    2
    3
    4
    5
    6
    7
    server {
        ssl on;
        ssl_certificate     /etc/nginx/ssl/www.test.com.crt;
        ssl_certificate_key /etc/nginx/ssl/www.test.com.key;
        listen       443 default_server;
        listen       [::]:443 default_server;
    }

  3. 重启nginx服务

导入证书

  1. 把www.test.com.crt拷贝到windows系统中
  2. 双击www.test.com.crt文件打开
  3. 点击“Install Certificate”
  4. 选择“Local Machine” 点击“Next”
  5. 选择“Place all certificates in the following store” 点击“Browser”
  6. 选择“Trusted Root Certification Authorities” 点击“OK”
  7. 点击“Next” 点击“Finish”

再次访问网站

参考资料

  1. OpenSSL创建的自签名证书在chrome端无法信任
  2. OpenSSL生成v3证书方法及配置文件
  3. 给Nginx配置一个自签名的SSL证书
  4. 脚本
]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>本文用来记录通过OpenSSL生成自定义证书并在浏览器设置可信任</p> </blockquote> <h4 id="准备"><a href="#准备" class="headerlink" title="准备"></a>准备</h4><ul> <li>Linux CentOS7 系统</li> <li>nginx 1.12.2</li> <li>Windows 10</li> <li>IE 11</li> <li>chrome 71</li> </ul> nginx+keepalived 主从搭建 http://tungsing.cc/2019/01/04/web/container/nginx_keepalived/ 2019-01-04T06:01:22.265Z 2019-05-18T08:37:31.309Z 前言

本文用来记录nginx加keepalived实现高可用，避免出现单点故障。

准备

  • Linux CentOS7 系统
  • nginx 1.12.2
  • keepalived 1.3.5

规划图

虚拟IP 真实IP hostname nginx端口 主从
10.200.1.200 10.200.1.5 nginx_master 80 Master
10.200.1.200 10.200.1.6 nginx_backup 80 Backup

注意点

把搭建过程中的坑写的前边，避免下次再遇到

  1. 机器的hostname一定要修改，不能出现相同的，相同会导致VIP不漂移
  2. 防火墙开放80端口
  3. selinux对keepalived的影响，我遇到的是在执行监控脚本无法调用系统服务命令(systemctl stop keepalived),解决办法有3
    • 不调用系统服务命令来启动或关闭应用，只用kill杀死进程
    • 关闭selinux
    • 找到selinux具体是什么权限导致在监控脚本无法调用系统服务命令(我没找到)

安装

  1. 在VirtualBox下安装CentOS7操作系统，配置IP地址和hostname

  2. 通过yum命令来安装epel-release、nginx、keepalived

    1
    2
    3
    # yum install epel-release -y
    # yum install nginx -y
    # yum install keepalived -y

  3. 复制第一步安装好的系统，配置IP地址和hostname

配置

Master配置

  1. keepalived 配置

    1
    # vi etc/keepalived/keepalived.conf
    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
    ! Configuration File for keepalived
    #全局配置
    global_defs {
        #运行keepalived的机器的一个标识
        router_id LVS_DEVEL_MASTER
    }
    #VRRPD配置
    vrrp_script check_nginx {
      #脚本监测
      script "/opt/check_nginx.sh"
      #脚本执行间隔，每2s检测一次
      interval 2
      #脚本结果导致的优先级变更，检测失败（脚本返回非0）则优先级 -20
      weight -20
    }
    #定义vrrp实例
    vrrp_instance VI_1 {
        #指定keepalived的角色，MASTER表示此主机是主服务器，BACKUP表示此主机是备用服务器
        state MASTER
        #指定HA监测网络的接口。与本机 IP 地址所在的网络接口相同
        interface enp0s3
        #虚拟路由标识，这个标识是一个数字，同一个vrrp实例使用唯一的标识。即同一vrrp_instance下，MASTER和BACKUP必须是一致的  
        virtual_router_id 51
        #定义优先级，数字越大，优先级越高
        priority 100
        #设定MASTER与BACKUP负载均衡器之间同步检查的时间间隔，单位是秒
        advert_int 1
        #设置验证类型和密码。主从必须一样
        authentication {
            auth_type PASS
            auth_pass 1111
        }
        #VRRP HA 虚拟地址 如果有多个VIP，继续换行填写 
        virtual_ipaddress {
            10.200.1.200
        }
        #执行nginx检测脚本。注意这个设置不能紧挨着写在vrrp_script配置块的后面（实验中碰过的坑），否则nginx监控失效！！
        track_script {
           check_nginx
        }
    }

  2. 监测脚本编写

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #!/bin/bash
    #检查nginx进程是否存在
    counter=$(ps -C nginx --no-heading|wc -l)
    pids=$(pidof keepalived)
    if [ "${counter}" = "0" ]; then
         #尝试启动一次nginx，停止5秒后再次检测
         #/usr/bin/systemctl start nginx
        sleep 2
        counter=$(ps -C nginx --no-heading|wc -l)
        if [ "${counter}" = "0" -a "${pids}" != "" ]; then
            #如果启动没成功，就杀掉keepalive触发主备切换
            #/usr/bin/systemctl stop keepalived
            #如果关闭了selinux可以只用上边的命令，如果没有直接用kill
            #kill -9 $pids
        fi
    fi

  3. 监测脚本授权

    1
    # chmod +x /opt/check_nginx.sh
Backup配置

  1. keepalived 配置

    1
    # vi /etc/keepalived/keepalived.conf
    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
    ! Configuration File for keepalived
    global_defs {
        #和Master不同的地方
        router_id LVS_DEVEL_BACKUP
    }
    vrrp_script check_nginx {
      script "sh /opt/check_nginx.sh" 
      interval 2 
      weight -20
    }
    vrrp_instance VI_1 {
        #和Master不同的地方
        state BACKUP
        interface enp0s3
        virtual_router_id 51
        #和Master不同的地方
        priority 90
        advert_int 1
        authentication {
            auth_type PASS
            auth_pass 1111
        }
        virtual_ipaddress {
            10.200.1.200
        }
        track_script {
           check_nginx
        }
    }

  2. 直接把Master的脚本拷贝过来

测试

  1. 关闭master的nginx服务，测试nginx是否会被重启

    检查页面是否正常

  2. 测试VIP是否会漂移

    • 注释检测脚本启动nginx服务的命令
    • 查看页面
    • 执行systemctl stop nginx命令，查看页面

结语

本记录只记录了核心的部分，如果是生成环境用，还有在熟悉其他的配置，比如发邮件配置等

参考资料

  1. nginx笔记
  2. Keepalived原理与实战精讲–VRRP协议
]]> <h4 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h4><blockquote> <p>本文用来记录nginx加keepalived实现高可用，避免出现单点故障。</p> </blockquote> <h4 id="准备"><a href="#准备" class="headerlink" title="准备"></a>准备</h4><ul> <li>Linux CentOS7 系统</li> <li>nginx 1.12.2</li> <li>keepalived 1.3.5</li> </ul> redis info 命令 http://tungsing.cc/2018/12/10/cache/redis/redis-info/ 2018-12-10T07:11:59.361Z 2019-05-18T10:14:11.205Z 收集了info命令的中文解释

信息 中文解释
Server 服务信息
redis_version Redis 服务器版本
redis_git_sha1 Git SHA1
redis_git_dirty Git dirty flag
redis_build_id redis build id
redis_mode 运行模式，单机或者集群
os Redis 服务器的宿主操作系统
arch_bits 架构（32 或 64 位）
multiplexing_api Redis 所使用的事件处理机制
process_id 服务器进程的 PID
run_id Redis 服务器的随机标识符（用于 Sentinel 和集群）
tcp_port TCP/IP 监听端口
uptime_in_seconds 自 Redis 服务器启动以来，经过的秒数
uptime_in_days 自 Redis 服务器启动以来，经过的天数
hz redis内部调度（进行关闭timeout的客户端，删除过期key等等）频率，程序规定serverCron每秒运行10次
lru_clock 以分钟为单位进行自增的时钟，用于 LRU 管理
executable
config_file 配置文件路径
Clients 客户端信息
connected_clients 已连接客户端的数量（不包括通过从属服务器连接的客户端）
client_longest_output_list 当前连接的客户端当中，最长的输出列表
client_biggest_input_buf 当前连接的客户端当中，最大输入缓存
blocked_clients 正在等待阻塞命令(BLPOP、BRPOP、BRPOPLPUSH)的客户端的数量
Memory 内存信息
used_memory 由 Redis 分配器分配的内存总量，以字节(byte)为单位
used_memory_human 以人类可读的格式返回 Redis 分配的内存总量
used_memory_rss 从操作系统的角度，返回 Redis 已分配的内存总量（俗称常驻集大小）。这个值和 top 、 ps 等命令的输出一致。
used_memory_rss_human 以人类可读的格式返回Redis已分配的内存总量
used_memory_peak Redis 的内存消耗峰值（以字节为单位）
used_memory_peak_human 以人类可读的格式返回 Redis 的内存消耗峰值
total_system_memory
total_system_memory_human
used_memory_lua lua引擎所使用的内存大小(以字节为单位)
used_memory_lua_human
maxmemory
maxmemory_human
maxmemory_policy 内存淘汰机制，当内存使用达到阈值的时候，所有引起申请内存的命令会报错
mem_fragmentation_ratio used_memory_rss和used_memory之间的比率，小于1表示使用了swap，大于1表示碎片比较多
mem_allocator 在编译时指定的redis所使用的内存分配器。可以是libc、jemalloc或者tcmalloc
Persistence 持久化信息
loading 服务器是否正在载入持久化文件
rdb_changes_since_last_save 离最近一次成功生成rdb文件，写入命令的个数，即有多少个写入命令没有持久化
rdb_bgsave_in_progress 服务器是否正在创建rdb文件
rdb_last_save_time 离最近一次成功创建rdb文件的时间戳。当前时间戳 - rdb_last_save_time=多少秒未成功生成rdb文件
rdb_last_bgsave_status 最近一次rdb持久化是否成功
rdb_last_bgsave_time_sec 最近一次成功生成rdb文件耗时秒数
rdb_current_bgsave_time_sec 如果服务器正在创建rdb文件，那么这个域记录的就是当前的创建操作已经耗费的秒数
aof_enabled 是否开启了aof
aof_rewrite_in_progress 标识aof的rewrite操作是否在进行中
aof_rewrite_scheduled rewrite任务计划，当客户端发送bgrewriteaof指令，如果当前rewrite子进程正在执行，那么将客户端请求的bgrewriteaof变为计划任务，待aof子进程结束后执行rewrite
aof_last_rewrite_time_sec 最近一次aof rewrite耗费的时长
aof_current_rewrite_time_sec 如果rewrite操作正在进行，则记录所使用的时间，单位秒
aof_last_bgrewrite_status 上次bgrewriteaof操作的状态
aof_last_write_status 上次aof写入状态
Stats 一般统计信息
total_connections_received 新创建连接个数,如果新创建连接过多，过度地创建和销毁连接对性能有影响，说明短连接严重或连接池使用有问题，需调研代码的连接设置
total_commands_processed redis处理的命令数
instantaneous_ops_per_sec redis当前的qps，redis内部较实时的每秒执行的命令数
total_net_input_bytes redis网络入口流量字节数
total_net_output_bytes redis网络出口流量字节数
instantaneous_input_kbps redis网络入口kps
instantaneous_output_kbps redis网络出口kps
rejected_connections 拒绝的连接个数，redis连接个数达到maxclients限制，拒绝新连接的个数
sync_full 主从完全同步成功次数
sync_partial_ok 主从部分同步成功次数
sync_partial_err 主从部分同步失败次数
expired_keys 运行以来过期的key的数量
evicted_keys 运行以来剔除(超过了maxmemory后)的key的数量
keyspace_hits 命中次数
keyspace_misses 没命中次数
pubsub_channels 当前使用中的频道数量
pubsub_patterns 当前使用的模式的数量
latest_fork_usec 最近一次fork操作阻塞redis进程的耗时数，单位微秒
migrate_cached_sockets
Replication 主从信息
role 实例的角色，是master or slave
connected_slaves 连接的slave实例个数
master_repl_offset 主从同步偏移量,此值如果和上面的offset相同说明主从一致没延迟
repl_backlog_active 复制积压缓冲区是否开启
repl_backlog_size 复制积压缓冲大小
repl_backlog_first_byte_offset 复制缓冲区里偏移量的大小
repl_backlog_histlen 此值等于 master_repl_offset-repl_backlog_first_byte_offset,该值不会超过repl_backlog_size的大小
CPU CPU信息
used_cpu_sys 将所有redis主进程在核心态所占用的CPU时求和累计起来
used_cpu_user 将所有redis主进程在用户态所占用的CPU时求和累计起来
used_cpu_sys_children 将后台进程在核心态所占用的CPU时求和累计起来
used_cpu_user_children 将后台进程在用户态所占用的CPU时求和累计起来
Cluster 集群信息
cluster_enabled 实例是否启用集群模式
Keyspace 数据库相关的统计信息
db0 db0的key的数量,以及带有生存期的key的数,平均存活时间

参考资料

  1. stackoverflow
  2. LUA脚本
]]> <p>收集了info命令的中文解释</p> <table> <thead> <tr> <th>信息</th> <th>中文解释</th> </tr> </thead> <tbody> <tr> <td>Server</td> <td>服务信息</td> </tr> <tr> <t redis集群搭建 http://tungsing.cc/2018/12/10/cache/redis/redis-cluster/ 2018-12-10T05:54:54.024Z 2019-05-18T08:34:32.881Z 环境
  • CentOS7 操作系统
  • 已安装好的Redis，具体安装看上一篇

集群搭建

同台机器集群搭建

  1. 创建文件夹
    我们设计集群中 Redis 节点的端口号为 9000-9005，端口号即集群下各实例文件夹。数据存放在 端口号/data 文件夹中。

    1
    2
    3
    # mkdir /opt/redis_cluster
    # cd /opt/redis_cluster
    # mkdir -p 9000/data 9001/data 9002/data 9003/data 9004/data 9005/data

  2. 复制一个redis.conf文件到9000目录下，并修改
    从源码包中复制配置文件并修改

    1
    2
    # cp /opt/redis-4.0.11/redis.conf /opt/redis_cluster/9000
    # vi /opt/redis_cluster/9000/redis.conf

    重点修改以下配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    port 9000（每个节点的端口号）
    daemonize yes
    #bind 127.0.0.1(绑定当前机器 IP,可以不配置)
    dir /opt/redis_cluster/9000/data/（数据文件存放位置）
    pidfile /var/run/redis_9000.pid（pid 9000和port要对应）
    cluster-enabled yes（启动集群模式）
    cluster-config-file nodes9000.conf（9001和port要对应）
    cluster-node-timeout 15000
    appendonly yes
    protected-mode no(保护模式设置为no，如果启用了，则只能够通过lookback ip(127.0.0.1)访问Redis cache)

  3. 把配置好的复制5份

    1
    2
    3
    4
    5
    # cp -rf /opt/redis_cluster/9000/* /opt/redis_cluster/9001
    # cp -rf /opt/redis_cluster/9000/* /opt/redis_cluster/9002
    # cp -rf /opt/redis_cluster/9000/* /opt/redis_cluster/9003
    # cp -rf /opt/redis_cluster/9000/* /opt/redis_cluster/9004
    # cp -rf /opt/redis_cluster/9000/* /opt/redis_cluster/9005

  4. 挨个修改实例的配置文件
    通过搜索会发现其实只有四个点需要修改，我们全局替换下吧，进入相应的节点文件夹，做替换就好了，不放心再手工检查下

    1
    2
    # vi /opt/redis_cluster/9001/redis.conf
    :%s/9001/9002

  5. 启动

    1
    2
    3
    4
    5
    6
    # /usr/local/bin/redis-server /opt/redis_cluster/9000/redis.conf
    # /usr/local/bin/redis-server /opt/redis_cluster/9001/redis.conf
    # /usr/local/bin/redis-server /opt/redis_cluster/9002/redis.conf
    # /usr/local/bin/redis-server /opt/redis_cluster/9003/redis.conf
    # /usr/local/bin/redis-server /opt/redis_cluster/9004/redis.conf
    # /usr/local/bin/redis-server /opt/redis_cluster/9005/redis.conf

  6. 检查是否启动成功

    1
    2
    # ps -ef |grep redis
    # /usr/local/bin/redis-cli -h 127.0.0.1 -p 9000

    连接成功，set值会报(error) CLUSTERDOWN Hash slot not served错误，原因是实例之间无法相互发现，我们继续

  7. 安装集群所需软件
    由于 Redis 集群是用ruby实现的集群管理，所以安装ruby相关软件

    1
    2
    3
    # yum install ruby
    # yum install rubygems
    # gem install redis

    此处需要安装大于等于2.2的ruby版本

  8. 配置集群
    通过redis-trib.rb命令创建集群，如果/usr/local/bin/目录没有，从源码包拷贝一个即可

    1
    # /usr/local/bin/redis-trib.rb create --replicas 1 127.0.0.1:9000 127.0.0.1:9001 127.0.0.1:9002 127.0.0.1:9003 127.0.0.1:9004 127.0.0.1:9005

    交互过程中输入yes，同意即可，–replicas 1表示主从复制比例为 1:1，即一个主节点对应一个从节点

  9. 验证

    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
      # /usr/local/bin/redis-cli -h 127.0.0.1 -p 9000
    127.0.0.1:9000> cluster info
    cluster_state:ok
    cluster_slots_assigned:16384
    cluster_slots_ok:16384
    cluster_slots_pfail:0
    cluster_slots_fail:0
    cluster_known_nodes:6
    cluster_size:3
    cluster_current_epoch:6
    cluster_my_epoch:1
    cluster_stats_messages_ping_sent:1122
    cluster_stats_messages_pong_sent:1060
    cluster_stats_messages_sent:2182
    cluster_stats_messages_ping_received:1060
    cluster_stats_messages_pong_received:1102
    cluster_stats_messages_received:2162
    127.0.0.1:9000> cluster nodes
    4f8c920acc559c11153c5aaf856820ca39c443cb 10.200.1.11:9000@19000 myself,master - 0 1544424469000 1 connected 0-5460
    ec2af1f981c08bf01131545369c0600b91c5172c 10.200.1.11:9004@19004 slave 4f8c920acc559c11153c5aaf856820ca39c443cb 0 1544424468000 5 connected
    bcc85b3502c107f18557d11889739a2b6f0ed896 10.200.1.11:9003@19003 slave aadb89ee25e9849e758529c477f9af6ede99850a 0 1544424467000 4 connected
    923d1b67ee012927bf4de345143d5f93670c97b5 10.200.1.11:9001@19001 master - 0 1544424468909 2 connected 5461-10922
    aadb89ee25e9849e758529c477f9af6ede99850a 10.200.1.11:9002@19002 master - 0 1544424469920 3 connected 10923-16383
    70fad7237c2e8bb308167f7e8b7a7b670d333564 10.200.1.11:9005@19005 slave 923d1b67ee012927bf4de345143d5f93670c97b5 0 1544424468000 6 connected
    127.0.0.1:9000>

    通过命令，可以详细的看出集群信息和各个节点状态，主从信息以及连接数、槽信息等

  10. 测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # /usr/local/bin/redis-cli -c -h 10.200.1.11 -p 9000
    10.200.1.11:9000> set name test
    -> Redirected to slot [5798] located at 10.200.1.11:9001
    OK
    10.200.1.11:9001> get name
    "test"
    10.200.1.11:9001> keys *
    1) "name"
    2) "cache:test3"
    10.200.1.11:9001>

    -c 表示集群模式

不同机器的集群搭建

和同一台机器搭建唯一的区别是通过redis-trib.rb命令创建集群，随便在一个实例上执行即可

参考资料

Redis 集群搭建详细指南

]]> <h4 id="环境"><a href="#环境" class="headerlink" title="环境"></a>环境</h4><ul> <li>CentOS7 操作系统</li> <li>已安装好的Redis，具体安装看上一篇</li> </ul> Linux下安装redis http://tungsing.cc/2018/12/10/cache/redis/redis-install-linux/ 2018-12-10T02:53:59.451Z 2019-05-18T08:34:42.616Z 环境
  • CentOS7 操作系统
  • Redis4 安装包

安装

yum方式

  1. 添加常用源

    1
    # yum install epel-release

  2. 安装redis

    1
    # yum install redis -y

  3. 启动redis

    1
    # systemctl start redis.service

  4. 把redis服务作为开机启动项

    1
    # systemctl enable redis.service

  5. 测试是否安装成功

    1
    # redis-cli

    测试结果：

    1
    2
    3
    4
    5
    6
    7
    127.0.0.1:6379> set name test
    OK
    127.0.0.1:6379> get name
    "test"
    127.0.0.1:6379> keys *
    1) "name"
    127.0.0.1:6379>
源码方式

  1. 官网下载所需源码安装包

    1
    # wget http://download.redis.io/releases/redis-4.0.11.tar.gz

  2. 解压源码

    1
    # tar -zxvf redis-4.0.11.tar.gz

  3. 打开解压目录执行安装

    1
    2
    3
    # cd /opt/redis-4.0.11/src
    # make
    # make install

    安装过程中如果出现少依赖包，安装好依赖包后再执行此命令，
    默认安装到/usr/local/bin/目录，也可以通过–prefix=/path自定义安装目录

  4. 检查是否安装成功

    1
    2
    3
    # cd /usr/local/bin/
    # ls
    redis-benchmark  redis-check-aof  redis-check-rdb  redis-cli  redis-sentinel  redis-server

  5. 配置并启动
    拷贝/opt/redis-4.0.11/redis.conf文件到一个目录或不拷贝直接用,然后启动

    1
    # /usr/local/bin/redis-server /opt/redis-4.0.11/redis.conf

  6. 测试

    1
    # /usr/local/bin/redis-cli

结语

开始Redis之旅吧！

]]> <h4 id="环境"><a href="#环境" class="headerlink" title="环境"></a>环境</h4><ul> <li>CentOS7 操作系统</li> <li>Redis4 安装包</li> </ul> Windows下安装redis http://tungsing.cc/2018/12/10/cache/redis/redis-install/ 2018-12-10T02:03:49.134Z 2019-05-18T08:34:46.869Z 环境
  • Windows10 操作系统
  • Redis 安装包

下载redis安装包

在github下载Redis-x64-3.2.100.zip包

安装

命令方式
  1. 解压Redis-x64-3.2.100.zip

  2. 在解压后文件夹中的CMD命令窗口运行下面命令

    1
    # redis-server.exe redis.windows.conf

    结果如图：

服务方式
  1. 解压Redis-x64-3.2.100.zip

  2. 在解压后文件夹中的CMD命令窗口运行下面命令，把redis部署为windows服务

    1
    # redis-server.exe --service-install redis.windows.conf

    结果如图：

  3. 启动redis服务
    • 用redis-server –service-start命令启动
    • 或在控制面板–管理工具–服务中启动
测试

在解压后文件夹中的CMD命令窗口运行下面命令

1
# redis-cli.exe

结语

开始Redis之旅吧！

]]> <h4 id="环境"><a href="#环境" class="headerlink" title="环境"></a>环境</h4><ul> <li>Windows10 操作系统</li> <li>Redis 安装包</li> </ul> <h4 id="下载redis安装包"><a href="#下载redis安装包" class="headerlink" title="下载redis安装包"></a>下载redis安装包</h4><p>在<a href="https://github.com/MicrosoftArchive/redis/releases">github</a>下载Redis-x64-3.2.100.zip包</p> 初识redis http://tungsing.cc/2018/12/06/cache/redis/redis/ 2018-12-06T01:45:34.281Z 2019-05-18T08:34:53.528Z Redis 介绍

Redis 是一款开源的，基于 BSD 许可的，高级键值 (key-value) 缓存 (cache) 和存储 (store) 系统。由于 Redis 的键包括 string，hash，list，set，sorted set，bitmap 和 hyperloglog，所以常常被称为数据结构服务器。你可以在这些类型上面运行原子操作，例如，追加字符串，增加哈希中的值，加入一个元素到列表，计算集合的交集、并集和差集，或者是从有序集合中获取最高排名的元素。

为了满足高性能，Redis 采用内存 (in-memory) 数据集 (dataset)。根据你的使用场景，你可以通过每隔一段时间转储数据集到磁盘，或者追加每条命令到日志来持久化。持久化也可以被禁用，如果你只是需要一个功能丰富，网络化的内存缓存。
Redis 还支持主从异步复制，非常快的非阻塞初次同步、网络断开时自动重连局部重同步。 其他特性包括：

  • 事务
  • 订阅/发布
  • Lua 脚本
  • 带 TTL 的键
  • LRU 回收健
  • 自动故障转移 (failover)

你可以通过多种语言来使用 Redis。

Redis 是由 ANSI C 语言编写的，在无需额外依赖下，运行于大多数 POSIX 系统，如 Linux、*BSD、OS X。Redis 是在 Linux 和 OS X 两款操作系统下开发和充分测试的，我们推荐 Linux 为部署环境。Redis 也可以运行在 Solaris 派生系统上，如 SmartOS，但是支持有待加强。没有官方支持的 Windows 构建版本，但是微软开发和维护了一个 64 位 Windows 的版本。

与Memcache比较

比较点 memcache redis
网站 www.memcached.org redis.io
初始版本 2003 2009
服务器端脚本 没有 LUA脚本
分区 没有 Sharding
复制 没有 主从复制和多主复制
访问控制 SASL(简单认证与安全层) 简单的基于密码的控制
数据持久化 没有 有
事务 没有 乐观锁、命令块和脚本的原子执行

参考资料

1.stackoverflow
2.LUA脚本

]]> <h4 id="Redis-介绍"><a href="#Redis-介绍" class="headerlink" title="Redis 介绍"></a>Redis 介绍</h4><p>Redis 是一款开源的，基于 BSD 许可的，高级键值 (key-value) 缓存 (cache) 和存储 (store) 系统。由于 Redis 的键包括 string，hash，list，set，sorted set，bitmap 和 hyperloglog，所以常常被称为数据结构服务器。你可以在这些类型上面运行原子操作，例如，追加字符串，增加哈希中的值，加入一个元素到列表，计算集合的交集、并集和差集，或者是从有序集合中获取最高排名的元素。</p> Weblogic 静默安装 http://tungsing.cc/2018/09/14/web/container/weblogic-install/ 2018-09-14T02:57:31.668Z 2019-05-18T08:37:48.968Z 准备
  • Linux CentOS6.9 系统
  • Weblogic 12c
  • JDK 1.8

下载Weblogic Server

直接去官网下载,下载需要用户名和密码，如果没有注册一个即可

解压

解压获得到fmw_12.2.1.0.0_wls.jar文件

安装Weblogic Server

准备
  1. 如果没有安装JDK，需要安装，保证环境变量正确

  2. 新建用户组weblogic

    1
    #groupadd weblogic

  3. 新建用户weblogic 并修改用户密码
    添加用户，并用-g参数来制定 web用户组

    1
    2
    #useradd -g weblogic weblogic
    #passwd 密码

  4. 切换到weblogic用户

  5. 准备安装目录 
    1
    /opt/weblogic
安装

  1. 创建响应文件wls.rsp

    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
    [ENGINE]
    #DO NOT CHANGE THIS.
    Response File Version=1.0.0.0.0
    [GENERIC]
    #The oracle home location. This can be an existing Oracle Home or a new Oracle Home
    ORACLE_HOME=/opt/weblogic/middleware
    #Set this variable value to the Installation Type selected. e.g. WebLogic Server, Coherence, Complete with Examples.
    INSTALL_TYPE=WebLogic Server
    #Provide the My Oracle Support Username. If you wish to ignore Oracle Configuration Manager configuration provide empty string for user name.
    MYORACLESUPPORT_USERNAME=
    #Provide the My Oracle Support Password
    MYORACLESUPPORT_PASSWORD=<SECURE VALUE>
    #Set this to true if you wish to decline the security updates. Setting this to true and providing empty string for My Oracle Support username will ignore the Oracle Configuration Manager co
    nfiguration
    DECLINE_SECURITY_UPDATES=true
    #Set this to true if My Oracle Support Password is specified
    SECURITY_UPDATES_VIA_MYORACLESUPPORT=false
    #Provide the Proxy Host
    PROXY_HOST=
    #Provide the Proxy Port
    PROXY_PORT=
    #Provide the Proxy Username
    PROXY_USER=
    #Provide the Proxy Password
    PROXY_PWD=<SECURE VALUE>
    #Type String (URL format) Indicates the OCM Repeater URL which should be of the format [scheme[Http/Https]]://[repeater host]:[repeater port]
    COLLECTOR_SUPPORTHUB_URL=

  2. 创建Loc文件 oraInst.loc

    1
    2
    3
    4
    # vi /opt/weblogic/oraInst.loc
    inventory_loc=/opt/weblogic/oraInventory
    inst_group=weblogic

  3. 保证所需要得目录weblogic用户要用读写权限

  4. 安装, wls.rsp，oraInst.loc必须指定绝对路径
    1
    # java -jar fmw_12.2.1.0.0_wls.jar  -silent  -responseFile  /opt/weblogic/wls.rsp  -invPtrLoc /opt/weblogic/oraInst.loc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
启动程序日志文件为/tmp/OraInstall2018-10-02_11-25-44AM/launcher2018-10-02_11-25-44AM.log。
正在提取文件......................
......................................
已启用此会话的验证。
正在验证数据
复制文件
完成百分比: 10
完成百分比: 20
完成百分比: 30
完成百分比: 40
完成百分比: 50
完成百分比: 60
完成百分比: 70
完成百分比: 80
完成百分比: 90
完成百分比: 100
Oracle Fusion Middleware 12c WebLogic Server 和 Coherence 12.2.1.0.0 的 安装 已成功完成。
日志已成功复制到/opt/weblogic/oraInventory/logs。

看到上面的日志表示安装成功

创建domain

  1. 准备脚本

    1
    2
    # cd /opt/weblogic/middleware/wlserver/common/templates/scripts/wlst/
    # cp basicWLSDomain.py create_domain.py

  2. 修改create_domain.py脚本

    • 设置密码

      1
      2
      3
      4
      找到
      # Please set password here before using this script, e.g. cmo.setPassword('value')
      添加
      cmo.setPassword('密码')

    • 删除其他暂时用不到的

      1
      2
      3
      # Create a JMS Server.
      到
      # Write the domain and close the domain template.

  3. 执行脚本

1
# /opt/weblogic/middleware/oracle_common/common/bin/wlst.sh  /opt/weblogic/middleware/wlserver/common/templates/scripts/wlst/create_domain.py

等待成功…

启动server
1
# /opt/weblogic/middleware/user_projects/domains/basicWLSDomain/bin/startWebLogic.sh
问题

在创建domain和启动server特别慢的时候，需要修改或添加环境配置

修改JAVA_HOME/lib/security目录下java.security

1
2
3
securerandom.source=file:/dev/random
改为
securerandom.source=file:/dev/./random

或添加环境变量

1
# export CONFIG_JVM_ARGS='-Djava.security.egd=file:/dev/./urandom'

结语

安装好weblogic才是第一步，后续还有很多要学习的

参考资料

  1. Weblogic 12C 静默安装
  2. 官方文档
]]> <h4 id="准备"><a href="#准备" class="headerlink" title="准备"></a>准备</h4><ul> <li>Linux CentOS6.9 系统</li> <li>Weblogic 12c</li> <li>JDK 1.8</li> </ul> <h4 id="下载Weblogic-Server"><a href="#下载Weblogic-Server" class="headerlink" title="下载Weblogic Server"></a>下载Weblogic Server</h4><p>直接去<a href="http://www.oracle.com/technetwork/middleware/weblogic/downloads/wls-main-097127.html">官网</a>下载,下载需要用户名和密码，如果没有注册一个即可</p>