Redis底层原理--04. Redis 功能的实现
Redis底层原理--03. Redis 数据类型

Redis底层原理--03. Redis 数据类型

1. 对象处理机制

由于 redis 需要对每一个 key 产生不同的操作,所以Redis 必须让每个键都带有类型信息,使得程序可以检查键的类型,并为它选择合适的处理方式

为了解决以上问题, Redis 构建了自己的类型系统,这个系统的主要功能包括:

  • redisObject 对象。基于 redisObject 对象的类型检查。
  • 基于 redisObject 对象的显式多态函数。
  • 对 redisObject 进行分配、共享和销毁的机制。
阅读更多
Redis底层原理--02. 内存映射数据结构

Redis底层原理--02. 内存映射数据结构

1. 整数集合

整数集合(intset)用于有序、无重复地保存多个整数值,它会根据元素的值,自动选择该用什
么长度的整数类型来保存元素

举个例子,如果在一个 intset 里面,最长的元素可以用 int16_t 类型来保存,那么这个 intset
的所有元素都以 int16_t 类型来保存。

另一方面,如果有一个新元素要加入到这个 intset并且这个元素不能用 int16_t 类型来保存
——比如说,新元素的长度为 int32_t ,那么这个 intset 就会自动进行“升级” :先将集合中现有的所有元素从 int16_t 类型转换为 int32_t 类型,接着再将新元素加入到集合中。

阅读更多
Redis底层原理--01. Redis 中的数据结构

Redis底层原理--01. Redis 中的数据结构

简单的字符串

1. 设计要点

在 C 语言中,字符串可以用一个 \0 结尾的 char 数组来表示。 比如说,hello world 在 C 语言中就可以表示为 “hello world\0” 。

这种简单的字符串表示在大多数情况下都能满足要求,但是,它并不能高效地支持长度计算和 追加(append)这两种操作:

  • 每次计算字符串长度(strlen(s))的复杂度为 θ(N) 。

  • 对字符串进行 N 次追加,必定需要对字符串进行 N 次内存重分配(realloc)。

在 Redis 内部,字符串的追加和长度计算并不少见,而 APPEND 和 STRLEN 更是这两种操 作在 Redis 命令中的直接映射,这两个简单的操作不应该成为性能的瓶颈。

另外,Redis 除了处理 C 字符串之外,还需要处理单纯的字节数组,以及服务器协议等内容, 所以为了方便起见,Redis 的字符串表示还应该是二进制安全的:程序不应对字符串里面保存 的数据做任何假设,数据可以是以 \0 结尾的 C 字符串,也可以是单纯的字节数组,或者其他 格式的数据。

考虑到这两个原因,Redis 使用 sds 类型替换了 C 语言的默认字符串表示: sds 既可以高效地 实现追加和长度计算,并且它还是二进制安全的。

2. sds 数据结构

阅读更多

Redis系列--布隆过滤器

在 Redis 的使用场景中,基本的架构图如下:
布隆过滤器
如果在缓存中查询不到数据,会直接到 DB 中查询,查询的数据再插入到缓存中。例如我们根据 orderId 查询对应的订单,具体伪代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
OrderEntity getOrder(String orderId){
//1. 查询缓存
OrderEntity orderEntity= getFromRedis(orderId);
if (orderEntity != null) {
return orderEntity;
}
//2. 缓存不存在
orderEntity=getFromDb(orderId);
//3. 塞入缓存
setRedis(orderEntity);
//4. 返回查询的值
return orderEntity;
}

如果这是时候客户端查询的 orderId 绝大多数都不在缓存中,这样就会带来一个 缓存穿透 的问题。如果有客户端恶意攻击,例如客户端使用 UUID 来访问我们的数据或者接口,势必会导致访问压力都落到 DB 上面,导致 DB 压力的上升。

为了解决这个缓存穿透,可以在 Redis 和 DB 中间增加一个过滤器,在访问 DB 前询问下过滤器,然后再决定是否查询 DB,具体结构图如下:

布隆过滤器

hash过滤

Hash 是一个简单 key — value 结构,如果在数据量不大的情况下,可以尝试把 DB 中的数据中的单列存储在缓存中

1
2
3
4
5
00001 1
00002 1
....

99999 1

在客户端访问时,可以先到 hash 中看下是否有值,然后根据过滤器返回值来确定是否查询 DB。

阅读更多

使用 docker-compose 打包多个应用

准备工作

这次部署两个项目,一个是 web 站点项目,一个是爬虫的后台应用项目。

  1. 两个项目的 jar 包,分别为 app.jar,spider.jar
  2. 两个应用都依赖 redis 和 mysql
  3. mysql 初始化需要的 sql 文件

docker file 文件

docker file 是 使用 docker 部署应用的命令。 具体的命令可以参考 Docker 命令.

由于是两个文件,所以需要两个不同的 Dockerfile .具体的 build 的内容如下:

Dockerfile web 的 build 文件

1
2
3
4
5
6
7
8
9
10
FROM java:8
MAINTAINER fuwei<laofu_online@163.com>

COPY oncesearch-portal-1.0-SNAPSHOT.jar /app.jar

CMD ["--server.port=80"]
EXPOSE 80

ENTRYPOINT ["java","-jar","/app.jar"]

爬虫的文件

阅读更多

一个正则表达式导致 CPU 高的问题排查过程

这篇文章记录一个正则表达是导致 CPU 高的问题排查。由于无法直接使用线上的代码测试,所以我自己把代码整理了下来,具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
public class AppMain {
public static void main(String[] args) throws InterruptedException {
final String regex="^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
final String email="blog.laofu.online.fuweilao@vip.qq.com#";
for (int i = 0; i < 1000000; i++) {
Matcher matcher = RegexUtils.matcher(regex, email);
matcher.find();
Thread.sleep(10);
// matcher.group();
}
}
}

当运行程序的时候,我们可以看到 java 的进程占用了 CPU 了 82.1%,由于我使用的服务器是 1核+2G, 所以 load avg 占用也很高。

image-20201005230510905

使用 top -H -p 4214 查看各个线程占用的情况

image-20201005230556871
hex
使用 printf '%x\n' 4217 把进程转成 16 进制值为 1079。执行 jstack 4214|grep 1079 -A 100得到线程的堆栈信息:

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
"main" #1 prio=5 os_prio=0 tid=0x00007f943004c800 nid=0x1079 runnable [0x00007f9439fe0000]
java.lang.Thread.State: RUNNABLE
at java.util.regex.Pattern$Curly.match0(Pattern.java:4264)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
// at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4195)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4293)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4195)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4293)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4195)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4293)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.match(Pattern.java:4799)
at java.util.regex.Pattern$GroupTail.match(Pattern.java:4731)
at java.util.regex.Pattern$Ques.match(Pattern.java:4196)
at java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
at java.util.regex.Pattern$Curly.match(Pattern.java:4248)
at java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
at java.util.regex.Pattern$Loop.matchInit(Pattern.java:4815)
at java.util.regex.Pattern$Prolog.match(Pattern.java:4755)
at java.util.regex.Pattern$Begin.match(Pattern.java:3539)
at java.util.regex.Matcher.search(Matcher.java:1248)
at java.util.regex.Matcher.find(Matcher.java:637)
at org.rz.search.spider.AppMain.main(AppMain.java:13)

"VM Thread" os_prio=0 tid=0x00007f94300cc800 nid=0x1079 runnable

"VM Periodic Task Thread" os_prio=0 tid=0x00007f9430121000 nid=0x1079 waiting on condition

JNI global references: 5

从上面的堆栈信息可以看出来是正则的递归调用,导致了很深的堆栈。
查看最终的堆栈入口:at org.rz.search.spider.AppMain.main(AppMain.java:13) 可以断定问题是正则匹配的原因。

为什么一个正则会导致CPU飙高?

阅读更多

Linux TOP 命令详解

TOP 命令的含义

TOP 命令是常用的 Linux 性能监控的命令,执行后,界面如下:

image-20200920135205175

第一行

1
top - 14:09:04 up 3 days, 21:20,  0 users,  load average: 0.52, 0.58, 0.59

当前时间(date)、系统已运行时间(last reboot)、当前登录用户的数量(who )、最近5、10、15分钟内的平均负载

CPU load的含义

load average: 0.52, 0.58, 0.59 代表 1min 5min 15min的 CPU 的平均负载

一般超过 1 代表拥堵,正常控制在 0.7 以下。如果是多核心,需要除于核心数。

这个负载的含义是什么呢? 0.52 代表是什么意思?

阅读更多

简单聊聊 MyCat 分库分表

MyCat 是基于服务器代理模式的数据库分库的中间件,原理是对 SQL 进行转发,具体的架构图如下:

image-20200919120231986

我们知道,数据的拆分必然会对事物的原子性带来影响,那如果保证在分库的同时,又能保证事务的原子性呢?

如何解决分布式事务

XA 协议

XA协议是一个开源的事务协议,相关文【XA 事务处理】

XA 协议在第二段协议 commit 事提交务后,如果出现了有的机器事务没有提交成功,有的机器已经提交成功,这时已经提交的数据,数据就无法再次回滚,这样就造成了数据不一致的问题。

image-20200919224824416

三段提交协议

阅读更多

MySQL 分库分表的方式

对于分库分表来说,具体有两种方式:垂直拆分和水平拆分
垂直拆分主要是业务的细化和独立,和业务联系比较密切。所以本文只讨论更通用的水平拆分。

为什么分库分表

  1. 降低单机 MySQL 的性能
  2. 降低单表或者单库的数据量,减少数据库的查询压力
  3. 突破单机的容量限制

    分库分表的方式

  4. 范围区分(range):按月\按区\按其他的等特殊的属性维度进行分片
  5. 预定义范围:预估有多少数据的容量,对数据进行范围的分配,0-100->A 101-200->B
  6. 取模 Hash:对指定的字段进行取模运算,匹配对应的库和表。

分库分表带来的问题

  1. 数据的维护成本高
  2. 跨库的业务join
  3. 分布式事务的性能低下
  4. 自增 id 的生成问题
  5. 非分片字段查询的轮询的浪费
  6. 多节点排序问题

分库分表的中间件

对于分库分表的中间件有很多,Shardingsphere,Tddl,MyCat,cobar。从架构上分,主要分为两种:JDBC应用方式Proxy模式

JDBC应用模式是基于客户端的分片,有客户端根据Sql和规则,决定具体执行的 sql 的服务器。代表有Shardingsphere,Tddl

image-20200919120019296

JDBC应用模式 优点:

阅读更多