<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>RJOMG</title><description>技术笔记</description><link>https://rjomg-blog.pages.dev/</link><language>zh_CN</language><item><title>安装KubeSphere</title><link>https://rjomg-blog.pages.dev/posts/wp-3441/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3441/</guid><pubDate>Fri, 14 Jun 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标:安装KubeSphere all-in-one&lt;/p&gt;
&lt;h2&gt;1.安装Docker&lt;/h2&gt;
&lt;p&gt;链接:&lt;a href=&quot;https://help.aliyun.com/zh/ecs/use-cases/install-and-use-docker-on-a-linux-ecs-instance#aa11e8210adyt&quot;&gt;阿里云的安装方法&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;以下是腾讯云安装方法&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 安装docker
$ curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun


# 启动docker
$ systemctl start docker
$ systemctl enable docker
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;设置阿里云镜像源和腾讯云源&lt;/p&gt;
&lt;p&gt;获取自己的阿里云镜像加速&lt;/p&gt;
&lt;p&gt;链接:阿里云源&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 设置阿里云镜像源
$ sudo mkdir -p /etc/docker


$ sudo tee /etc/docker/daemon.json &amp;lt;&amp;lt;-&apos;EOF&apos;
{
  &quot;registry-mirrors&quot;: [
       &quot;https://mirror.ccs.tencentyun.com&quot;,
       &quot;https://xxxx.mirror.aliyuncs.com&quot;,
       &quot;https://docker.m.daocloud.io&quot;,
       &quot;https://dockerproxy.com&quot;,
       &quot;https://docker.nju.edu.cn&quot;,
       &quot;https://docker.mirrors.ustc.edu.cn&quot;
  ]
}
EOF


# 重启
$ sudo systemctl daemon-reload
$ sudo systemctl restart docker
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.安装KubeSphere&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://kubesphere.io/zh/docs/v3.4/quick-start/all-in-one-on-linux/#%E6%AD%A5%E9%AA%A4-2%E4%B8%8B%E8%BD%BD-kubekey&quot;&gt;KubeSphere官网文档&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;安装依赖&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 安装依赖
# 清除缓存
$ yum makecache

$ yum -y install socat
$ yum -y install conntrack-tools
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;下载KubeSphere&lt;/h3&gt;
&lt;p&gt;下载完成后当前目录会有一个&quot;kk&quot;的文件&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 当服务器无法访问Github,需要设置
$ export KKZONE=cn


# 下载
$ curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.13 sh -
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;安装&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 修改kk的文件可执行权限
$ chmod +x kk

# 安装k8s和KubeSphere, 因为当前安装模式是all-in-one,所以基本不需要做任何配置
./kk create cluster --with-kubernetes v1.22.12 --with-kubesphere v3.4.1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;安装的过程中有可能一直卡顿&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 如果一直有卡顿,可以使用下面命令去查看
$ kubectl get pods -n kubesphere-system


# 详细提示通过以下命令
# ks-console-85c97b6d7d-j6gnn,这个是上面的命令查看出来的
kubectl describe pod ks-console-85c97b6d7d-j6gnn -n kubesphere-system
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;pod节点被污染错误可以通过下面的修改&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 修改错误的pod节点,解决污染节点错误
$ kubectl edit deployment ks-installer -n kubesphere-system

# 新增这个spec.template.spec下面的
 tolerations:
      - key: &quot;node-role.kubernetes.io/master&quot;
        operator: &quot;Exists&quot;
        effect: &quot;NoSchedule&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;方法二&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 查询所有节点
$ kubectl get nodes
NAME             STATUS   ROLES                         AGE   VERSION
vm-0-12-centos   Ready    control-plane,master,worker   20h   v1.22.12


# 清空污染节点信息, 可能会删除到某些东西,谨慎使用
$ kubectl taint nodes vm-0-12-centos node-role.kubernetes.io/master-
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;安装应用商店&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 安装应用商店的其中一种办法
kubectl edit clusterconfiguration ks-installer -n kubesphere-system


# 更新以下内容
openpitrix:
  store:
    enabled: true # 将“false”更改为“true”。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Harbor&lt;/h2&gt;
&lt;p&gt;最简单的方式是通过应用商店安装&lt;/p&gt;
&lt;h3&gt;配置镜像&lt;/h3&gt;
&lt;p&gt;&quot;insecure-registries&quot;: [&quot;ip:30002&quot;]&lt;/p&gt;
&lt;h2&gt;安装Mysql&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;创建mysql-pvc持久卷&lt;/p&gt;
&lt;p&gt;挂载路径: /var/lib/mysql&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;创建配置字典mysql-config&lt;/p&gt;
&lt;p&gt;键名: my.cnf&lt;/p&gt;
&lt;p&gt;挂载路径: /etc/mysql/conf.d&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# config
[client]
default-character-set=utf8mb4

[mysql]
default-character-set=utf8mb4

[mysqld]
character-set-client-handshake=FALSE
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
init_connect=&apos;SET NAMES utf8mb4&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: mysql:5.7&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
tcp-3306
tcp-33060
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
MYSQL_ROOT_PASSWORD=&quot;youpassword&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: mysql-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-3306
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Redis&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;创建redis-pvc持久卷&lt;/p&gt;
&lt;p&gt;挂载目录:/data&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;创建配置字典redis-config&lt;/p&gt;
&lt;p&gt;键名:redis.conf&lt;/p&gt;
&lt;p&gt;挂载目录:/usr/local/redis/conf/redis.conf&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# config
# Redis 配置文件

# 绑定到所有网络接口
bind 0.0.0.0

# 禁用保护模式，允许从任何 IP 进行连接（注意安全性）
protected-mode no

# 设置 Redis 监听的端口
port 6379

# 设置持久化数据的存储目录
dir /data

# 启用 AOF（追加文件）持久化模式
appendonly yes

# 设置 Redis 访问密码，替换 yourpassword 为你的密码
requirepass EctgV2ZLrmOFWnhI

# 最大内存使用限制（单位：字节），可根据需要调整
maxmemory 256mb

# 当达到最大内存限制时的内存淘汰策略，这里使用所有键的 LRU（最近最少使用）策略
maxmemory-policy allkeys-lru

# RDB 快照备份设置
save 900 1   # 如果在 900 秒内至少有 1 个键被修改，则进行 RDB 快照备份
save 300 10  # 如果在 300 秒内至少有 10 个键被修改，则进行 RDB 快照备份
save 60 10000 # 如果在 60 秒内至少有 10000 个键被修改，则进行 RDB 快照备份

# RDB 文件名
dbfilename dump.rdb
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: redis:latest&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-6379
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
null
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: redis-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-6379
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Consul&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;不需要持久卷&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;不需要字典&lt;/p&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: consul:latest&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
tcp-8300    TCP 8300
tcp-8301    TCP 8301
udp-8301    UDP 8301
tcp-8302    TCP 8302
udp-8302    UDP 8302
tcp-8500    TCP 8500
tcp-8600    TCP 8600
udp-8600    UDP 8600
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
null
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: consul-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-8500
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Nacos&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;不需要持久卷&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;不需要配置字典&lt;/p&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: nacos/nacos-server:latest&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-8848   TCP 8848
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
MYSQL_SERVICE_HOST mysql-w8ws.go-rs // mysql服务的DNS
MYSQL_SERVICE_PORT 3306
MYSQL_SERVICE_DB_NAME nacos-data
MYSQL_SERVICE_USER root
MYSQL_SERVICE_PASSWORD ******
MODE standalone
JVM_XMS 512m
JVM_XMX 512m
JVM_XMN 256m
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: nacos-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-8848
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Elasticsearch&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;创建es-pvc持久卷&lt;/p&gt;
&lt;p&gt;挂载目录:/elasticsearch/data&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;创建配置字典es-config&lt;/p&gt;
&lt;p&gt;键名:elasticsearch.yml&lt;/p&gt;
&lt;p&gt;挂载目录:/elasticsearch/config/elasticsearch.yml&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# config
http.host: 0.0.0.0
xpack.security.enabled: false
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: elasticsearch:8.12.2&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-9200   TCP 9200
http-9300   TCP 9300
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
discovery.type single-node
ES_JAVA_OPTS -Xms512m -Xmx512m // 如果生成环境则不需要限制
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: es-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-9200
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Kibana&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;不需要持久卷&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;不需要配置字典&lt;/p&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: kibana:8.12.2&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-5601   TCP 5601
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
ELASTICSEARCH_HOSTS http://es-2gaq.go-rs:9200 // 这是es的DNS
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: kibana-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-5601
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装RocketMQ-Namesrv&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;创建rocketmq-pvc持久卷(broker共用同一个)&lt;/p&gt;
&lt;p&gt;挂载目录:/opt/store&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;不需要配置字典&lt;/p&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: foxiswho/rocketmq:server&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-9876   TCP 9876
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
不需要创建
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: null&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
不需要创建
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装RocketMQ-Broker&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;创建rocketmq-pvc持久卷(broker共用同一个)&lt;/p&gt;
&lt;p&gt;挂载目录:/opt/store&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;创建配置字典rocketmq-config&lt;/p&gt;
&lt;p&gt;键名:broker.conf&lt;/p&gt;
&lt;p&gt;挂载目录:/etc/rocketmq/broker.conf&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# config
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the &quot;License&quot;); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.


# 所属集群名字
brokerClusterName=DefaultCluster

# broker 名字，注意此处不同的配置文件填写的不一样，如果在 broker-a.properties 使用: broker-a,
# 在 broker-b.properties 使用: broker-b
brokerName=broker-a

# 0 表示 Master，&amp;gt; 0 表示 Slave
brokerId=0

# nameServer地址，分号分割
# namesrvAddr=rocketmq-nameserver1:9876;rocketmq-nameserver2:9876

# 启动IP,如果 docker 报 com.alibaba.rocketmq.remoting.exception.RemotingConnectException: connect to &amp;lt;192.168.0.120:10909&amp;gt; failed
# 解决方式1 加上一句 producer.setVipChannelEnabled(false);，解决方式2 brokerIP1 设置宿主机IP，不要使用docker 内部IP
# brokerIP1=192.168.50.75

# 在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4

# 是否允许 Broker 自动创建 Topic，建议线下开启，线上关闭 ！！！这里仔细看是 false，false，false
autoCreateTopicEnable=true

# 是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true

# Broker 对外服务的监听端口
listenPort=10911

# 删除文件时间点，默认凌晨4点
deleteWhen=04

# 文件保留时间，默认48小时
fileReservedTime=120

# commitLog 每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824

# ConsumeQueue 每个文件默认存 30W 条，根据业务情况调整
mapedFileSizeConsumeQueue=300000

# destroyMapedFileIntervalForcibly=120000
# redeleteHangedFileInterval=120000
# 检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
# 存储路径
# storePathRootDir=/home/ztztdata/rocketmq-all-4.1.0-incubating/store
# commitLog 存储路径
# storePathCommitLog=/home/ztztdata/rocketmq-all-4.1.0-incubating/store/commitlog
# 消费队列存储
# storePathConsumeQueue=/home/ztztdata/rocketmq-all-4.1.0-incubating/store/consumequeue
# 消息索引存储路径
# storePathIndex=/home/ztztdata/rocketmq-all-4.1.0-incubating/store/index
# checkpoint 文件存储路径
# storeCheckpoint=/home/ztztdata/rocketmq-all-4.1.0-incubating/store/checkpoint
# abort 文件存储路径
# abortFile=/home/ztztdata/rocketmq-all-4.1.0-incubating/store/abort
# 限制的消息大小
maxMessageSize=65536

# flushCommitLogLeastPages=4
# flushConsumeQueueLeastPages=2
# flushCommitLogThoroughInterval=10000
# flushConsumeQueueThoroughInterval=60000

# Broker 的角色
# - ASYNC_MASTER 异步复制Master
# - SYNC_MASTER 同步双写Master
# - SLAVE
brokerRole=ASYNC_MASTER

# 刷盘方式
# - ASYNC_FLUSH 异步刷盘
# - SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH

# 发消息线程池数量
# sendMessageThreadPoolNums=128
# 拉消息线程池数量
# pullMessageThreadPoolNums=128
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: foxiswho/rocketmq:broker&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-10909  TCP 10909
http-10911  TCP 10911
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
NAMESRV_ADDR  &quot;namesrv的DNS&quot;:9876
JAVA_OPTS -Duser.home=/opt
JAVA_OPT_EXT -server -Xms256m -Xmx256m -Xmn256m # 如果是线上环境则按需设置
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: null&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
不需要创建
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装RocketMQ-Console&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;不需要挂载&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;不需要配置字典&lt;/p&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: styletang/rocketmq-console-ng&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
http-8080   TCP 8080
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
不需要创建
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务:rocketmq-console-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-8080
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;安装Jaeger&lt;/h2&gt;
&lt;h3&gt;1.创建持久卷&lt;/h3&gt;
&lt;p&gt;不需要持久卷&lt;/p&gt;
&lt;h3&gt;2.创建配置字典&lt;/h3&gt;
&lt;p&gt;不需要字典&lt;/p&gt;
&lt;h3&gt;3.创建工作负载&lt;/h3&gt;
&lt;p&gt;创建有状态副本集&lt;/p&gt;
&lt;p&gt;DockerHub容器: jaegertracing/all-in-one&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 端口
tcp-14250   TCP 14250
tcp-14268   TCP 14268
tcp-16686   TCP 16686
udp-5775    UDP 5775
tcp-5778    TCP 5778
udp-6831    UDP 6831
udp-6832    UDP 6832
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;# 环境变量
null
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建服务&lt;/h3&gt;
&lt;p&gt;服务: Jaeger-nodeport&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 服务
http-16686
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>分布式基础理论 CAP和BASE理论</title><link>https://rjomg-blog.pages.dev/posts/wp-3389/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3389/</guid><pubDate>Sat, 23 Mar 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标:什么时候CAP/BASE?&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;CAP理论&lt;/h2&gt;
&lt;p&gt;cap理论是分布式系统的理论基石&lt;/p&gt;
&lt;p&gt;如果你你是一个分布式系统，那么你必须要满足一点：分区容错性&lt;/p&gt;
&lt;p&gt;一致性/可用性/分区容错性/这三个基本需求，最多只能同时满足其中的2个。&lt;/p&gt;
&lt;h3&gt;一致性(Consistency)&lt;/h3&gt;
&lt;p&gt;“all nodes see the same data at the same time”,即更新操作成功并返回客户端后，所有节点在同一时间的数据完全一致，这就是分布式的一致性。一致性的问题在并发系统中不可避免，对于客户端来说，一致性指的是并发访问时更新过的数据如何获取的问题。从服务端来看，则是更新如何复制分布到整个系统，以保证数据最终一致。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;可用性&lt;/strong&gt;(&lt;strong&gt;Availability&lt;/strong&gt;)&lt;/h3&gt;
&lt;p&gt;可用性指“Reads and writes always succeed”，即服务一直可用，而且是正常响应时间。好的可用性主要是指系统能够很好的为用户服务，不出现用户操作失败或者访问超时等用户体验不好的情况。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;&lt;strong&gt;分区容错性&lt;/strong&gt;&lt;/strong&gt;(&lt;strong&gt;Partition Tolerance&lt;/strong&gt;)&lt;/h3&gt;
&lt;p&gt;即分布式系统在遇到某节点或网络分区故障的时候，仍然能够对外提供满足一致性和可用性的服务。分区容错性要求能够使应用虽然是一个分布式系统，而看上去却好像是在一个可以运转正常的整体。比如现在的分布式系统中有某一个或者几个机器宕掉了，其他剩下的机器还能够正常运转满足系统需求，对于用户而言并没有什么体验上的影响。&lt;/p&gt;
&lt;h3&gt;CAP取舍策略&lt;/h3&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2024/03/1709984719-cap.png&quot; class=&quot;wp-image-3412&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h4&gt;CA without P&lt;/h4&gt;
&lt;p&gt;**如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但放弃P的同时也就意味着放弃了系统的扩展性，也就是分布式节点受限，没办法部署子节点，这是违背分布式系统设计的初衷的。&lt;/p&gt;
&lt;h4&gt;CP without A&lt;/h4&gt;
&lt;p&gt;**如果不要求A（可用），相当于每个请求都需要在服务器之间保持强一致，而P（分区）会导致同步时间无限延长(也就是等待数据同步完才能正常访问服务)，一旦发生网络故障或者消息丢失等情况，就要牺牲用户的体验，等待所有数据全部一致了之后再让用户访问系统。设计成CP的系统其实不少，最典型的就是分布式数据库，如Redis、HBase等。对于这些分布式数据库来说，数据的一致性是最基本的要求，因为如果连这个标准都达不到，那么直接采用关系型数据库就好，没必要再浪费资源来部署分布式数据库。&lt;/p&gt;
&lt;h4&gt;AP wihtout C&lt;/h4&gt;
&lt;p&gt;**要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。典型的应用就如某米的抢购手机场景，可能前几秒你浏览商品的时候页面提示是有库存的，当你选择完商品准备下单的时候，系统提示你下单失败，商品已售完。这其实就是先在 A（可用性）方面保证系统可以正常的服务，然后在数据的一致性方面做了些牺牲，虽然多少会影响一些用户体验，但也不至于造成用户购物流程的严重阻塞。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;BASE理论&lt;/h2&gt;
&lt;p&gt;分布式系统中的一致性是 弱一致性 单数据库 mysql的一致性 强一致性&lt;br /&gt;
BASE是Basically Available（基本可用）、Soft state（软状态）和Eventually consistent（最终一致性）三个短语的缩写。BASE理论是对CAP中一致性和可用性权衡的结果，其来源于对大规模互联网系统分布式实践的总结， 是基于CAP定理逐步演化而来的。BASE理论的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;基本可用&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;基本可用是指分布式系统在出现不可预知故障的时候，允许损失部分可用性—-注意，这绝不等价于系统不可用。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;响应时间上的损失。正常情况下，一个在线搜索引擎需要在0.5秒之内返回给用户相应的查询结果，但由于出现故障，查询结果的响应时间增加了1~2秒&lt;/li&gt;
&lt;li&gt;系统功能上的损失：正常情况下，在一个电子商务网站上进行购物的时候，消费者几乎能够顺利完成每一笔订单，但是在一些节日大促购物高峰的时候，由于消费者的购物行为激增，为了保护购物系统的稳定性，部分消费者可能会被引导到一个降级页面&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;&lt;strong&gt;软状态&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;软状态指允许系统中的数据存在中间状态，并认为该中间状态的存在不会影响系统的整体可用性，即允许系统在不同节点的数据副本之间进行数据同步的过程存在延时&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;最终一致性&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;最终一致性强调的是所有的数据副本，在经过一段时间的同步之后，最终都能够达到一个一致的状态。因此，最终一致性的本质是需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性。总的来说，BASE理论面向的是大型高可用可扩展的分布式系统，和传统的事物ACID特性是相反的，它完全不同于ACID的强一致性模型，而是通过牺牲强一致性来获得可用性，并允许数据在一段时间内是不一致的，但最终达到一致状态。但同时，在实际的分布式场景中，不同业务单元和组件对数据一致性的要求是不同的，因此在具体的分布式系统架构设计过程中，ACID特性和BASE理论往往又会结合在一起。&lt;/p&gt;
&lt;p&gt;简单来讲大部分时候都是使用BASE&lt;/p&gt;
</content:encoded></item><item><title>Elasticsearch Docker安装和中文分词插件</title><link>https://rjomg-blog.pages.dev/posts/wp-3346/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3346/</guid><pubDate>Sun, 03 Mar 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标:安装Elasticsearch和Kibana并加入中文分词&lt;/p&gt;
&lt;h2&gt;安装&lt;/h2&gt;
&lt;h3&gt;Elasticsearch&lt;/h3&gt;
&lt;h4&gt;elasticsearch.yml&lt;/h4&gt;
&lt;p&gt;8.0本地访问需要关闭SSL,我这里全都设置成了False,如有需要自己设置为True&lt;/p&gt;
&lt;p&gt;使用方法:&lt;/p&gt;
&lt;p&gt;把该文件放在挂载的目录&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;config/elasticsearch.yml&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;或者直接复制进Docker容器内&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;/usr/share/elasticsearch/config/elasticsearch.yml&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cluster.name: &quot;docker-cluster&quot;
network.host: 0.0.0.0

#----------------------- BEGIN SECURITY AUTO CONFIGURATION -----------------------
#
# The following settings, TLS certificates, and keys have been automatically      
# generated to configure Elasticsearch security features on 28-02-2024 16:42:10
#
# --------------------------------------------------------------------------------

# Enable security features
xpack.security.enabled: false

xpack.security.enrollment.enabled: false

# Enable encryption for HTTP API client connections, such as Kibana, Logstash, and Agents
xpack.security.http.ssl:
  enabled: false
  keystore.path: certs/http.p12

# Enable encryption and mutual authentication between cluster nodes
xpack.security.transport.ssl:
  enabled: false
  verification_mode: certificate
  keystore.path: certs/transport.p12
  truststore.path: certs/transport.p12
#----------------------- END SECURITY AUTO CONFIGURATION -------------------------
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;Docker安装&lt;/h4&gt;
&lt;p&gt;挂载目录需要先把为目录设置权限,本地开发一般使用777就可以&lt;/p&gt;
&lt;p&gt;一般&quot;绑定挂载&quot;第一次挂载都需要先要准备好&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;/elasticsearch目录&amp;lt;/mark&amp;gt;下的文件(建议使用挂载)&lt;/p&gt;
&lt;p&gt;可以先运行一次没有挂载任何卷的es&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 设置权限
chmod -R 777 /elasticsearch


# 运行一次没有挂载卷的es
docker run -d --name elasticsearch elasticsearch:8.12.2


# 从这个运行中的容器复制文件到宿主机 容器名称:容器路径 宿主机路径
docker cp elasticsearch:/usr/share/elasticsearch/config /elasticsearch/config
docker cp elasticsearch:/usr/share/elasticsearch/data /elasticsearch/data
docker cp elasticsearch:/usr/share/elasticsearch/plugins /elasticsearch/plugins


# 停止并关闭
docker stop elasticsearch
docker rm elasticsearch


# -p 宿主机端口:容器端口
# -e ES_JAVA_OPTS=&quot;-Xms128m -Xmx256m&quot; 设置ES服务的占用内存大小(开发时用作限制)
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e &quot;discovery.type=single-node&quot; \
-e ES_JAVA_OPTS=&quot;-Xms128m -Xmx256m&quot; \
-d elasticsearch:8.12.2



# 挂载目录方式 -v 宿主机路径:容器路径
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e &quot;discovery.type=single-node&quot; \
-e ES_JAVA_OPTS=&quot;-Xms128m -Xmx256m&quot; \
-v /elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /elasticsearch/data:/usr/share/elasticsearch/data \
-v /elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:8.12.2
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;kibana&lt;/h3&gt;
&lt;h4&gt;Docker安装&lt;/h4&gt;
&lt;p&gt;安装成功后访问http://127.0.0.1:5601即可&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# ip是你本地的ip kibana版本需要和es一样
docker run -d --name kibana -e ELASTICSEARCH_HOSTS=&quot;http://192.168.50.75:9200&quot; -p 5601:5601 kibana:8.12.2
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;IK中文分词&lt;/h2&gt;
&lt;h3&gt;安装&lt;/h3&gt;
&lt;p&gt;下载:ik-Github&lt;/p&gt;
&lt;p&gt;解压重命名为ik,放入到容器内路径/usr/share/elasticsearch/plugins&lt;/p&gt;
&lt;p&gt;如果使用了挂载卷,放入/elasticsearch/plugins&lt;/p&gt;
&lt;p&gt;更改权限&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 更改容器内文件夹权限.
docker exec -u root -it elasticsearch /bin/bash
cd /usr/share/elasticsearch/plugins
chmod 777 -R ik


# 如果使用挂载只需要把宿主机的ik文件夹权限修改
chmod -R 777 /elasticsearch
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;重启即可使用&lt;/p&gt;
&lt;h3&gt;中文分词词库扩展&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 进入ik配置目录
cd /usr/share/elasticsearch/plugins/ik/config


# 这个是配置扩展的文件
IKAnalyzer.cfg.xml


# 创建我的词库配置文件夹
mkdir custom
cd custom
 

# 创建停用词配置
vim extra_stopwords.dic

# 写入想要禁用的词
的
是


# 创建我的词库
vim extra_dict.dic


# 写入需要增加的词
中国科技大学
中华牙膏
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;更改IKAnalyzer.cfg.xml&lt;/p&gt;
&lt;p&gt;加入相对路径 custom/extra_dict.dic和custom/extra_stopwords.dic&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!DOCTYPE properties SYSTEM &quot;http://java.sun.com/dtd/properties.dtd&quot;&amp;gt;
&amp;lt;properties&amp;gt;
        &amp;lt;comment&amp;gt;IK Analyzer 扩展配置&amp;lt;/comment&amp;gt;
        &amp;lt;!--用户可以在这里配置自己的扩展字典 --&amp;gt;
        &amp;lt;entry key=&quot;ext_dict&quot;&amp;gt;custom/extra_dict.dic&amp;lt;/entry&amp;gt;
        &amp;lt;!--用户可以在这里配置自己的扩展停止词字典--&amp;gt;
        &amp;lt;entry key=&quot;ext_stopwords&quot;&amp;gt;custom/extra_stopwords.dic&amp;lt;/entry&amp;gt;
        &amp;lt;!--用户可以在这里配置远程扩展字典 --&amp;gt;
        &amp;lt;!-- &amp;lt;entry key=&quot;remote_ext_dict&quot;&amp;gt;words_location&amp;lt;/entry&amp;gt; --&amp;gt;
        &amp;lt;!--用户可以在这里配置远程扩展停止词字典--&amp;gt;
        &amp;lt;!-- &amp;lt;entry key=&quot;remote_ext_stopwords&quot;&amp;gt;words_location&amp;lt;/entry&amp;gt; --&amp;gt;
&amp;lt;/properties&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>MacOS Cpolar 使用</title><link>https://rjomg-blog.pages.dev/posts/wp-3344/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3344/</guid><pubDate>Thu, 29 Feb 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标:如何使用Cpolar&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;启动和停止&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;# 启动
sudo launchctl bootstrap system /Library/LaunchDaemons/cpolar.plist

# 停止
sudo launchctl bootout system /Library/LaunchDaemons/cpolar.plist
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis二分查找和跳跃链表（有序集合）</title><link>https://rjomg-blog.pages.dev/posts/wp-2749/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2749/</guid><pubDate>Mon, 23 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：redis有序集合的原理，为什么选择跳跃链表&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;二分查找&lt;/h2&gt;
&lt;h3&gt;简单定义&lt;/h3&gt;
&lt;p&gt;在一个单调有序的集合中查找元素&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每次将集合分为左右两部分&lt;/li&gt;
&lt;li&gt;判断解在哪个部分中并调整集合上下界&lt;/li&gt;
&lt;li&gt;重复直到找到目标元素&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;时间复杂度&lt;/h3&gt;
&lt;p&gt;O(logn)优于直接顺序查找O(n)&lt;/p&gt;
&lt;h3&gt;例子&lt;/h3&gt;
&lt;p&gt;查找值为22的记录过程：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;mid = (low+high) / 2&lt;/li&gt;
&lt;li&gt;mid&amp;lt;x: low = mid + 1&lt;/li&gt;
&lt;li&gt;mid&amp;gt;x: high = mid -1&lt;/li&gt;
&lt;/ul&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;td&gt;18&lt;/td&gt;
&lt;td&gt;22&lt;/td&gt;
&lt;td&gt;28&lt;/td&gt;
&lt;td&gt;34&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;td&gt;65&lt;/td&gt;
&lt;td&gt;70&lt;/td&gt;
&lt;td&gt;80&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;low=0&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;min=4&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;high=9&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;mid = 4 （mid = (low+high) / 2）&lt;/p&gt;
&lt;p&gt;因为key 4 的值是28，28比22大，即 high = mid -1，新的high = 3&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;td&gt;18&lt;/td&gt;
&lt;td&gt;22&lt;/td&gt;
&lt;td&gt;28&lt;/td&gt;
&lt;td&gt;34&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;td&gt;65&lt;/td&gt;
&lt;td&gt;70&lt;/td&gt;
&lt;td&gt;80&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;low=0&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;high=3&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;high=3 值是22 已经找到返回结果3&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;跳跃链表&lt;/h2&gt;
&lt;h3&gt;定义&lt;/h3&gt;
&lt;p&gt;跳表由多条链表L0 ……LN以及下行指针构成&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;第三级索引&lt;/td&gt;
&lt;td&gt;-&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;第二级索引&lt;/td&gt;
&lt;td&gt;-&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;44&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;第一级索引&lt;/td&gt;
&lt;td&gt;-&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;44&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;原始链表&lt;/td&gt;
&lt;td&gt;-&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;td&gt;31&lt;/td&gt;
&lt;td&gt;44&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;td&gt;64&lt;/td&gt;
&lt;td&gt;78&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;每条链表包含元素检索值单调递增，包含两个特殊节点 -∞(起始节点)和+∞(终止节点)&lt;/p&gt;
&lt;p&gt;L0包含所有元素，对任意的i&amp;gt;0，Li+1是Li的子集，且Li+1中的每一个节点，有一个下行指针，指向Li中与之有相同索引值的节点&lt;/p&gt;
&lt;p&gt;在跳跃表中查找一个元素x&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;从最上层的链(Ln)的开头开始&lt;/li&gt;
&lt;li&gt;假设当前位置为p,它向右指向的节点为q(p与q不一定相邻),且q的值为y。将y与x作比较
&lt;ol&gt;
&lt;li&gt;x = y 输出查询成功&lt;/li&gt;
&lt;li&gt;x &amp;gt; y 从p向右移动到q的位置&lt;/li&gt;
&lt;li&gt;x &amp;lt; y 从p向下移动一格&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;如果当前位置在最底层的链中(L0),且还要往下移动的话,则输出查询失败&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;例子&lt;/h3&gt;
&lt;p&gt;假设要寻找78这个值&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;第三级索引&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;-♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;↓&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;第二级索引&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;-♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;44&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;↓&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;第一级索引&lt;/td&gt;
&lt;td&gt;-&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;44&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;56&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;↓&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;原始链表&lt;/td&gt;
&lt;td&gt;-&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;td&gt;31&lt;/td&gt;
&lt;td&gt;44&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;56&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;64&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;78&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;+&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
</content:encoded></item><item><title>Go编码规范</title><link>https://rjomg-blog.pages.dev/posts/wp-3232/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3232/</guid><pubDate>Fri, 20 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;「&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Go语言的编程代码规范&amp;lt;/mark&amp;gt;」&lt;/p&gt;
&lt;h2&gt;为什么需要代码规范&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;代码规范不是强制的，也就是你不遵循代码规范写出来的代码运行也是完全没有问题的&lt;/li&gt;
&lt;li&gt;代码规范目的是方便团队形成一个统一的代码风格，提高代码的可读性，规范性和统一性。本规范将从命名规范，注释规范，代码风格和 Go 语言提供的常用的工具这几个方面做一个说明。&lt;/li&gt;
&lt;li&gt;规范并不是唯一的，也就是说理论上每个公司都可以制定自己的规范，不过一般来说整体上规范差异不会很大。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;代码规范细则&lt;/h2&gt;
&lt;h3&gt;1.命名规范&lt;/h3&gt;
&lt;p&gt;命名是代码规范中很重要的一部分，统一的命名规则有利于提高的代码的可读性，好的命名仅仅通过命名就可以获取到足够多的信息。&lt;/p&gt;
&lt;p&gt;a. 当命名（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就&lt;strong&gt;可以被外部包的代码所使用&lt;/strong&gt;（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;b. 命名如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的&lt;/strong&gt;（像面向对象语言中的 private ）&lt;/p&gt;
&lt;h4&gt;1.1包名：package&lt;/h4&gt;
&lt;p&gt;保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，尽量和标准库不要冲突。包名应该为&lt;strong&gt;小写&lt;/strong&gt;单词，不要使用下划线或者混合大小写。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package model
package main
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;1.2 文件名&lt;/h4&gt;
&lt;p&gt;尽量采取有意义的文件名，简短，有意义，应该为&lt;strong&gt;小写&lt;/strong&gt;单词，使用&lt;strong&gt;下划线&lt;/strong&gt;分隔各个单词。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
user_model.go
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;1.3 结构体命名&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;采用驼峰命名法，首字母根据访问控制大写或者小写&lt;/li&gt;
&lt;li&gt;struct 申明和初始化格式采用多行，例如下面：&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// 多行申明
type User struct{
    Username  string
    Email     string
}
 
// 多行初始化
u := User{
    Username: &quot;bobby&quot;,
    Email:    &quot;bobby@imooc.com&quot;,
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;1.4 接口命名&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;命名规则基本和上面的结构体类型&lt;/li&gt;
&lt;li&gt;单个函数的结构名以 “er” 作为后缀，例如 Reader , Writer 。&lt;/li&gt;
&lt;li&gt;或以I开头，例如 IRead&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; // 示例
type Reader interface {
        Read(p []byte) (n int, err error)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;1.5 变量命名&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;和结构体类似，变量名称一般遵循驼峰法，首字母根据访问控制原则大写或者小写，但遇到特有名词时，需要遵循以下规则：&lt;/li&gt;
&lt;li&gt;如果变量为私有，且特有名词为首个单词，则使用小写，如 apiClient&lt;/li&gt;
&lt;li&gt;其它情况都应当使用该名词原有的写法，如 APIClient、repoID、UserID&lt;/li&gt;
&lt;li&gt;错误示例：UrlArray，应该写成 urlArray 或者 URLArray&lt;/li&gt;
&lt;li&gt;若变量类型为 bool 类型，则名称应以 Has, Is, Can 或 Allow 开头&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; // 示例
var isExist bool
var hasConflict bool
var canManage bool
var allowGitHook bool
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;1.6 常量命名&lt;/h4&gt;
&lt;p&gt;常量均需使用全部大写字母组成，并使用下划线分词&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
const APP_VER = &quot;1.0&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果是枚举类型的常量，需要先创建相应类型：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
type Scheme string

const (
    HTTP  Scheme = &quot;http&quot;
    HTTPS Scheme = &quot;https&quot;
)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2. 注释&lt;/h3&gt;
&lt;p&gt;Go提供C风格的/* */块注释和C ++风格的//行注释。行注释是常态；块注释主要显示为包注释，但在表达式中很有用或禁用大量代码。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释&lt;/li&gt;
&lt;li&gt;多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;go 语言自带的 godoc 工具可以根据注释生成文档，生成可以自动生成对应的网站（&lt;a href=&quot;https://link.zhihu.com/?target=http%3A//golang.org&quot;&gt;golang.org&lt;/a&gt; 就是使用 godoc 工具直接生成的），注释的质量决定了生成的文档的质量。每个包都应该有一个包注释，在package子句之前有一个块注释。对于多文件包，包注释只需要存在于一个文件中，任何一个都可以。包评论应该介绍包，并提供与整个包相关的信息。它将首先出现在godoc页面上，并应设置下面的详细文档。&lt;/p&gt;
&lt;h4&gt;2.1 包注释&lt;/h4&gt;
&lt;p&gt;每个包都应该有一个包注释，一个位于package子句之前的块注释或行注释。包如果有多个go文件，只需要出现在一个go文件中（一般是和包同名的文件）即可。 包注释应该包含下面基本信息(请严格按照这个顺序，简介，创建人，创建时间）：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;包的基本简介（包名，简介）&lt;/li&gt;
&lt;li&gt;创建者，格式： 创建人： rtx 名&lt;/li&gt;
&lt;li&gt;创建时间，格式：创建时间： yyyyMMdd&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// util 包， 该包包含了项目共用的一些常量，封装了项目中一些共用函数。
// 创建人： hanru
// 创建时间： 20190419
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.2 结构（接口）注释&lt;/h4&gt;
&lt;p&gt;每个自定义的结构体或者接口都应该有注释说明，该注释对结构进行简要介绍，放在结构体定义的前一行，格式为： 结构体名， 结构体说明。同时结构体内的每个成员变量都要有说明，该说明放在成员变量的后面（注意对齐），实例如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// User ， 用户对象，定义了用户的基础信息
type User struct{
    Username  string // 用户名
    Email     string // 邮箱
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.3 函数（方法）注释&lt;/h4&gt;
&lt;p&gt;每个函数，或者方法（结构体或者接口下的函数称为方法）都应该有注释说明，函数的注释应该包括三个方面（严格按照此顺序撰写）：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;简要说明，格式说明：以函数名开头，“，”分隔说明部分&lt;/li&gt;
&lt;li&gt;参数列表：每行一个参数，参数名开头，“，”分隔说明部分&lt;/li&gt;
&lt;li&gt;返回值： 每行一个返回值&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// NewtAttrModel ， 属性数据层操作类的工厂方法
// 参数：
//      ctx ： 上下文信息
// 返回值：
//      属性操作类指针
func NewAttrModel(ctx *common.Context) *AttrModel {
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.4 代码逻辑注释&lt;/h4&gt;
&lt;p&gt;对于一些关键位置的代码逻辑，或者局部较为复杂的逻辑，需要有相应的逻辑说明，方便其他开发者阅读该段代码，实例如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// 从 Redis 中批量读取属性，对于没有读取到的 id ， 记录到一个数组里面，准备从 DB 中读取
xxxxx
xxxxxxx
xxxxxxx
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.5 注释风格&lt;/h4&gt;
&lt;p&gt;统一使用中文注释，对于中英文字符之间严格使用空格分隔， 这个不仅仅是中文和英文之间，英文和中文标点之间也都要使用空格分隔，例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// 从 Redis 中批量读取属性，对于没有读取到的 id ， 记录到一个数组里面，准备从 DB 中读取
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;上面 Redis 、 id 、 DB 和其他中文字符之间都是用了空格分隔。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;建议全部使用单行注释&lt;/li&gt;
&lt;li&gt;和代码的规范一样，单行注释不要过长，禁止超过 120 字符。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3. &lt;strong&gt;import 规范&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;import在多行的情况下，goimports会自动帮你格式化，但是我们这里还是规范一下import的一些规范，如果你在一个文件里面引入了一个package，还是建议采用如下格式：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
import (
    &quot;fmt&quot;
)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是如果是引入本项目中的其他包，最好使用相对路径。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// 这是不好的导入
import “../net”

// 这是正确的做法
import “github.com/repo/proj/src/net”
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4. 错误处理&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;错误处理的原则就是不能丢弃任何有返回err的调用，不要使用 _ 丢弃，必须全部处理。接收到错误，要么返回err，或者使用log记录下来&lt;/li&gt;
&lt;li&gt;尽早return：一旦有错误发生，马上返回&lt;/li&gt;
&lt;li&gt;尽量不要使用panic，除非你知道你在做什么&lt;/li&gt;
&lt;li&gt;错误描述如果是英文必须为小写，不需要标点结尾&lt;/li&gt;
&lt;li&gt;采用独立的错误流进行处理&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; // 示例
// 错误写法
if err != nil {
    // error handling
} else {
    // normal code
}

// 正确写法
if err != nil {
    // error handling
    return // or continue, etc.
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Go的指针</title><link>https://rjomg-blog.pages.dev/posts/wp-3181/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3181/</guid><pubDate>Tue, 17 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;「&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是指针？&amp;lt;/mark&amp;gt;」&lt;/p&gt;
&lt;h2&gt;指针&lt;/h2&gt;
&lt;p&gt;指针是一个&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;变量&amp;lt;/mark&amp;gt;，其&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;存储的是另一个变量的内存地址&amp;lt;/mark&amp;gt;。通过指针，你可以在函数或方法中修改传入的参数的值，或者操作大型数据结构时提高效率。&lt;/p&gt;
&lt;p&gt;类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
var var_name *var-type
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;初始化&lt;/h2&gt;
&lt;p&gt;初始化的三种方式&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

type Person struct {
    Name string
    Age  int
}

func main (){
        // 指针初始化的三种方法
    // 第一种
    p1 := &amp;amp;Person{}
    fmt.Println(p1)

    // 第二种
    var emptyPerson Person
    p2 := &amp;amp;emptyPerson
    fmt.Println(p2)

    // 第三种
    p3 := new(Person)
    fmt.Println(p3)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;使用&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;定义指针变量。&lt;/li&gt;
&lt;li&gt;为指针变量赋值。&lt;/li&gt;
&lt;li&gt;访问指针变量中指向地址的值。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &amp;amp;a  /* 指针变量的存储地址 */

   fmt.Printf(&quot;a 变量的地址是: %x\n&quot;, &amp;amp;a  )

   /* 指针变量的存储地址 */
   fmt.Printf(&quot;ip 变量储存的指针地址: %x\n&quot;, ip )

   /* 使用指针访问值 */
   fmt.Printf(&quot;*ip 变量的值: %d\n&quot;, *ip )
}
// a 变量的地址是: 20818a220
// ip 变量储存的指针地址: 20818a220
// *ip 变量的值: 20
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;空指针&lt;/h2&gt;
&lt;p&gt;当一个指针被定义后没有分配到任何变量时，它的值为 nil。&lt;/p&gt;
&lt;p&gt;nil 指针也称为空指针。&lt;/p&gt;
&lt;p&gt;nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。&lt;/p&gt;
&lt;p&gt;一个指针变量通常缩写为 ptr。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func main() {
   var  ptr *int

   fmt.Printf(&quot;ptr 的值为 : %x\n&quot;, ptr  )
}
// ptr 的值为 : 0

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Go的结构体</title><link>https://rjomg-blog.pages.dev/posts/wp-3136/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3136/</guid><pubDate>Mon, 16 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是结构体&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;结构体&lt;/h2&gt;
&lt;p&gt;Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。&lt;/p&gt;
&lt;p&gt;结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。&lt;/p&gt;
&lt;h3&gt;结构体的简单定义和使用&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import (
    &quot;encoding/json&quot;
    &quot;fmt&quot;
)

// Person 结构体的简单定义
type Person struct {
    name    string
    age     int
    address string
    height  float32
}

// 结构体
func main(){
        // 结构体初始化和赋值
    // 方式1
    p1 := Person{&quot;rjomg1&quot;, 18, &quot;blog&quot;, 1.80}
    fmt.Println(p1)

    // 方式2
    p2 := Person{
        name:    &quot;rjomg2&quot;,
        age:     18,
        address: &quot;blog&quot;,
    }
    fmt.Println(p2)

    // 方法3
    var p3 []Person
    p3 = append(p3, p1)
    fmt.Println(p3)

    // 方法4
    var p4 []Person
    p4 = append(p4, Person{
        name: &quot;rjomg3&quot;,
        age:  18,
    })
    fmt.Println(p4)

    // 方法5
    var p5 []Person
    p5 = []Person{
        {&quot;rjomg5&quot;, 18, &quot;blog&quot;, 1.80},
        {
            age: 20,
        },
    }
    fmt.Println(p5)

    // 方法6
    var p6 Person
    p6.age = 20
    fmt.Println(p6)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;结构体嵌套&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import (
    &quot;encoding/json&quot;
    &quot;fmt&quot;
)

// Person 结构体的简单定义
type Person struct {
    name    string
    age     int
    address string
    height  float32
}

type Person2 struct {
    name string
    age  int
}

type Person3 struct {
    Name string
    Age  int
}

// Student 结构体的两种嵌套方式
type Student struct {
    // 第一种嵌套方式
    p Person

    // 第二种匿名嵌套
    Person2

    score float32
    name  string
}

// 结构体
func main(){
        // 嵌套方式
    fmt.Println(&quot;-------- p7 start ---------&quot;)
    p7 := Student{
        p: Person{name: &quot;func_rjomg1&quot;, age: 18},
        Person2: Person2{
            name: &quot;func_rjomg2&quot;,
            age:  18,
        },
        name:  &quot;func_rjomg3&quot;,
        score: 100,
    }
    p7.name = &quot;p7_rjomg&quot; // 修改的是 p7.name
    p7.age = 21          // 修改的是匿名函数下的 p7.Person2.age
    fmt.Println(p7)
    fmt.Println(&quot;-------- p7 end ---------&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;结构体定义方法&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import (
    &quot;encoding/json&quot;
    &quot;fmt&quot;
)

// Person 结构体的简单定义
type Person struct {
    name    string
    age     int
    address string
    height  float32
}

type Person2 struct {
    name string
    age  int
}

type Person3 struct {
    Name string
    Age  int
}

// Student 结构体的两种嵌套方式
type Student struct {
    // 第一种嵌套方式
    p Person

    // 第二种匿名嵌套
    Person2

    score float32
    name  string
}

// 值传递
func (p Person) print() {
    p.age = 19
    fmt.Printf(&quot;name:%s, age:%d\r\n&quot;, p.name, p.age)
}

// 指针传递
func (p *Person) print2() {
    p.age = 19
    fmt.Printf(&quot;name:%s, age:%d\r\n&quot;, p.name, p.age)
}

// 结构体
func main(){
        // 结构体定义方法
    p11 := Person{
        name: &quot;func_rjomg&quot;,
        age:  18,
    }
    p11.print()          // 结果：name:func_rjomg, age:19
    fmt.Println(p11.age) // 18
    p11.print2()         // name:func_rjomg, age:19
    fmt.Println(p11.age) // 19 通过指针传递

    s := Student{
        p: Person{name: &quot;func_rjomg1&quot;, age: 18},
        Person2: Person2{
            name: &quot;name&quot;,
            age:  18,
        },
        name:  &quot;func_rjomg1&quot;,
        score: 100,
    }
    fmt.Println(s)
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis秒杀</title><link>https://rjomg-blog.pages.dev/posts/wp-3139/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3139/</guid><pubDate>Sun, 15 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：怎么实现使用redis秒杀&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;秒杀可使用的思路&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;客户端层面考虑，限流，限制单个客户的抢购频率。&lt;/li&gt;
&lt;li&gt;服务端层面考虑，加强校验，识别该用户是否真实用户，防止恶意刷单。&lt;/li&gt;
&lt;li&gt;应用层面考虑的话，可以使用漏桶算法，和令牌桶算法&lt;/li&gt;
&lt;li&gt;尽量把整个秒杀页面做成静态页面，尽可能把动态的数据缓存到redis里面&lt;/li&gt;
&lt;li&gt;异步，抢购成功马上返回处理成功，剩下的后续逻辑由mq（队列）去处理，缓解服务器的峰值压力&lt;/li&gt;
&lt;li&gt;分流，增加服务器数量，上集群，分散请求压力&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;秒杀&lt;/h2&gt;
&lt;h3&gt;Redis限制一人一单&lt;/h3&gt;
&lt;p&gt;使用分布式锁，锁是一种保护机制，在多线程的情况下，保证数据操作的一致性&lt;/p&gt;
&lt;h4&gt;锁的产生&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;不跨线程共享变量，线程共享的变量改为地方法局部级变量&lt;/li&gt;
&lt;li&gt;使状态变量为不可变的，使用final修饰（将变量变为常量）&lt;/li&gt;
&lt;li&gt;在任何访问状态变量的时候使用同步，使用synchronized修饰方法，或使用同步代码块。&lt;/li&gt;
&lt;li&gt;每个共享的可变变量都需要由唯一一个确定的锁保护。使用Lock锁。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;分布式锁实现方式有三种&lt;/h4&gt;
&lt;p&gt;基于数据库；基于Zookeeper调度中心；基于Redis&lt;/p&gt;
&lt;h4&gt;分布式锁条件&lt;/h4&gt;
&lt;p&gt;实现分布式锁要满足3点：多进程可见，互斥，可重入。&lt;/p&gt;
</content:encoded></item><item><title>Go的函数和defer、panic、recover关键字</title><link>https://rjomg-blog.pages.dev/posts/wp-3074/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3074/</guid><pubDate>Thu, 12 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Go的函数简单应用和defer、panic、recover关键字&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;函数的用法&lt;/h2&gt;
&lt;p&gt;函数是基本的代码块，用于执行一个任务。&lt;/p&gt;
&lt;p&gt;Go 语言最少有个 main() 函数。&lt;/p&gt;
&lt;p&gt;你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。&lt;/p&gt;
&lt;p&gt;函数声明告诉了编译器函数的名称，返回类型，和参数。&lt;/p&gt;
&lt;p&gt;Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。&lt;/p&gt;
&lt;h3&gt;简单的函数应用&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

// 函数参数传递的时候，值传递，引用传递，go语言中全部都是值传递
func add(a, b int, c float32) (sum int, err error) {
    sum = a + b
    return
}

// 传递n个参数
func addItem(items ...int) (sum int, err error) {
    // 方法1
    for i := 0; i &amp;lt; len(items); i++ {
        sum += items[i]
    }

    // 方法2
    sum = 0
    for _, value := range items {
        sum += value
    }
    return sum, err
}

func main() {
    // go 函数支持普通函数、匿名函数、闭包
    /*
        go中函数式”一等公民“
            1.函数本身可以当做变量
            2.匿名函数 闭包
            3.函数可以满足接口
    */
    sum, err := add(1, 2, 2.555)
    fmt.Println(sum)
    fmt.Println(err)

    sum2, _ := addItem(1, 2, 3, 4)
    fmt.Println(sum2)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;匿名函数&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func callback(x, x2 int, f func(int, int)) {
    f(x, x2)
}

func main() {
    // 匿名函数
    localFunc := func(x int, x2 int) {
        fmt.Printf(&quot;total is: %d\r\n\n&quot;, x+x2)
    }
    callback(1, 2, localFunc)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;闭包&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func auto() func() int {
    local := 0
    return func() int {
        local++
        return local
    }
}

func main() {
    // 闭包
    closureFunc := auto()
    sum3 := 0
    for i := 0; i &amp;lt; 5; i++ {
        sum3 = closureFunc()
    }
    fmt.Println(sum3)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;Error&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import (
    &quot;errors&quot;
    &quot;fmt&quot;
)

func A() (int, error) {
    return 0, errors.New(&quot;this is an error&quot;)
}

func main() {
    if _, err := A(); err != nil {
        fmt.Println(err)
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;关键字&lt;/h2&gt;
&lt;h3&gt;defer&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;defer&amp;lt;/mark&amp;gt; 关键字用于确保函数调用在程序执行结束后执行。无论函数因为什么原因结束，都会执行 defer 语句，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;defer语句的执行顺序是后进先出（LIFO）的。也就是说，最先声明的 defer 语句最后执行，最后声明的 defer 语句最先执行&amp;lt;/mark&amp;gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func main() {
    fmt.Println(&quot;start&quot;)
    
    defer fmt.Println(&quot;defer 1&quot;)
    defer fmt.Println(&quot;defer 2&quot;)
    defer fmt.Println(&quot;defer 3&quot;)
    
    fmt.Println(&quot;end&quot;)
// 结果：
// start
//end
//defer 3
//defer 2
//defer 1
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;panic&lt;/h3&gt;
&lt;p&gt;是 Go 语言的一个内建函数，它可以用来捕获到 panic 引发的异常，从而使程序从异常中恢复过来，继续执行。recover 只有在 defer 语句中才能捕获到 panic 引发的异常。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func main() {
    defer fmt.Println(&quot;这句话会被打印出来&quot;)
    fmt.Println(&quot;开始&quot;)
    panic(&quot;发生了一些不好的事情&quot;)
    fmt.Println(&quot;结束&quot;)  // 这句话不会被打印出来
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;recover&lt;/h3&gt;
&lt;p&gt;recover 是一个内建的函数，可以用于重新获得 panicking goroutine 的控制并恢复正常执行。recover 只有在延迟函数（defer）中才有效。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 示例
package main

import &quot;fmt&quot;

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println(&quot;Recovered from&quot;, r)
        }
    }()
    fmt.Println(&quot;开始&quot;)
    panic(&quot;发生了一些不好的事情&quot;)
    fmt.Println(&quot;结束&quot;)  // 这句话不会被打印出来
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Go的Map</title><link>https://rjomg-blog.pages.dev/posts/wp-3031/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3031/</guid><pubDate>Wed, 11 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是map？&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是Map&lt;/h2&gt;
&lt;p&gt;Map 是一种无序的键值对的集合。&lt;/p&gt;
&lt;p&gt;Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。&lt;/p&gt;
&lt;p&gt;Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，遍历 Map 时返回的键值对的顺序是不确定的。&lt;/p&gt;
&lt;p&gt;在获取 Map 的值时，如果键不存在，返回该类型的零值，例如 int 类型的零值是 0，string 类型的零值是 &quot;&quot;。&lt;/p&gt;
&lt;p&gt;Map 是引用类型，如果将一个 Map 传递给一个函数或赋值给另一个变量，它们都指向同一个底层数据结构，因此对 Map 的修改会影响到所有引用它的变量。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;！！！单纯的Map不是线程安全的&amp;lt;/mark&amp;gt;，如果需要使用线程安全的使用（sync.map()方法）&lt;/p&gt;
&lt;h3&gt;示例1&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import &quot;fmt&quot;

func main() {
    // map是一个key（索引）和value（值）的无序集合，主要是查询方便o(1)
    // map的2种初始化方式
    // 1.花括号初始化
    var courseMap = map[string]string{
        &quot;go&quot;:   &quot;go工程师&quot;,
        &quot;grpc&quot;: &quot;grpc入门&quot;,
        &quot;gin&quot;:  &quot;gin深入理解&quot;,
    }

    // 取值
    fmt.Println(courseMap[&quot;grpc&quot;]) // grpc入门

    // 入值
    courseMap[&quot;mysql&quot;] = &quot;mysql原理&quot;
    fmt.Println(courseMap) // map[gin:gin深入理解 go:go工程师 grpc:grpc入门 mysql:mysql原理]

    // 错误展示（当设置了一个Map但是没有初始化,系统就会报错）
    //var courseMap2 map[string]string
    //courseMap2[&quot;mysql&quot;] = &quot;mysql原理&quot;
    //fmt.Println(courseMap2) // 输出结果：panic: assignment to entry in nil map

    // 2.make方法初始化(更为常用)
    var courseMap3 = make(map[string]string, 10)
    courseMap3[&quot;study&quot;] = &quot;学习Go语言&quot;
    fmt.Println(courseMap3) // map[study:学习Go语言]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;Map循环&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import &quot;fmt&quot;

func main() {
        var courseMap = map[string]string{
        &quot;go&quot;:   &quot;go工程师&quot;,
        &quot;grpc&quot;: &quot;grpc入门&quot;,
        &quot;gin&quot;:  &quot;gin深入理解&quot;,
    }

        // map 循环是无序的
    for key, value := range courseMap {
        fmt.Println(key, value)
    }
    fmt.Println(&quot;-----------&quot;)

    for _, value := range courseMap {
        fmt.Println(value)
    }
    fmt.Println(&quot;-----------&quot;)

    for key := range courseMap {
        fmt.Println(key, courseMap[key])
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;Map判断元素是否存在&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import &quot;fmt&quot;

func main() {
        var courseMap = map[string]string{
        &quot;go&quot;:   &quot;go工程师&quot;,
        &quot;grpc&quot;: &quot;grpc入门&quot;,
        &quot;gin&quot;:  &quot;gin深入理解&quot;,
    }

        // 判断一个map里面是否存在该参数
    courseMap[&quot;java&quot;] = &quot;&quot;
    d, ok := courseMap[&quot;java&quot;]
    if !ok {
        fmt.Println(&quot;not ok&quot;)
    } else {
        fmt.Println(&quot;is set&quot;, d)
    }

    // 写法2
    if d, ok := courseMap[&quot;java&quot;]; !ok {
        fmt.Println(&quot;not ok&quot;)
    } else {
        fmt.Println(&quot;is set&quot;, d)
    }
// 运行结果：is set
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;Map删除&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import &quot;fmt&quot;

func main() {
        var courseMap = map[string]string{
        &quot;go&quot;:   &quot;go工程师&quot;,
        &quot;grpc&quot;: &quot;grpc入门&quot;,
        &quot;gin&quot;:  &quot;gin深入理解&quot;,
    }
    delete(courseMap, &quot;grpc&quot;)
    delete(courseMap, &quot;aaa&quot;) // 删除一个不存在的键值，不会报错
    fmt.Println(courseMap)   // 运行结果：map[gin:gin深入理解 go:go工程师 java: mysql:mysql原理] 
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Go的List</title><link>https://rjomg-blog.pages.dev/posts/wp-3057/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-3057/</guid><pubDate>Wed, 11 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是List链表&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是List双向链表&lt;/h2&gt;
&lt;p&gt;Go语言的标准库中包含一个&lt;code&gt;container/list&lt;/code&gt;包，这个包实现了双向链表。你可以使用这个包来创建和操作链表。&lt;/p&gt;
&lt;p&gt;list查询效率较慢，但是不需要扩容&lt;/p&gt;
&lt;h3&gt;简单使用&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main
import (
    &quot;container/list&quot;
    &quot;fmt&quot;
)
func main() {
    var myList list.List
    fmt.Println(myList) // 返回结果：{{   } 0}
    myList.PushBack(&quot;go&quot;)
    myList.PushBack(&quot;grpc&quot;)
    myList.PushBack(&quot;mysql&quot;)
    fmt.Println(myList) // 返回结果：{{0x140000741e0 0x14000074240  } 3}
    // 如果打印实际的值，需要遍历打印
    // 正序遍历
    for i := myList.Front(); i != nil; i = i.Next() {
        fmt.Println(i.Value)
    }
    // 返回结果
    // go
    // grpc
    // mysql
    fmt.Println(&quot;---------&quot;)
    // 反向遍历
    for i := myList.Back(); i != nil; i = i.Prev() {
        fmt.Println(i.Value)
    }
    // 返回结果
    // mysql
    // grpc
    // go
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;List中插入一个数据&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main
import (
    &quot;container/list&quot;
    &quot;fmt&quot;
)
func main() {
    var myList list.List
    fmt.Println(myList) // 返回结果：{{   } 0}
    myList.PushBack(&quot;go&quot;)
    myList.PushBack(&quot;grpc&quot;)
    myList.PushBack(&quot;mysql&quot;)
    
        // list中某个地方插入一个新的数据
    i := myList.Front()
    for ; i != nil; i = i.Next() {
        if i.Value.(string) == &quot;grpc&quot; {
            break
        }
    }
    myList.InsertBefore(&quot;gin&quot;, i)
    for i := myList.Front(); i != nil; i = i.Next() {
        fmt.Println(i.Value)
    }
    // 返回结果：
    //go
    //gin
    //grpc
    //mysql
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;&lt;/h3&gt;
</content:encoded></item><item><title>Go的切片(slice)</title><link>https://rjomg-blog.pages.dev/posts/wp-2948/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2948/</guid><pubDate>Tue, 10 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是Golang的切片&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是切片&lt;/h2&gt;
&lt;p&gt;在 Go 语言中，切片（slice）是一种动态数组，可以根据需要动态地增长或缩小。切片底层是一个数组，但与数组不同的是，切片的长度是可以动态改变的。&lt;/p&gt;
&lt;h3&gt;切片初始化&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; // 切片初始化的三种方式
package main

import &quot;fmt&quot;
func main() {
    // 1.make方法
    var makeSlice = make([]string, 3)
    makeSlice := make([]string, 3) // 也可以简写为
    fmt.Println(makeSlice)

    // 2.从数组直接创建
    arr := [5]string{&quot;go&quot;, &quot;gin&quot;, &quot;grpc&quot;, &quot;mysql&quot;, &quot;elasticsearch&quot;}
    arrToSlice := arr[0:len(arr)]
    fmt.Println(arrToSlice)

    // 3.使用string{}
    stringToSlice := []string{&quot;go&quot;, &quot;gin&quot;, &quot;grpc&quot;}
    fmt.Println(stringToSlice)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;Go的切片在函数传递的时候是值传递还是引用传递？&lt;/h3&gt;
&lt;p&gt;严格来讲是值传递，但是效果呈现出来是引用传递(&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;不完全&amp;lt;/mark&amp;gt;)&lt;/p&gt;
&lt;p&gt;我们可以同一个例子得出结论：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;值传递&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import (
    &quot;fmt&quot;
    &quot;strconv&quot;
)

func printSlice(data []string) {
    data[0] = &quot;java&quot; // 方法内修改会影响传入的data

        // 但是方法内的append却不会影响到传入的data
    for i := 0; i &amp;lt; 10; i++ {
        data = append(data, strconv.Itoa(i))
    }
}

func main() {
    courses := []string{&quot;go&quot;, &quot;grpc&quot;, &quot;gin&quot;}
    printSlice(courses) // 执行方法
    fmt.Println(courses) // 结果 [java grpc gin]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;切片的原理&lt;/h2&gt;
&lt;h3&gt;示例1&lt;/h3&gt;
&lt;p&gt;在 Go 中，函数参数传递都是值传递。但对于引用类型，传递的值实际上是指向底层数据结构的指针，因此在函数内部对其进行的修改会影响到原始数据。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import (
    &quot;fmt&quot;
    &quot;strconv&quot;
)

func main() {
    data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    s1 := data[1:6] // s1当前：[2, 3, 4, 5, 6]
    s2 := data[2:7] // s2当前：[3, 4, 5, 6, 7]
    s2[0] = 22 // 修改s2的第0个数据
    fmt.Println(s1) // s1结果：[2 22 4 5 6]
    fmt.Println(s2) // s2的结果： [22 4 5 6 7]
        fmt.Println(data) // data的结果：[1 2 22 4 5 6 7 8 9 10]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;ç&lt;/p&gt;
&lt;h4&gt;示例1图解&lt;/h4&gt;
&lt;p&gt;切片是底层数组的一种引用形式，它们通过指向数组并确定段的起始和终止来确定如何访问数据。&lt;/p&gt;
&lt;p&gt;多个切片可以引用同一个底层数组的不同部分，它们可能会或不会重叠。&lt;/p&gt;
&lt;p&gt;对底层数组的修改将通过所有切片进行反映，这些切片引用了数组的被修改的部分。&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/10/切片1-3.png&quot; class=&quot;wp-image-3028&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h3&gt;示例2&lt;/h3&gt;
&lt;p&gt;在扩容前的s3[0] = 33是会影响到data/s1/s2，但是扩容（扩容：是成倍扩容）后修改的就是一个全新的数据了。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; // 案例
package main

import (
    &quot;fmt&quot;
    &quot;strconv&quot;
)

func main() {
    data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    s1 := data[1:6] // s1当前：[2, 3, 4, 5, 6]
    s2 := data[2:7] // s2当前：[3, 4, 5, 6, 7]
    s2[0] = 22 // 修改s2的第0个数据
    fmt.Println(s1) // s1结果：[2 22 4 5 6]
    fmt.Println(s2) // s2的结果： [22 4 5 6 7]
        fmt.Println(data) // data的结果：[1 2 22 4 5 6 7 8 9 10]

        // 在示例1基础上新增的
        s3 := data[3:8]
    s3[0] = 33
    s3 = append(s3, 1, 2, 3, 4, 5, 6, 7, 8) // append超过cap上限，这个操作是为了造成扩容
    s3[1] = 44
    fmt.Println(s1) // s1:[2 22 33 5 6]
    fmt.Println(s2) // s2:[22 33 5 6 7]
    fmt.Println(s3) // s3:[33 44 6 7 8 1 2 3 4 5 6 7 8]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;示例2图解&lt;/h4&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/10/切片2-1.png&quot; class=&quot;wp-image-3025&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;扩容&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;如果当前的切片容量小于 1024，那么新的容量通常是当前容量的2倍。（即：新容量 = 2倍的当前容量）&lt;/li&gt;
&lt;li&gt;如果当前的切片容量大于等于 1024，新的容量增加为原来容量的 1.25，增加25%（即：新容量 = 当前容量 + 当前容量/4）。&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>Linux常用的信号量</title><link>https://rjomg-blog.pages.dev/posts/wp-2899/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2899/</guid><pubDate>Sun, 01 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Linux常用的信号量&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;linux&lt;/h2&gt;
&lt;p&gt;在 Linux 系统中，信号量（signal）是进程间通信的一种方式。以下是一些常用的信号量：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;SIGCHLD（编号：17）：子进程停止或结束&lt;/li&gt;
&lt;li&gt;SIGQUIT（编号：3）：退出进程（相当于按下 Ctrl+\）&lt;/li&gt;
&lt;li&gt;SIGTERM（编号：15）：请求结束进程，这是默认的 &lt;code&gt;kill&lt;/code&gt; 命令发出的信号&lt;/li&gt;
&lt;li&gt;SIGKILL（编号：9）：结束进程（这个信号不能被阻止、处理或忽略）&lt;/li&gt;
&lt;li&gt;SIGHUP（编号：1）：终端挂起或控制进程终止&lt;/li&gt;
&lt;li&gt;SIGUSR1（编号：10）：用户自定义信号1，常用于用户自定义用途&lt;/li&gt;
&lt;li&gt;SIGUSR2（编号：12）：用户自定义信号2，常用于用户自定义用途&lt;/li&gt;
&lt;li&gt;SIGWINCH（编号：28）：这个信号在 Linux 系统中表示窗口大小改变&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;示例：kill -s SIGTERM $pid&lt;/p&gt;
&lt;p&gt;这些信号量可以通过 &lt;code&gt;kill&lt;/code&gt; 命令发送，也可以在程序中通过系统调用发送。进程可以选择忽略某些信号，或者定义信号处理函数来处理某些信号。&lt;/p&gt;
</content:encoded></item><item><title>Nginx的Master/Worker进程</title><link>https://rjomg-blog.pages.dev/posts/wp-2903/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2903/</guid><pubDate>Sun, 01 Oct 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Nginx的Master进程和Worker进程&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;Nginx 使用多进程架构来处理请求，这些进程包括一个 master 进程（主进程）和多个 worker 进程（工作进程）。&lt;/p&gt;
&lt;h2&gt;Master进程（主进程）&lt;/h2&gt;
&lt;p&gt;主进程主要负责管理 worker 进程，包括创建、监控和维护这些进程。主进程还负责读取和验证 Nginx 配置文件、处理信号等。当收到重载配置、平滑升级、关闭等信号时，主进程会采取相应的行动。主进程不参与实际的请求处理，它的主要任务是确保 worker 进程能够正常运行。&lt;/p&gt;
&lt;p&gt;Master进程&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;监控Worker进程
&lt;ul&gt;
&lt;li&gt;当Worker进程挂掉，会发送一个信号量SIGCHLD（编号：17）：子进程停止或结束&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;管理Workder进程&lt;/li&gt;
&lt;li&gt;接收信号
&lt;ul&gt;
&lt;li&gt;TERM,INT&lt;/li&gt;
&lt;li&gt;QUIT&lt;/li&gt;
&lt;li&gt;HUP&lt;/li&gt;
&lt;li&gt;USR1&lt;/li&gt;
&lt;li&gt;USR2&lt;/li&gt;
&lt;li&gt;WINCH&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Worker进程&lt;/h2&gt;
&lt;p&gt;工作进程负责处理客户端的请求。Nginx 使用多个 worker 进程来提高并发能力和可用性。每个 worker 进程都是独立的，它们互不影响，可以并行处理请求。这种架构使 Nginx 能够充分利用多核处理器的优势，提高系统的吞吐量和性能。工作进程的数量可以在 Nginx 配置文件中设置，根据系统资源和实际需求进行调整。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;不推荐直接通过信号量管理Worker进程，虽然可以这样做，但一般通过Master进程来管理Worker进程&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;Worker进程&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接收信号
&lt;ul&gt;
&lt;li&gt;TERM,INT&lt;/li&gt;
&lt;li&gt;QUIT&lt;/li&gt;
&lt;li&gt;USR1&lt;/li&gt;
&lt;li&gt;WINCH&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;命令行&lt;/h2&gt;
&lt;p&gt;Bin目录下面执行的命令行语句（实际上也是发送信号量到Nginx）&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;reload:HUP&lt;/li&gt;
&lt;li&gt;reopen:USR1&lt;/li&gt;
&lt;li&gt;stop:TERM&lt;/li&gt;
&lt;li&gt;quit:QUIT&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Linux常用的信号量&lt;/h2&gt;
</content:encoded></item><item><title>SwitchHosts</title><link>https://rjomg-blog.pages.dev/posts/wp-2851/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2851/</guid><pubDate>Thu, 28 Sep 2023 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;安装&lt;/h2&gt;
&lt;h3&gt;下载地址&lt;/h3&gt;
&lt;p&gt;URL:https://github.com/oldj/SwitchHosts&lt;/p&gt;
&lt;h3&gt;解除Hosts权限&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;cd C:\Windows\System32\drivers\etc

attrib -s -h -r hosts
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis集群</title><link>https://rjomg-blog.pages.dev/posts/wp-2823/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2823/</guid><pubDate>Thu, 17 Aug 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是Redis集群、Redis集群原理、怎么搭建Redis集群&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;集群介绍&lt;/h2&gt;
&lt;p&gt;集群（cluster）就是一组计算机，它们作为一个整体向用户提供一组网络资源，这些单个的计算机系统就是集群的节点（Node）。集群提供了一下关键的特性。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可扩展性&amp;lt;/mark&amp;gt;。集群的性能不能限于单一的服务实体，新的服务实体可以动态的加入到集群，从而增强集群的性能。&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;高可用性&amp;lt;/mark&amp;gt;。集群通过服务实体冗余使客户端免于轻易找遇到“out of service”警告。当一台节点服务器发生故障的时候，这台服务器上所运行的应用程序将在另一节点服务器上被自动接管。消除单点故障对于增强数据可用性、可达性和可靠性是非常重要的。&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;负载均衡&amp;lt;/mark&amp;gt;。负载均衡能把任务比较均匀的分布到集群环境下的计算和网络资源，以便提高数据吞吐量。&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;错误回复&amp;lt;/mark&amp;gt;。如果集群中的某一台服务器由于故障或者维护需要而无法使用，资源和应用程序将转移到可用的集群节点上。这种由于某个节点中的资源不能工作，另一个可用节点中的资源能够透明的接管并且接续完成任务的过程叫做错误恢复。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;分布式与集群的联系与区别如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;分布式是指将不同的业务分布在不同的地方。&lt;/li&gt;
&lt;li&gt;而集群指的是将几台服务器集中在一起，实现同一业务。&lt;/li&gt;
&lt;li&gt;分布式的每一个节点，都可以做集群，而集群并不一定就是分布式。而分布式，从狭义上理解，也与集群差不多，但是它的组织比较松散，不像集群，有一定组织性，一台服务器宕机了，其他的服务器可以顶上来。分布式的每一个节点，都完成不同的业务，一个节点宕了，这个业务就不可访问了。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;集群的主要分成三大类：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;HA：高可用集群（High Availability Cluster）&lt;/li&gt;
&lt;li&gt;LBC：负载均衡集群/负载均衡系统（Load Balance Cluster）&lt;/li&gt;
&lt;li&gt;HPC：科学计算集群（High Performance Computing Cluster）/高性能计算（High Performance Computing）集群。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Redis集群架构&lt;/h2&gt;
&lt;p&gt;假设上千万、上亿用户同时访问Redis，QPS（请求数/秒）达到了10万+。这些请求过来，单机Redis直接就挂了。系统的瓶颈就出现在Redis单机问题上，此时我们可以通过主从复制解决该问题，实现系统的高并发。&lt;/p&gt;
&lt;p&gt;主从模式中，当主节点宕机之后，从节点是可以作为主节点顶上来继续提供服务，但是需要修改应用方的主节点地址，还需要命令所有从节点去复制新的主节点。整个过程需要人工干预。于是，再Redis2.8版本开始，引入了哨兵（Sentinel）这个概念，在主从复制的基础上，哨兵实现了自动化故障恢复。&lt;/p&gt;
&lt;p&gt;哨兵模式中，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;单个节点的写能力，存储能力收到了单机的限制，动态扩容困难复杂&amp;lt;/mark&amp;gt;。于是Redis3.0版本正式推出了Redis Cluster 集群模式，有效的解决了Redis分布式方面的需求。Redis Cluster 集群模式具有&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;高可用、可扩展性、分布式、容错&amp;lt;/mark&amp;gt;等特性。&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/08/Redis集群.png&quot; class=&quot;wp-image-2840&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;Redis Cluster 采用无中心结构，每个节点都可以保存数据和整个集群状态，每个节点都和其他的所有节点连接。Cluster一般由多个节点组成，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;节点数量至少为6个&amp;lt;/mark&amp;gt;才能保证组成完整高可用的集群，其中三个为主节点，三个为从节点。三个主节点会分配槽，处理客户端的命令请求，而从节点可以用在主节点故障后，顶替主节点。&lt;/p&gt;
&lt;p&gt;配置一个Redis Cluster我们需要准备至少6台Redis，为什么至少6台呢？我们可以在Redis官网文档中找到这样一句话：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Note that the minimal cluster that works as expected requires to contain at least three master nodes. 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为最小的Redis集群，需要至少3个主节点，既然有3个主节点，而一个主节点搭配至少一个从节点，因此至少需要6台Redis。如上图所示，该集群中包含了6个Redis节点，3主3从，分别为M1、M2、M3、S1、S2、S3、除了主从Redis节点之间进行数据恢复复制外，所有Redis节点之间采用Gossip协议进行通信，交换维护节点元数据信息。&lt;/p&gt;
&lt;p&gt;总结下来就是：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;读请求分配给Slave节点，写请求分配给Master，数据同步从Master到Slave节点。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h3&gt;主从模式&lt;/h3&gt;
&lt;p&gt;Redis Cluster 为了保证数据的高可用新，加入了主从模式，一个主节点对应一个或者多个从节点，主节点提供数据存取，从节点复制主节点数据备份，当这个主节点挂掉后，就会通过这个主节点的从节点选取一个来充当主节点，从而保证集群的高可用。&lt;/p&gt;
&lt;p&gt;回到刚才那个例子中，集群有A、B、C三个主节点，如果这3个主节点都没有对应的从节点，如果B挂掉了，则集群将无法继续，因为我们不再有办法为5501~11000范围内的哈希槽提供服务。&lt;/p&gt;
&lt;p&gt;所以我们在创建集群的时候，一定要为每一个主节点都添加对应的从节点。比如，集群包含主节点A、B、C，以及从节点A1、B1、C1那么即使B怪掉系统也可以继续正确的工作。&lt;/p&gt;
&lt;p&gt;因为B1节点属于B节点的子节点，所以Redis集群将会选择B1节点作为新的主节点，集群将会继续正确的提供服务。当B重新开启后，它就会变成B1的从节点。但是请注意，如果节点B和B1同时挂掉，Redis Cluster就无法继续正常的提供服务了。&lt;/p&gt;
&lt;h3&gt;优点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;去中心化&lt;/li&gt;
&lt;li&gt;可扩展性，数据按照Slot存储分布子在多个节点，节点间数据共享，节点可动态添加或者删除，可动态调整数据分布&lt;/li&gt;
&lt;li&gt;高可用新，部分节点不可用时，集群仍可用。通过正佳Slave做备份副本&lt;/li&gt;
&lt;li&gt;实现故障自动迁移，节点之间通过Gossip协议交换状态信息，用投票机制完成Slave到Master的角色提升&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;缺点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;数据通过异步复制，无法保证数据强一致性&lt;/li&gt;
&lt;li&gt;集群环境搭建略微复杂&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;原理&lt;/h2&gt;
&lt;p&gt;单机、主从、哨兵的模式数据都是存储在一个节点上，其他节点进行数据的复制。而单个节点存储的是存在上限的，集群模式就是把数据进行分片存储，当一个分片数据达到上限的时候，还可以分成多个分片。&lt;/p&gt;
&lt;h3&gt;哈希槽&lt;/h3&gt;
&lt;p&gt;Redis集群（Cluster）并没有选用一致性哈希，而是采用了哈希槽（SLOT）的这种概念。主要的原因是一致性哈希算法对于数据分布、节点位置的控制并不是很友好。&lt;/p&gt;
&lt;p&gt;首先哈希槽其实是两个概念：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;哈希算法。Redis Cluster的Hash算法不是简单的hash()，而是crc16算法，一种校验算法。&lt;/li&gt;
&lt;li&gt;槽位的概念，空间分配的规则、其实哈希槽的本质和一致性哈希算法非常相似，不同的点就是对于哈希空间的定义。一致性哈希的空间是一个圆环，节点分布是基于圆环的，无法很好的控制数据分布。而Redis Cluster的槽位空间是自定义分配的，类似于Window盘分区的概念。这种分区是可以自定义大小，自定义位置的。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Redis Cluster包含了16384个哈希槽，每个Key通过计算后都会落在具体的一个槽位上，而这个槽位是属于哪个存储节点的，则由用户自己定义分配。例如机器硬盘小的，可以分配少一点槽位，硬盘大的可以分配多一点。如果节点硬盘都差不多则可以平均分配。所以哈希槽这种概念很好的解决了一致性哈希的弊端。&lt;/p&gt;
&lt;p&gt;另外再容错性和扩展性上，表象与一致性哈希一样，都是对受影响的数据进行转移。而哈希槽本质上是对槽位的转移，把故障的节点负责的槽位转移到其他正常的节点上。扩展节点也是一样，把其他的节点上的槽位转移到新的节点上。&lt;/p&gt;
&lt;p&gt;但一定要注意的是，对于槽位的转移和分派，Redis集群是不会自动进行的，而是需要人工配置的。所以Redis集群的高可用是依赖于节点的主从复制与主从之间的自动故障转移。&lt;/p&gt;
&lt;h3&gt;16384个slots（槽位）&lt;/h3&gt;
&lt;p&gt;Redis Cluster没有单机的那种16个数据库（0-15）的概念，而是分成了15384个slots（槽位），每个节点负责其中一部分槽位，槽位的信息存储于每个节点中；当客户端来连接集群时，它先得到一份集群的槽位配置信息并将其缓存在客户端本地。这样当客户端要查找某个Key时，可以直接定位到目标节点。同时因为槽位的信息可能会存在客户端与服务器不一致的情况，还需要纠正机制来实现槽位信息的校验调整。&lt;/p&gt;
&lt;h3&gt;槽位定位算法&lt;/h3&gt;
&lt;p&gt;Redis Cluster默认会对key值使用CRC16算法进行hash得到一个整数值，然后用这个整数值对16384进行取模来得到具体槽位。每一个节点负责维护一部分槽以及槽所映射的键值数据。&lt;/p&gt;
&lt;p&gt;槽位计算公式：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;HASH_SLOT = CRC16(key) mod 16384&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/08/Redis算法.png&quot; class=&quot;wp-image-2859&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;键空间被分割为 16384 槽（slot），所有的主节点都负责 16384 个哈希槽中的一部分。当集群处于稳定状态时，集群中没有在执行重配置（reconfiguration）操作，每个哈希槽都只由一个节点进行处理（不过主节点可以有一个或多个从节点，可以在网络断线或节点失效时替换掉主节点）。&lt;/p&gt;
&lt;p&gt;Redis Cluster 提供了灵活的节点扩容和缩容方案。在不影响集群对外服务的情况下，可以为集群添加节点进行扩容也可以下线部分节点进行缩容。可以说，槽是 Redis Cluster 管理数据的基本单位，集群伸缩就是槽和数据在节点之间的移动。&lt;/p&gt;
&lt;p&gt;简单的理解就是：扩容或缩容以后，槽需要重新分配，数据也需要重新迁移，但是服务不需要下线。&lt;/p&gt;
&lt;p&gt;假如，这里有 3 个节点的集群环境如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;节点 A 哈希槽范围为 0 ~ 5500；&lt;/li&gt;
&lt;li&gt;节点 B 哈希槽范围为 5501 ~ 11000；&lt;/li&gt;
&lt;li&gt;节点 C 哈希槽范围为 11001 ~ 16383。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;此时，我们如果要存储数据，按照 Redis Cluster 哈希槽的算法，假设结果是： CRC16(key) % 16384 = 6782。 那么就会把这个 key 的存储分配到 B 节点。此时连接 A、B、C 任何一个节点获取 key，都会这样计算，最终通过 B 节点获取数据。&lt;/p&gt;
&lt;p&gt;假如这时我们新增一个节点 D，Redis Cluster 会从各个节点中拿取一部分 Slot 到 D 上，比如会变成这样：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;节点 A 哈希槽范围为 1266 ~ 5500；&lt;/li&gt;
&lt;li&gt;节点 B 哈希槽范围为 6827 ~ 11000；&lt;/li&gt;
&lt;li&gt;节点 C 哈希槽范围为 12288 ~ 16383；&lt;/li&gt;
&lt;li&gt;节点 D 哈希槽范围为 0 ~ 1265，5501 ~ 6826，11001 ~ 12287&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这种特性允许在集群中轻松地添加和删除节点。同样的如果我想删除节点 D，只需要将节点 D 的哈希槽移动到其他节点，当节点是空时，便可完全将它从集群中移除。&lt;/p&gt;
&lt;h3&gt;补充：为什么是 16384 个槽&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;CRC16&amp;lt;/mark&amp;gt;算法产生的 hash 值有 16bit，该算法可以产生 2^16-=65536 个值。换句话说，值是分布在 0~65535 之间。那作者在做mod运算的时候，为什么不mod65536，而选择mod16384？&lt;/p&gt;
&lt;p&gt;对于这个问题，作者给出了解答。原版回答如下图所示，对应的链接地址为：&lt;a href=&quot;https://github.com/redis/redis/issues/2576&quot;&gt;https://github.com/redis/redis/issues/2576&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/08/为什么16384槽位.png&quot; class=&quot;wp-image-2869&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;如果槽位为65536，发送心跳信息的消息头达8k，发送的心跳包过于庞大。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;两个 Redis 节点之间进行通信的时候，会&lt;strong&gt;定期&lt;/strong&gt;发送 PING/PONG 消息，交换&lt;strong&gt;数据信息&lt;/strong&gt;。交换的数据信息，由消息体和消息头组成。消息头包含了发送消息的节点的具体信息，每一个消息必须拥有完整的消息头；消息体无外乎是一些节点标识啊，IP啊，端口号啊，发送时间啊。&lt;/p&gt;
&lt;p&gt;在消息头中，最占空间的是 &amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;myslots[CLUSTER_SLOTS/8]&amp;lt;/mark&amp;gt;。当槽位为 65536 时，这块的大小是：65536 ÷ 8 = 8kb 因为每秒钟，Redis 节点需要发送一定数量的 PING 消息作为心跳包，如果槽位为 65536，这个 PING 消息的消息头太大了，浪费带宽。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Redis的集群主节点数量基本不可能超过1000个。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;如上所述，集群节点越多，心跳包的消息体内携带的数据越多。如果节点过1000个，也会导致网络拥堵。因此 Redis 作者，不建议 Redis Cluster 节点数量超过 1000 个。那么，对于节点数在 1000 以内的 Redis Cluster 集群，16384 个槽位够用了。没有必要拓展到 65536个。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;槽位越小，节点少的情况下，压缩率高。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Redis 主节点的配置信息中，它所负责的哈希槽是通过一张 bitmap 的形式来保存的，在传输过程中，会对 bitmap 进行压缩，但是如果 bitmap 的填充率 slots / N 很高的话(N表示节点数)，bitmap 的压缩率就很低。如果节点数很少，而哈希槽数量很多的话，bitmap 的压缩率也会很低。而 16384 ÷ 8 = 2kb。（文件压缩率指的是，文件压缩前后的大小比。）&lt;/p&gt;
&lt;p&gt;综上所述，作者决定取 16384 个槽，不多不少，刚刚好！&lt;/p&gt;
&lt;h2&gt;环境搭建&lt;/h2&gt;
&lt;p&gt;Redis 集群搭建在5版本以前使用Ruby构建集群，而5版本以后直接使用 &lt;code&gt;redis-cli&lt;/code&gt; 命令创建集群了。&lt;/p&gt;
&lt;h3&gt;编写配置文件&lt;/h3&gt;
&lt;p&gt;三个节点分别创建 &lt;code&gt;redis-*.conf&lt;/code&gt; 并添加以下配置（* 为具体端口为了区分文件）。&lt;/p&gt;
&lt;p&gt;注意：修改配置文件中所有 IP 和端口部分内容，可以使用 vi 命令 &lt;code&gt;%s/old/new/g&lt;/code&gt; 全局替换。&lt;/p&gt;
&lt;p&gt;vi /usr/local/redis/cluster/conf/redis-6371.conf（注意配置文件名称起名规则）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 放行访问IP限制
bind 0.0.0.0
# 端口
port 6371
# 后台启动
daemonize yes
# 日志存储目录及日志文件名
logfile &quot;/usr/local/redis/cluster/log/redis-6371.log&quot;
# rdb数据文件名
dbfilename dump-6371.rdb
# aof模式开启和aof数据文件名
appendonly yes
appendfilename &quot;appendonly-6371.aof&quot;
# rdb数据文件和aof数据文件的存储目录
dir /usr/local/redis/cluster/data
# 设置密码
requirepass 123456
# 从节点访问主节点密码(必须与 requirepass 一致)
masterauth 123456
# 是否开启集群模式，默认 no
cluster-enabled yes
# 集群节点信息文件，会保存在 dir 配置对应目录下
cluster-config-file nodes-6371.conf
# 集群节点连接超时时间
cluster-node-timeout 15000
# 集群节点 IP
cluster-announce-ip 192.168.10.101
# 集群节点映射端口
cluster-announce-port 6371
# 集群节点总线端口
cluster-announce-bus-port 16371
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每个 Redis 集群节点都需要打开&lt;strong&gt;两个 TCP 连接&lt;/strong&gt;。一个用于为客户端提供服务的正常 Redis TCP 端口，例如 6379。还有一个基于 6379 端口加 10000 的端口，比如 16379。&lt;/p&gt;
&lt;p&gt;第二个端口用于集群总线，这是一个使用二进制协议的节点到节点通信通道。节点使用集群总线进行故障检测、配置更新、故障转移授权等等。客户端永远不要尝试与集群总线端口通信，与正常的 Redis 命令端口通信即可，但是请确保防火墙中的这两个端口都已经打开，否则 Redis 集群节点将无法通信。&lt;/p&gt;
&lt;h3&gt;创建 Redis Cluster 集群&lt;/h3&gt;
&lt;p&gt;分别启动6个节点&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 分别启动
/usr/local/redis/bin/redis-server /usr/local/redis/cluster/conf/redis-6371.conf
/usr/local/redis/bin/redis-server /usr/local/redis/cluster/conf/redis-6372.conf
/usr/local/redis/bin/redis-server /usr/local/redis/cluster/conf/redis-6373.conf
/usr/local/redis/bin/redis-server /usr/local/redis/cluster/conf/redis-6374.conf
/usr/local/redis/bin/redis-server /usr/local/redis/cluster/conf/redis-6375.conf
/usr/local/redis/bin/redis-server /usr/local/redis/cluster/conf/redis-6376.conf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;随便一个 Redis 节点中使用客户端运行以下命令即可（注意IP和端口）：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 创建集群
/usr/local/redis/bin/redis-cli -a 123456 --cluster create \
192.168.10.101:6371 192.168.10.101:6372 \
192.168.10.102:6373 192.168.10.102:6374 \
192.168.10.103:6375 192.168.10.103:6376 \
--cluster-replicas 1
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt; # Docker创建集群
edis-cli --cluster create redis1:6379 redis2:6379 redis3:6379 redis4:6379 redis5:6379 redis6:6379 --cluster-replicas 1
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;--cluster&lt;/code&gt;：构建集群环境的所有 Redis 节点 IP + PORT 信息&lt;/li&gt;
&lt;li&gt;&lt;code&gt;--cluster-replicas 1&lt;/code&gt;：主节点数/从节点数的比例，使用一比一的比例，6 个节点最终会产生 3 主 3 从的集群环境&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;出现选择提示信息，输入 &lt;strong&gt;yes&lt;/strong&gt;，结果如下所示，集群创建成功：&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/08/搭建Redis集群.png&quot; class=&quot;wp-image-2888&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h3&gt;检查集群状态&lt;/h3&gt;
&lt;p&gt;任意一个节点即可，运行以下命令。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 查看状态
/usr/local/redis/bin/redis-cli -a 123456 --cluster check 192.168.10.101:6371

# 主节点信息
192.168.10.101:6371 (a1cd39d2...) -&amp;gt; 0 keys | 5461 slots | 1 slaves.
192.168.10.103:6375 (4568a256...) -&amp;gt; 0 keys | 5461 slots | 1 slaves.
192.168.10.102:6373 (4f3ec684...) -&amp;gt; 0 keys | 5462 slots | 1 slaves.
# 主节点有多少 Key
[OK] 0 keys in 3 masters.
# 每个槽的平均分配情况
0.00 keys per slot on average.
# 集群状态检查操作由 192.168.10.101:6371 节点执行
&amp;gt;&amp;gt;&amp;gt; Performing Cluster Check (using node 192.168.10.101:6371)
# 主节点信息以及附加的从节点个数
M: a1cd39d24bd2c9456026d592f0fac8728cea0e29 192.168.10.101:6371
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 4568a2560a688898a5d2337bce3a288f12355ae8 192.168.10.103:6375
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
# 从节点信息以及复制的主节点 ID
S: 78559b214c41f5909a5c6a0eecb9f01ee9efba9d 192.168.10.101:6372
   slots: (0 slots) slave
   replicates 4568a2560a688898a5d2337bce3a288f12355ae8
S: 3404010f04dff5109ddafaee2fe1f4abe1bc8292 192.168.10.103:6376
   slots: (0 slots) slave
   replicates 4f3ec6842325815a21f665691c8ac7b84235b306
M: 4f3ec6842325815a21f665691c8ac7b84235b306 192.168.10.102:6373
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 9cb940409435c06d2eb0628ed342abd9378d9f6b 192.168.10.102:6374
   slots: (0 slots) slave
   replicates a1cd39d24bd2c9456026d592f0fac8728cea0e29
# 所有节点都同意槽的配置情况
[OK] All nodes agree about slots configuration.
&amp;gt;&amp;gt;&amp;gt; Check for open slots...
&amp;gt;&amp;gt;&amp;gt; Check slots coverage...
# 所有 16384 个槽都包括在内
[OK] All 16384 slots covered.
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis哨兵（架构、原理、搭建）</title><link>https://rjomg-blog.pages.dev/posts/wp-2784/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2784/</guid><pubDate>Tue, 18 Jul 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：如何哨兵监控的架构、原理和搭建&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;哨兵监控架构&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/07/哨兵.png&quot; class=&quot;wp-image-2785&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;主从模式中，当主节点宕机之后，从节点是可以作为主节点顶上来继续提供服务，但是需要修改应用方面的主节点地址，还需要命令所有从节点去复制新的主节点，整个过程需要人工干预。&lt;/p&gt;
&lt;p&gt;于是，在Redis2.8版本开始，引入了哨兵（Sentinel）这个概念，在主从复制的基础上，哨兵实现了自动化故障恢复。如上图所示，哨兵模式由两部分组成，哨兵节点和数据节点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;哨兵节点：哨兵节点是特殊的Redis节点，不存储数据；&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;数据节点：主节点和从节点都是数据节点。&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Redis Sentinel 是分布式系统中监控Redis主从服务器，并提供服务器下线时自动故障转移功能的模式。其中三个特性为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;监控（Monitoring）：Sentinel会不断地检查你的主服务器和从服务器是否正常运行；&lt;/li&gt;
&lt;li&gt;提醒（Notification）：当被监控的某个Redis服务器出现问题时，Sentinel可以通过API向管理员或者其他应用程序发送通知；&lt;/li&gt;
&lt;li&gt;自动化故障迁移（Automatic failover）：当一个主服务器不能正常工作时，Sentinel 会开始一次自动故障迁移操作；&lt;/li&gt;
&lt;li&gt;配置提供者（Configguration provider）：为客户端提供服务发现功能，客户端链接Sentinel获取当前Master节点的相关信息，当发生failover时，Sentinel将新通知客户端&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Sentinel的分布式特性&lt;/h3&gt;
&lt;p&gt;Redis Sentinel 是一个分布式系统，可以在一个架构中运行多个Sentinel进程，优势如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;当多个Sentinel确定Master不再可用，进行故障检测，这降低了误报的可能性&lt;/li&gt;
&lt;li&gt;当在不同的服务器运行多个Sentinel进程，然后将Sentinel做集群，即使其中一个故障，也可以进行热切换，降低对客户端的影响，从而提升了系统的健壮性&lt;/li&gt;
&lt;li&gt;Redis客户端可连接任意Sentine来使用Redis&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;部署Redis Sentinel 前要了解&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Sentinel运行默认监听端口26379&lt;/li&gt;
&lt;li&gt;一个健壮的部署至少需要三个Sentinel实例&lt;/li&gt;
&lt;li&gt;运行Sentinel必须指定配置文件，因为系统使用此文件来保存当前状态，一遍重启Sentinel时重新加载。指定的配置文件有问题或不指定配置文件，Sentinel会拒绝启动&lt;/li&gt;
&lt;li&gt;三个Sentinel实例应放在相对独立的虚拟机或者物理机中。&lt;/li&gt;
&lt;li&gt;由于Redis使用的是异步复制，Sentinel + Redis 不能保证故障期间保留已确认的写入，但可以配置Sentinel允许丢失有限的写入。另外还有一些安全性比较低的部署方式&lt;/li&gt;
&lt;li&gt;使用的客户端要支持Sentinel，大多数热门的都支持Sentinel，但不是全部&lt;/li&gt;
&lt;li&gt;没有完全健壮的HA设置，所以要经常在测试环境中测试&lt;/li&gt;
&lt;li&gt;Sentinel在Docker端口影射或者网络地址转换的环境中配置要格外小心：在重新映射端口的情况下，真实端口可能与转发的端口不通，会破坏Sentinel自动发现其他Sentinel进程和master的Slave列表。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;优点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;哨兵模式是基于主从模式的，所有主从的优点哨兵都有&lt;/li&gt;
&lt;li&gt;主从可以自动切换，系统更健壮，可用性更高&lt;/li&gt;
&lt;li&gt;Sentinel会不断检查你的主服务器和从服务器是否正常运行，当被监控的某个Redis服务器出现问题时，Sentinel可以通过API或者其他应用程序发送通知。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;缺点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;主从切换需要时间，会丢失数据&lt;/li&gt;
&lt;li&gt;还是没有解决主从节点写的压力&lt;/li&gt;
&lt;li&gt;主从点的写能力，存储能力收到单机限制&lt;/li&gt;
&lt;li&gt;动态扩容困难复杂，对于集群，容量达到上限时在线扩容会变得很复杂&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;哨兵的工作原理&lt;/h2&gt;
&lt;h3&gt;定时任务&lt;/h3&gt;
&lt;p&gt;Sentinel内部有三个定时任务，分别是&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每一秒每个Sentinel对其他的Sentinel和Redis节点执行&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;PING&amp;lt;/mark&amp;gt;操作（监控），这是一个心跳检测，是失败判定的依据&lt;/li&gt;
&lt;li&gt;每两秒每个Sentinel通过Master节点的channel交换信息（Publish/subscribe）&lt;/li&gt;
&lt;li&gt;每十秒每个Sentinel会对Master和Slave执行&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;INFO命令&amp;lt;/mark&amp;gt;，这个任务主要达到两个目的
&lt;ul&gt;
&lt;li&gt;发现Slave节点&lt;/li&gt;
&lt;li&gt;确认主从关系&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;主观下线&lt;/h3&gt;
&lt;p&gt;所谓的主观下线（Subjectively Down，简称SDOWN）指的是单个Sentinel实例对服务器做出的下线判断，即单个Sentinel认为某个服务下线（有可能是接收不到订阅，之间的网络不通等等原因）。&lt;/p&gt;
&lt;p&gt;主管下线就是说如果服务器在给定的毫秒数之内，没有返回Sentinel发送的PING命令的回复，或者返回一个错误，那么Sentinel会将这个服务器标记为主观下线（SDOWN）。&lt;/p&gt;
&lt;h3&gt;客观下线&lt;/h3&gt;
&lt;p&gt;客观下线（Objectively Down，简称ODOWN）指的是多个Sentinel实例在对同一个服务器做出了SDOWN判断，并且通过命令互相交流之后，得出的服务器下线判断，然后开启failover。&lt;/p&gt;
&lt;p&gt;只有足够数量的Sentinel都将一个服务器标记为主管下线之后，服务器才会被标记为客观下线（ODOWN）。只有当Master被认定为客观下线时，才会发生故障迁移。&lt;/p&gt;
&lt;h3&gt;仲裁&lt;/h3&gt;
&lt;p&gt;仲裁值得是配置文件中的&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;quorum选项&amp;lt;/mark&amp;gt;。某个Sentinel先将Master节点标记为主观下线，然后会将这个判断通过&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;sentinel is-master-down-by-addr命令&amp;lt;/mark&amp;gt;询问其他Sentinel节点是否也同样认为该addr时，该Master节点会被认为客观下线进行故障迁移。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;quorum的值一般设置为Sentinel个数的二分之一加1&amp;lt;/mark&amp;gt;，例如3个Sentinel就设置为2.&lt;/p&gt;
&lt;h3&gt;哨兵模式工作原理&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;每个Sentinel以每秒一次的频率向他所知的Master、Slave以及其他Sentinel节点发送一个PING命令&lt;/li&gt;
&lt;li&gt;如果一个实例（Instance）距离最后一次有效回复PING命令的时间超过配置文件 own-after-milliseconds选项所指定的值，则这个实例会被Sentinel标记为&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主观下线。&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;li&gt;如果一个Master被标记为主管下线，那么正在监控这个Master的所有Sentinel要以每秒一次的频率确认Master是否真的进入了主观下线状态&lt;/li&gt;
&lt;li&gt;当有足够的Sentinel（大于等于配置文件所指定的值）在指定的时间范围内确认Master进入了主观下线状态，则Master会被标记为客观下线&lt;/li&gt;
&lt;li&gt;如果Master处于ODOWN状态，则投标自动选出新的主节点。将剩余的从节点指向新的主节点继续进行数据复制；&lt;/li&gt;
&lt;li&gt;在正常的情况下，每个Sentinel会以每10秒一次的频率向他已知的所有Master、Slave发送INFO命令，当Master被Sentinel标记为客观下线时，Sentinel向已下线的Master的所有Slave发送INFO命令的频率会从10秒一次改为每秒一次&lt;/li&gt;
&lt;li&gt;若美欧足够数量的Sentinel同意Master已经下线，Master的客观下线状态就会被移除。若Master重新向Sentinel的PING命令返回有效回复，Master的主管下线状态就会被移除。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;哨兵的搭建&lt;/h2&gt;
&lt;h3&gt;编写配置文件&lt;/h3&gt;
&lt;p&gt;在3台服务器分别安装Redis，或者直接在一主二从的三台Redis服务器上配置&lt;/p&gt;
&lt;p&gt;三个节点分别创建 &lt;code&gt;sentinel.conf&lt;/code&gt; 并添加以下配置。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 只有6.2以上版本的sentinel可以解析主机名 这个docker才需要开启的
sentinel resolve-hostnames yes
# 放行所有 IP 限制
bind 0.0.0.0
# 进程端口号
port 26379
# 后台启动 正常应该使用YES，Docker需要改成no
daemonize no
# 日志记录文件
logfile &quot;/usr/local/redis/sentinel/log/sentinel.log&quot;
# 进程编号记录文件
pidfile &quot;/var/run/sentinel.pid&quot;
# 指示 Sentinel 去监视一个名为 mymaster 的主服务器
sentinel monitor mymaster 172.18.0.7 6379 2
# 访问主节点的密码
# sentinel auth-pass mymaster 123456
# Sentinel 认为服务器已经断线所需的毫秒数
sentinel down-after-milliseconds mymaster 10000
# 若 Sentinel 在该配置值内未能完成 failover 操作，则认为本次 failover 失败
sentinel failover-timeout mymaster 180000
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;启动&lt;/h3&gt;
&lt;p&gt;先启动 3 个 Redis 服务&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 启动Redis
/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;启动3个Sentinel服务&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 启动Sentinel
/usr/local/redis/bin/redis-sentinel /usr/local/redis/conf/sentinel.conf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看日志&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 查看日志
tail -f /usr/local/redis/log/sentinel.log
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;故障迁移的一致性&lt;/h2&gt;
&lt;p&gt;有个问题，三个Sentinel如果选不出一个领头羊，或者三个Sentinel都要去做备份迁移，那么肯定是会出错的。&lt;/p&gt;
&lt;p&gt;解决这个方法，这里用到了&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;分布式一致性算法Raft（共识算法）&amp;lt;/mark&amp;gt;，就是怎么样选举Sentinel节点为领头羊节点&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Sentinel自动故障迁移使用Raft算法来选举领头羊（Leader）Sentinel，从而确保在一个给定的周期（epoch）里，只有一个领头产生。&lt;/li&gt;
&lt;li&gt;这表示在同一个周期中，不会有两个Sentinel同时被选择为领头，并且各个Sentinel在同一个节点中只会对一个领头进行投票。&lt;/li&gt;
&lt;li&gt;更高的配置节点总是优于较低的节点，因此每个Sentinel都会主动使用更新的节点来代替自己的配置。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;简单来说，我们可以将Sentinel配置看作是一个带版本号的状态，一个状态会以最后写入者胜出（Last-write-wins）的方式（也即是，最新的配置总是胜出的）传播至所有的其他Sentinel。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;TILT模式（假如系统时间错误了）&lt;/h2&gt;
&lt;p&gt;Redis Sentinel 严重历来系统时间：为了确认实例是否可用，他会记录最后一次回复PING的时间，并和当前时间比较推断距离最后一次回复过去了多久。&lt;/p&gt;
&lt;p&gt;然而，若系统时间发生非正常改变，或者系统非常繁忙，或进程优于谋些原因阻塞，Sentinel可能会出现一些问题。&lt;/p&gt;
&lt;p&gt;TITL模式是一种特殊的”保护“模式，Sentinel在发生一些意料之外的问题时，会进入这个模式，降低对系统时间的依赖。&lt;/p&gt;
&lt;p&gt;Sentinel所做的就是记录之前的中断调用时间，并和当前调用时间对比：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;如果两次调用时间之间的差距为负值（系统时钟调整到之前的某个时间值），或者非常大（超过SENTINEL_TILT_TRIGGER时间，默认为2s），那么Sentinel进入TILT模式。&lt;/li&gt;
&lt;li&gt;如果Sentinel已经进入TILT模式，那么Sentinel延迟退出TILT模式的时间。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;当处于TITL模式，Sentinel或持续监控所有状态：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;停止处理请求&lt;/li&gt;
&lt;li&gt;当有实力向这个Sentinel发送SENTINEL is-master-down-by-addr 命令时，Sentinel返回负值：因为这个Sentinel所进行的下线判断已经不再准确。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果TILT可以正常维持30秒钟（SENTINEL_TILT_PERIOD时长，默认为30s），那么Sentinel退出TILT模式，TITL模式是Sentinel的被动模式。&lt;/p&gt;
</content:encoded></item><item><title>Redis简单主从</title><link>https://rjomg-blog.pages.dev/posts/wp-2710/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2710/</guid><pubDate>Wed, 12 Jul 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：搭建一个Redis的简单主从&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;环境搭建&lt;/h2&gt;
&lt;h3&gt;环境准备&lt;/h3&gt;
&lt;p&gt;我是使用docker compose简单的创建了3个Redis分别是Redis1（主）、Redis2（从）、Redis3（从）。&lt;/p&gt;
&lt;p&gt;如果你是普通服务器，请准备3个Redis。&lt;/p&gt;
&lt;p&gt;以下不使用Docker做演示，Docker只需要参考修改一下就可以非常简单。&lt;/p&gt;
&lt;h3&gt;创建配置/数据/日志目录&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; # 创建配置目录
mkdir -p /usr/local/redis/conf
# 创建数据目录
mkdir -p /usr/local/redis/data
# 创建日志目录
mkdir -p /usr/local/redis/log
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;修改配置文件&lt;/h3&gt;
&lt;p&gt;创建或下载一份配置文件至 &lt;code&gt;conf&lt;/code&gt; 目录。&lt;/p&gt;
&lt;p&gt;按照Redis版本下载配置文件，下载地址：&lt;a href=&quot;https://redis.io/docs/management/config/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;URL&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/redis配置文件图.png&quot; class=&quot;wp-image-2249&quot; width=&quot;338&quot; height=&quot;287&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vim /usr/local/redis/conf/redis.conf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;分别修改3个节点配置文件中以下内容：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 放行访问IP限制
bind 0.0.0.0
# 后台启动
daemonize yes
# 日志存储目录及日志文件名
logfile &quot;/usr/local/redis/log/redis.log&quot;
# rdb数据文件名
dbfilename dump.rdb
# aof模式开启和aof数据文件名
appendonly yes
appendfilename &quot;appendonly.aof&quot;
# rdb数据文件和aof数据文件的存储目录
dir /usr/local/redis/data
# 设置密码
requirepass 123456
# 从节点访问主节点密码(必须与 requirepass 一致)
masterauth 123456
# 从节点只读模式
replica-read-only yes
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在从节点中额外添加以下内容：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 下面的配置无需在主节点中配置
# 从节点属于哪个主节点
slaveof 192.168.10.101 6379

# 从节点属于哪个主节点 Docker
slaveof 容器名称（例如：redis1） 6379
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;启动&lt;/h2&gt;
&lt;p&gt;三个节点分别运行以下命令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;检查&lt;/h2&gt;
&lt;p&gt;每个节点自带的客户端连接至Redis服务。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/usr/local/redis/bin/redis-cli
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;通过 info replication 查看主从信息，检查环境是否搭建成功。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;127.0.0.1:6379&amp;gt; info replication
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后在主节点插入一条数据，测试从节点是否可读取（是否复制成功），测试从节点是否可写数据（从节点只读模式是否生效）。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;原理剖析&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;IP&lt;/td&gt;
&lt;td&gt;预角色&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;192.168.10.101&lt;/td&gt;
&lt;td&gt;Master&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;192.168.10.102&lt;/td&gt;
&lt;td&gt;Slave&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;192.168.10.103&lt;/td&gt;
&lt;td&gt;Slave&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;复制配置&lt;/h3&gt;
&lt;p&gt;配置基本的Redis复制功能是很简单的。只需要将以下的内容加进slave的配置文件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 从节点属于哪个主节点，从哪个主节点进行复制
slaveof 192.168.10.101 6379
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;info replication&lt;/h3&gt;
&lt;h4&gt;主节点&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;127.0.0.1:6379&amp;gt; info replication
# Replication
# 角色
role:master
# 从节点的连接数
connected_slaves:2
# 从节点详细信息 IP PORT 状态 命令(单位:字节长度)偏移量 延迟秒数
# 主节点每次处理完写操作，会把命令的字节长度累加到master_repl_offset中。
# 从节点在接收到主节点发送的命令后，会累加记录子什么偏移量信息slave_repl_offset，同时，也会每秒钟上报自身的复制偏移量到主节点，以供主节点记录存储。
# 在实际应用中，可以通过对比主从复制偏移量信息来监控主从复制健康状况。
slave0:ip=192.168.10.102,port=6379,state=online,offset=23866,lag=0
slave1:ip=192.168.10.103,port=6379,state=online,offset=23866,lag=0
# master启动时生成的40位16进制的随机字符串，用来标识master节点
master_replid:acc2aaa1f0bb0fd79d7d3302f16bddcbe4add423
master_replid2:0000000000000000000000000000000000000000
# master 命令(单位:字节长度)已写入的偏移量
master_repl_offset:23866
second_repl_offset:-1
# 0/1：关闭/开启复制积压缓冲区标志(2.8+)，主要用于增量复制及丢失命令补救
repl_backlog_active:1
# 缓冲区最大长度，默认 1M
repl_backlog_size:1048576
# 缓冲区起始偏移量
repl_backlog_first_byte_offset:1
# 缓冲区已存储的数据长度
repl_backlog_histlen:23866
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;从节点&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;127.0.0.1:6379&amp;gt; info replication
# Replication
# 角色
role:slave
# 主节点详细信息
master_host:192.168.10.101
master_port:6379
# slave端可查看它与master之间同步状态,当复制断开后表示down
master_link_status:up
# 主库多少秒未发送数据到从库
master_last_io_seconds_ago:1
# 从服务器是否在与主服务器进行同步 0否/1是
master_sync_in_progress:0
# slave复制命令(单位:字节长度)偏移量
slave_repl_offset:24076
# 选举时，成为主节点的优先级，数字越大优先级越高，0 永远不会成为主节点
slave_priority:100
# 从库是否设置只读，0读写/1只读
slave_read_only:1
# 连接的slave实例个数
connected_slaves:0
# master启动时生成的40位16进制的随机字符串，用来标识master节点
master_replid:acc2aaa1f0bb0fd79d7d3302f16bddcbe4add423
# slave切换master之后，会生成了自己的master标识，之前的master节点的标识存到了master_replid2的位置
master_replid2:0000000000000000000000000000000000000000
# master 命令(单位:字节长度)已写入的偏移量
master_repl_offset:24076
# 主从切换时记录主节点的命令偏移量+1，为了避免全量复制
second_repl_offset:-1
# 0/1：关闭/开启复制积压缓冲区标志(2.8+)，主要用于增量复制及丢失命令补救
repl_backlog_active:1
# 缓冲区最大长度，默认 1M
repl_backlog_size:1048576
# 缓冲区起始偏移量
repl_backlog_first_byte_offset:1
# 缓冲区已存储的数据长度
repl_backlog_histlen:24076
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;复制流程&lt;/h3&gt;
&lt;p&gt;Redis的主从结构可以采用&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;一主多从&amp;lt;/mark&amp;gt;或者&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;级联结构&amp;lt;/mark&amp;gt;，Redis主从复制可以根据是否全量分为全量同步和增量同步&lt;/p&gt;
&lt;p&gt;主从刚刚连接的时候，进行全量同步；全同步结束后，进行增量同步。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;全量同步
&lt;ul&gt;
&lt;li&gt;Redis全量复制一般发生在Slave初始化阶段，这时Slave需要将Master上的所有数据都复制一份&lt;/li&gt;
&lt;li&gt;从服务器连接主服务器，发送SYNC命令&lt;/li&gt;
&lt;li&gt;主服务器接收到了SYNC命名后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令&lt;/li&gt;
&lt;li&gt;主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令&lt;/li&gt;
&lt;li&gt;从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；&lt;/li&gt;
&lt;li&gt;主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令&lt;/li&gt;
&lt;li&gt;从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;增量同步
&lt;ul&gt;
&lt;li&gt;Redis增量复制是指Slave初始化后开始正常工作时主服务器发生的写操作同步到从服务器的过程&lt;/li&gt;
&lt;li&gt;增量复制的过程主要是主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;主从复制的异步特性
&lt;ul&gt;
&lt;li&gt;主从复制对于主Redis来说是非阻塞的
&lt;ul&gt;
&lt;li&gt;这意味着当从服务器在进行主从复制同步过程中，主Redis仍然可以处理外接的访问请求&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;主从复制对于从Redis服务器来说也是非阻塞的
&lt;ul&gt;
&lt;li&gt;这意味着，即使从Redis在进行主从复制的过程中也可以接受外界的查询请求，只不过这时候从Redis返回的是以前老的数据&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Redis复制如何处理Key的过期&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Slave不会让Key过期&amp;lt;/mark&amp;gt;，而是等待Master让Key过期。当一个Master让一个Key到期时，它会合成一个DEL命令并传输到所有的Slave。包括源码中也体现了非主库不删：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int expireIfNeeded(redisDb *db, robj *key) { 
 time_t when = getExpire(db,key); 
 
 if (when &amp;lt; 0) return 0; /* No expire for this key */ 
 
 /* Don&apos;t expire anything while loading. It will be done later. */ 
 if (server.loading) return 0; 
 
 /* If we are running in the context of a slave, return ASAP: 
 * the slave key expiration is controlled by the master that will 
 * send us synthesized DEL operations for expired keys. 
 * 
 * Still we try to return the right information to the caller, 
 * that is, 0 if we think the key should be still valid, 1 if 
 * we think the key is expired at this time. */ 
 if (server.masterhost != NULL) { 
 return time(NULL) &amp;gt; when; 
 } 
 
 /* Return when this key has not expired */ 
 if (time(NULL) &amp;lt;= when) return 0; 
 
 /* Delete the key */ 
 server.stat_expiredkeys++; 
 propagateExpire(db,key); 
 return dbDelete(db,key); 
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;无需磁盘参与的复制&lt;/h3&gt;
&lt;p&gt;正常情况下，一个全量重同步要求在磁盘上创建一个RDB文件，然后将它从磁盘加载进内存，然后Slave以此进行数据同步。&lt;/p&gt;
&lt;p&gt;如果磁盘性能很低的话，这对Master是一个压力很大的操作。Redis2.8.12是第一个支持无磁盘复制的版本。在此设置中，子进程直接发送RDB文件给Slave，无需使用磁盘作为中间存储介质。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 默认是关闭的，使用的时候将 no 改为 yes 即可。
# 最终都会把RBD快照文件发送给丛节点，开启以后会不写入磁盘直接发送，关闭以后先写入磁盘再发送快照，默认关闭。
repl-diskless-sync no
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis如何选择RDB和AOF持久化</title><link>https://rjomg-blog.pages.dev/posts/wp-2619/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2619/</guid><pubDate>Wed, 28 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：如何选择RDB、AOF&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;同时开启&lt;/h2&gt;
&lt;p&gt;Redis先加载AOF文件来恢复原始数据，因为AOF数据比RDB更完整，但是AOF存在潜在的bug，如把错误的操作记录写入了AOF，会导出数据恢复失败，所以可以把RDB作为后备数据。&lt;/p&gt;
&lt;p&gt;为了考虑能，可以只在Slave上开启RDB，并且15min备份一次，如果为了避免AOF rewite的IO以及阻塞，可以在Redis集群中不开启AOF，靠集群的备份机制来保证可用性，在启动时选取较新的RDB文件，如果整个集群全部崩溃，会丢失15min前的数据。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;混合模式&lt;/h2&gt;
&lt;p&gt;Redis4.0开始支持该模式&lt;/p&gt;
&lt;p&gt;解决的问题：Redis在重启时通常是加载AOF文件，但加载速度慢。因为RDB数据不完整，所以加载AOF。&lt;/p&gt;
&lt;p&gt;开启方式：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;aof-use-rdb-preamble true&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;开启后，AOF在重写时会直接读取RDB中的内容。&lt;/p&gt;
&lt;p&gt;运行过程：通过bgrwriteaof完成，不同的是当开启混合持久化后&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;子进程会把内存中的数据以RDB的方式写入AOF中&lt;/li&gt;
&lt;li&gt;把重写缓冲区中的增量命令以AOF方式写入到文件&lt;/li&gt;
&lt;li&gt;将含有RDB个数和AOF个数的AOF数据覆盖旧的AOF文件&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;新的AOF文件中，一部分数据来自RDB文件，一部分来自Redis运行过程时的增量数据&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;数据恢复&lt;/h2&gt;
&lt;p&gt;当我们开启了混合持久化时，启动Redis依然优先加载AOF文件，AOF文件加载可能有两种情况如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;AOF文件开头是以RDB的格式，先加载RDB内容再加载剩余的AOF&lt;/li&gt;
&lt;li&gt;AOF文件开头的格式，直接以AOF格式加载整个文件&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;优点：既能快速备份又能避免大量数据丢失&lt;/p&gt;
&lt;p&gt;缺点：RDB是压缩格式，AOF在读取它时可读性较差&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;二者动态切换&lt;/h2&gt;
&lt;p&gt;在Redis2.2或以上版本，可以在重启的情况下，从RDB切换到AOF&quot;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;为最新的dump.rdb文件创建一个备份&lt;/li&gt;
&lt;li&gt;将备份放到一个安全的地方&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; # 复制备份
cp dump.rdb dump.rdb.bak
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行以下两条命令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 开启aof
redis-cli config set appendonly yes
# 关闭rdb
redis-cli config set save “”
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;确保写命令会被正确地追加到 AOF 文件的末尾&lt;/li&gt;
&lt;li&gt;执行的第一条命令开启了 AOF 功能： Redis 会阻塞直到初始 AOF 文件创建完成为止， 之后 Redis 会继续处理命令请求， 并开始将写入命令追加到 AOF 文件末尾&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;什么是RDB和AOF&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;链接：&lt;a href=&quot;https://www.rjomg.com/2023/06/27/2531/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Redis RDB持久化和AOF持久化&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Redis如何容灾备份</title><link>https://rjomg-blog.pages.dev/posts/wp-2655/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2655/</guid><pubDate>Wed, 28 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Redis的容灾备份&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;容灾备份&lt;/h2&gt;
&lt;h3&gt;1.&lt;strong&gt;开启RDB持久化&lt;/strong&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# redis.conf
save 900 1
save 300 10
save 60 10000
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;&lt;strong&gt;2.开启AOF配置&lt;/strong&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# redis.conf
# 开启aof
appendonly yes
appendfilename &quot;appendony.aof&quot;

# rewrite
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# appendfsync always
appendfsync everysec
# appendfsync no
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.&lt;strong&gt;RDB日志备份，编写脚本定时备份&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;vim一个redis-rdb-copy-per-hour.sh&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#!bin/bash
cur_date=$(date &quot;+%Y%m%d%H%M%S&quot;)
rm -rf /usr/local/redis/snapshotting/$cur_date
mkdir -p /usr/local/redis/snapshotting/$cur_date
cp /usr/local/redis/data/dump.rdb /usr/local/redis/snapshotting/$cur_date

del_date=$(date -d -48hour &quot;+%Y%m%d%H%M&quot;)
rm -rf /usr/local/redis/snapshotting/$del_date
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;使用crontab定时器执行备份脚本&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 打开crontab
crontab -e
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后写入（以下为每10秒执行一次，生产环境可以调整一下每小时执行一次）：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 打开crontab
# 测试环境
*/1 * * * * sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh
*/1 * * * * sleep 10; sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh
*/1 * * * * sleep 20; sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh
*/1 * * * * sleep 30; sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh
*/1 * * * * sleep 40; sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh
*/1 * * * * sleep 50; sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh

# 正式环境
* 1 * * * sh /usr/local/redis/bin/redis-rdb-copy-per-hour.sh
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.恢复方法&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;如果是redis进程挂掉，那么重启redis进程即可，直接基于AOF日志文件恢复数据&lt;/li&gt;
&lt;li&gt;如果是redis进程所在机器挂掉，那么重启机器后，尝试重启redis进程，尝试直接基于AOF日志文件进行数据恢复&lt;/li&gt;
&lt;li&gt;如果redis当前最新的AOF和RDB文件出现了丢失/损坏，那么可以尝试基于该机器上当前的某个最新的RDB数据副本进行数据恢复，步骤如下：​
&lt;ol&gt;
&lt;li&gt;停止redis(命令是redis-cli shutdown),&lt;/li&gt;
&lt;li&gt;在配置文件中关闭aof: appendonly no&lt;/li&gt;
&lt;li&gt;拷贝rdb日志备份到/usr/local/redis/data（如果使用的是docker默认则在/data）目录下&lt;/li&gt;
&lt;li&gt;启动redis&lt;/li&gt;
&lt;li&gt;尝试get一个key，确认数据恢复&lt;/li&gt;
&lt;li&gt;命令热修改redis配置,使用redis-cli连接redis，使用命令redis config set appendonly yes打开aof方式,这样aof和rdb数据就一致了&lt;/li&gt;
&lt;li&gt;手动修改redis.conf配置文件中appendonly为yes，因为热修改暂时不会写到配置文件中，所以需要手动修改，然后启动redis，再次确认数据恢复&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;优化方案&lt;/h2&gt;
&lt;h3&gt;独立部署，硬盘优化&lt;/h3&gt;
&lt;p&gt;独立部署其实为了解决子进程开销和优化，不要将Redis和其他存储服务器或者消息队列部署在一起，因为RDB和AOF的文件生成除了内存和硬盘开销之外，都属于CPU密集型操作。&lt;/p&gt;
&lt;p&gt;也可以根据写入量决定是否使用性能更高的SSD磁盘。&lt;/p&gt;
&lt;h3&gt;缓存禁用持久化&lt;/h3&gt;
&lt;p&gt;如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何的持久化方式。&lt;/p&gt;
&lt;h3&gt;主从模式，从持久化&lt;/h3&gt;
&lt;p&gt;因为RDB文件只是作为后备用途，建议只是在Slave（从库）上持久化RDB文件，而且只要15分钟备份一次就够了，只保留&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt; save 900 1&amp;lt;/mark&amp;gt; 这一条规则。&lt;/p&gt;
&lt;p&gt;如果不Enalbe AOF，仅靠Master-Slave Replication（主从复制）实现高可用高性能也可以。能省掉一大笔的IO也减少了Rewrite（重写）时带来的系统波动。代价是如果Master/Slave同时挂掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave中的RDB文件，载入较新的那个（新浪微博选用的架构模式）。&lt;/p&gt;
&lt;h3&gt;优化fork处理&lt;/h3&gt;
&lt;p&gt;如果Enalbe AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单的load自己的AOF文件就可以了。代价一是带来了持续的IO，二是AOF Rewrite 的最后将Rewrite过程中产生的数据写到新的文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF Rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设置到5G以上。默认超过原大小100%大小时重写可以改到适当的数值。&lt;/p&gt;
&lt;p&gt;还可以修改配置 &amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;no-appendfsync-on-rewrite no = yes&amp;lt;/mark&amp;gt; ，让AOF重写期间不要执行正常追加操作。&lt;/p&gt;
</content:encoded></item><item><title>Redis RDB持久化和AOF持久化</title><link>https://rjomg-blog.pages.dev/posts/wp-2531/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2531/</guid><pubDate>Tue, 27 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是RDB持久化、AOF持久化&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;Redis的持久化方式&lt;/h2&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql的Mysqldump文件和Redis的dumo.rdb类似&amp;lt;/mark&amp;gt;（原理并不一致）&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql的redo log和Redis的AOF(appendonly.aof)类似&amp;lt;/mark&amp;gt;（原理并不一致）&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可以关联记忆&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;PS：如果觉得阅读太长，可以直接阅读优点和缺点。&lt;/p&gt;
&lt;p&gt;通常数据库存在三种用于持久操作以防止数据损坏的常见策略：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;是数据库不关心故障，而是在数据文件损坏后从数据备份或快照中恢复。RDB就是这种情况&lt;/li&gt;
&lt;li&gt;该数据库使用操作日志记录每个操作的操作行为，以在失败后通过日志恢复一致性。由于操作日志是按顺序追加写入的，因此不会出现无法恢复操作日志的情况。类似于Mysql的重做和撤消日志。&lt;/li&gt;
&lt;li&gt;数据库不修改旧数据，而仅通过追加进行写入，因此数据本身就是日志，因此永远不会出现数据无法恢复的情况。CouchDB是一个很好的例子。AOF类似这种情况&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;严格上讲Redis为持久化提供了三种方式：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;RDB：在指定的时间间隔能对数据进行快照存储，类似于MySQL的dump备份文件。&lt;/li&gt;
&lt;li&gt;AOF：记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据（MySQL的binlog）。&lt;/li&gt;
&lt;li&gt;RDB与AOF混合使用，这是Redis4.0开始的新特性。在混合使用中AOF读取RDB数据重建原始数据集，集二者优势为一体。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;RDB持久化&lt;/h2&gt;
&lt;h3&gt;Redis配置文件&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; # redis.conf
# 放行访问IP限制
bind 0.0.0.0
# 后台启动
daemonize yes
# 日志存储目录及日志文件名
logfile &quot;/usr/local/redis/log/redis.log&quot;
# rdb数据文件名
dbfilename dump.rdb
# rdb数据文件和aof数据文件的存储目录
dir /usr/local/redis/data
# 设置密码
requirepass 123456
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;开启RBD&lt;/h3&gt;
&lt;p&gt;我们可以配置Redis在n秒内如果超过m个key被修改就自动做快照，下面是默认的快照保存配置（这3个选项都屏蔽，则RDB禁用）：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # redis.conf
# 900秒内如果超过1个key改动，则发起快照保存
save 900 1
# 300秒内如果超过10个key改动，则发起快照保存
save 300 10
# 60秒内如果超过1W个key改动，则发起快照保存
save 60 10000
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;什么叫Redis快照&lt;/h3&gt;
&lt;p&gt;快照，顾名思义可以理解为拍照一样，把整个内存数据映射到硬盘中，保存一份到硬盘，因此恢复数据起来比较快，把数据映射回去即可，不像AOF，一条条的执行操作命令。&lt;/p&gt;
&lt;p&gt;快照是默认的持久化方式。这种方式就是将内存中的数据以快照的方式写入到二进制文件中，默认的文件名为dump.rdb。可以通过配置设置自动做快照持久化的方式。&lt;/p&gt;
&lt;p&gt;产生快照的情况有以下几种：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;执行bgsave命令（此时Redis会fork一个子进程，子进程负责生成硬盘文件，父进程负责继续接受命令）&lt;/li&gt;
&lt;li&gt;执行save命令（和bgsave命令不同，发送save命令后，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;系统创建快照完成之前&amp;lt;/mark&amp;gt;系统不会再接受任何新的命令，换句话说&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;save命令会阻塞后面的命令，而bgsave不会&amp;lt;/mark&amp;gt;）&lt;/li&gt;
&lt;li&gt;根据用户在配置文件中配置的快照触发时间执行（即配置文件中的save 900 1）&lt;/li&gt;
&lt;li&gt;客户端发送shutdown，系统会&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;先执行save命令阻塞客户端&amp;lt;/mark&amp;gt;，然后关闭服务器&lt;/li&gt;
&lt;li&gt;当有主从架构时，从服务器向主服务器&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;发送sync命令&amp;lt;/mark&amp;gt;来执行复制操作时，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主服务器会执行bgsave&amp;lt;/mark&amp;gt;操作&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;RDB工作原理&lt;/h3&gt;
&lt;p&gt;Redis默认会将快照文件储存在Redis当前进程的工作目录中的dump.rdb文件中，可以通过配置dir和dbfilename两个参数分别指定快照文件的储存路径和文件名。流程过程如下图。&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/RDB工作原理.jpg&quot; class=&quot;wp-image-2560&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Redis使用fork函数&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;复制一份当前进程&amp;lt;/mark&amp;gt;（父进程）的副本（子进程）。&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;父进程&amp;lt;/mark&amp;gt;继续&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;接收并处理客户端&amp;lt;/mark&amp;gt;发来的命令，而&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;子进程开始将内存中的数据写入硬盘中的临时文件&amp;lt;/mark&amp;gt;。&lt;/li&gt;
&lt;li&gt;当子进程写入完所有数据后会用该&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;临时文件（子进程生成的文件）&amp;lt;/mark&amp;gt;替换旧的RDB文件，至此一次快照操作完成。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在执行fork的时候操作系统（类Unix操作系统）会使用写时复制（copy-on-write）策略，即fork函数发生的一刻父进程共享同一内存数据，父进程要更改其中某片数据时（如执行一个写命令），操作系统会将&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;该片数据复制一份以保证子进程的数据不受影响&amp;lt;/mark&amp;gt;，所以新的RDB文件存储的是执行fork一刻的内存数据。&lt;/p&gt;
&lt;p&gt;写时复制策略也保证了在fork的时刻虽然看上去生成了两份内存副本，但&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;实际上内存的占用量并不会增加一倍&amp;lt;/mark&amp;gt;。这就意味着当系统内存只有2GB，而Redis数据库的内存只有1.5GB时，执行fork后内存使用量并不会增加到3GB（超出物理内存）。为此需要确保Linux系统允许应用程序申请超过可用内存（物理内存和交换分区）的空间，方法是在/etc/sysctl.conf文件加入vm.overcommit_memory = 1 ，然后重启系统或者执行sysctl vm.overcommit_memory = 1 确保设置生效。&lt;/p&gt;
&lt;p&gt;另外需要注意的是，当进行快照的过程中，如果写入操作较多，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;造成fork前后数据差异较大&amp;lt;/mark&amp;gt;，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;是会是的内存使用量显著超过实际数据大小的&amp;lt;/mark&amp;gt;，因为内存中不仅保存了当前数据库的数据，而且还保存着fork时刻的内存数据。进行内存用量估算时很容易忽略这一个问题，造成内存用量超限。&lt;/p&gt;
&lt;p&gt;通过上述过程可以发现Redis进行快照的过程中不会修改RDB文件，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;只有快照结束后才会将旧的文件替换成新的，也就是说任何时候RDB文件都是完整的&amp;lt;/mark&amp;gt;。这使得我们可以通过定时备份RDB文件来实现Redis数据库备份。RDB文件是经过压缩（可以通过配置rdbcompression参数以禁用压缩节省CPU占用）的二进制格式，所以占用的空间会小于内存中的数据大小，更加利于传输。&lt;/p&gt;
&lt;p&gt;Redis启动后会读取RDB快照文件，将数据从硬盘载入到内存。根据数据量大小与结构和服务器性能不同，消耗的时间也不同，通常将一个记录1000万个字符串类型键、大小为1GB的快照文件载入到内存中需要花费约20~30秒。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;扩展：写入时复制（Copy-on-write，简称COW）是一种计算程序设计领域的优化策略。其核心思想是，如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，知道某个调用者试图修改资源的内容时，系统才会真正的复制一份专用副本（private copy）给该调用者 ，而其他调用者所见到的最初的资源仍然保持不变。这个过程对其他的调用者都是透明的。此做法主要的优点是如果调用者没有修改该资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h3&gt;RDB的优点&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;一旦采用RDB方式，那么你的整个Redis数据库将只包含一个紧凑压缩的二进制文件，这对于文件备份而言是非常完美的。比如，你可能打算每小时归档一次最近24小时的数据，同时还要每天归档一次最近30天的数据源。通过这样的备份策略，一旦系统出现灾难性故障，我们可以非常容易的进行回复。&lt;/li&gt;
&lt;li&gt;对于灾难恢复而言，RDB是非常不错的选择。因为我们可以非常轻松的将一个单独的文件压缩后再转移到其它的存储介质上。&lt;/li&gt;
&lt;li&gt;性能最大化。对于Redis的服务进程而言，在开始持久化时，它唯一需要做的只是fork出子进程。之后再由子进程完成这些持久化的工作，这样就可以极大的避免服务器进程执行IO操作了。&lt;/li&gt;
&lt;li&gt;相比于AOF机制，如果数据集很大，RDB的启动效率会更高。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;RDB的缺点&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;如果你想保证数据的高可用性，即最大限度的避免数据丢失，那么RDB将不是一个很好的选择。因为系统一旦在定时持久化之前出现宕机现象，此前数据没来得及写入磁盘的数据都将丢失。&lt;/li&gt;
&lt;li&gt;由于RDB是通过fork子进程来协助完成数据持久化工作的，因此，如果当数据集较大时，可能会导致整个服务器停止服务几百毫秒，甚至是1秒钟。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;AOF持久化&lt;/h2&gt;
&lt;p&gt;它也是Redis持久化的重要手段之一，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;AOF（Append Only File）只追加文件&amp;lt;/mark&amp;gt;，也就是没吃处理完请求命令后都会将此命令追加到AOF文件的末尾、而RDB是压缩成二进制等时机开子进程去干这个事情。&lt;/p&gt;
&lt;h3&gt;Redis配置文件&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; # redis.conf
# 默认appendonly为no
appendonly yes
appendfilename &quot;appendonly.aof&quot;
# RDB文件和AOF文件所在目录
dir /usr/local/redis/data
# fsync 持久化策略
appendfsync everysec
# AOF重写期间是否禁止fsync；如果开启该选项，可以减轻文件重写时CPU和硬盘的负载（尤其是硬盘），但是可能会丢失AOF重写期间的数据；需要在负载和安全性之间进行平衡
no-appendfsync-on-rewrite no
# 当前aof文件大于多少字节后才触发
auto-aof-rewrite-min-size 64mb
# 当前写入日志文件的大小超过上一次rewrite之后的文件大小的百分之100时，也就是2倍时触发Rewrite
auto-aof-rewrite-percentage 100
# 如果AOF文件结尾损坏，Redis启动时是否仍载入AOF文件
aof-load-truncated yes
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;同步策略&lt;/h3&gt;
&lt;p&gt;Redis中提供了三种AOF同步策略：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;每秒同步&amp;lt;/mark&amp;gt;（默认，每秒调用一次fsync，这种模式新能并不是很糟糕）&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;每修改同步&amp;lt;/mark&amp;gt;（会极大削弱Redis的性能，因为这种模式下每次write后都会调用fsync）&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;不主动同步&amp;lt;/mark&amp;gt;（由操作系统自动调度刷磁盘，性能是最好的）&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; # redis.conf
# 每秒钟同步一次，该策略为AOF的缺省策略
appendfsync everysec

# 每次有数据修改发生时都会写入AOF文件
appendfsync always

# 从不同步。高效但是数据不会主动被持久化
appendfsync no
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;事实上，每秒同步也是异步完成的，其实效率也是非常高的，所以差的是一旦系统出现宕机现象，那么这一秒钟之内修改的数据将会丢失。&lt;/p&gt;
&lt;p&gt;而每修改同步，我们可以将其视为同步持久化，即每次发生的数据变化都会被立即记录到磁盘中。可以预见，这种方式在效率上是最低的。&lt;/p&gt;
&lt;p&gt;至于无同步，Redis不会主动去将AOF日志内容同步到磁盘。所以这一切就完全依赖于操作系统的调试了。对于大多数Linux操作系统，是每30秒进行一次fsync，将缓冲区中的数据写到磁盘上。&lt;/p&gt;
&lt;h3&gt;AOF工作原理&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;client&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;→&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Redis Server&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;→&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;执行命令&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;→&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;命令写入AOF缓冲区&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;→&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;刷新磁盘写入AOF文件&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;AFO的频率高的话肯定会对Redis带来性能影响，因为每次都是刷盘操作。跟Mysql一样了。Redis每次都是先将命令放到缓冲区，然后根据具体的策略（每秒/每条指令/缓冲区满）进行刷盘操作。如果配置的always，那么就是典型阻塞，如果ererysec每秒的话，那么会开一个同步的线程区每秒进行刷盘操作，对主线程影响稍小。&lt;/p&gt;
&lt;h3&gt;写入文件与恢复&lt;/h3&gt;
&lt;p&gt;AOF文件是一个只进行append操作的日志文件，因此在写入的过程中即使出现宕机现象，也不会破坏日志文件中已经存在的内容。&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;假如一次操作只是写入了一半的数据就出现了系统崩溃问题&amp;lt;/mark&amp;gt;，不用担心，在Redis下次启动之前，我们可以通过&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;redis-check-aof工具&amp;lt;/mark&amp;gt;来帮助我们修复问题。&lt;/p&gt;
&lt;p&gt;AOF文件有序地保存了对数据库执行的所有写入操作，这些写入操作以Redis协议的格式保存，因此AOF文件的内容非常容易被人读懂，对文件进行分析（parse）也很轻松。&lt;/p&gt;
&lt;p&gt;导出（export）AOF文件也非常的简单，举个例子，如果你不小心执行了“&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;FLUSHALL&amp;lt;/mark&amp;gt;”命令，但只要AOF文件未被重写，那么只要停止服务器，移除AOF文件最末尾的“&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;FLUSHALL&amp;lt;/mark&amp;gt;”命令，并重启Redis，就可以将数据集恢复到“&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;FLUSHALL&amp;lt;/mark&amp;gt;”命令执行之前的状态。&lt;/p&gt;
&lt;h3&gt;重写&lt;/h3&gt;
&lt;p&gt;Redis可以在AOF文件体积变得过大时，自动地在后台对AOF进行rewrite。即Redis以append模式不断的将修改数据写入到老的磁盘文件中，同时Redis还会创建一个新的文件用于记录此期间有哪些修改命令被执行。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;因为Redis在创建新的AOF文件的过程中，会继续将命令追加到现有的AOF文件里面，即使重写的过程中发生停机，现有的AOF文件也不会丢失&amp;lt;/mark&amp;gt;。&lt;/p&gt;
&lt;p&gt;而一旦新的AOF文件创建完毕，Redis就会从旧AOF文件切换到新的AOF文件，并开始对新的AOF文件进行追加操作。&lt;/p&gt;
&lt;h4&gt;为什么要重写&lt;/h4&gt;
&lt;p&gt;比如我有业务很简单，就来回delete set 同一个key。就这个业务运行了10年，那么aof文件将记录无数个delete k1， set k1 xxx。其实都是重复的，但是我aof每次都追加，文件变成了1T大小。这时候Redis宕机了，要恢复，你想想1TB大小的aof文件去恢复，累死了。最主要的是1TB大小只记录了两个命令，所以压缩其实就是来处理这件事的。&lt;/p&gt;
&lt;h4&gt;rewrite触发条件&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;客户端执行“&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;bgrewriteaof&amp;lt;/mark&amp;gt;”命令&lt;/li&gt;
&lt;li&gt;auto-aof-rewrite-min-size 64 mb # 当前aof文件大于多少字节后才触发&lt;/li&gt;
&lt;li&gt;auto-aof-rewrite-percentage 100 # 当前写入日志文件的大小超过上一次rewrite之后的文件大小的百分之100时，也就是2倍时触发Rewrite&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;AOF优点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用AOF会让你的Redis更加耐久，你可以使用不同的fsync策略，无fsync，每秒fsync，每次写的时候fsync，使用默认每秒fsync策略，Redis的性能依然很好（fsync是由后台线程进行处理的，主线程会尽力处理客户端请求）一旦出现故障，你最多丢失1 秒的数据。&lt;/li&gt;
&lt;li&gt;AOF文件是一个只进行追加的日志文件，所以不需要写入seek，即使由于某些原因（磁盘空间已满，写的过程中宕机等等）未执行完整的写入命令，你也可以使用redis-check-aof工具修复这些问题。&lt;/li&gt;
&lt;li&gt;Redis可以在AOF文件体积变得过大时，自动的在后台对AOF进行重写。重写过后的新AOF文件包含了恢复当前数据集所需的最小命令集合。整个重写操作是绝对安全的，因为Redis在创建新的AOF文件的过程中，会继续将命令追加到现有的AOF文件里面，即使重写的过程中发生停机，现有的AOF文件也不会丢失。而一旦新的AOF文件创建完毕，Redis就会从旧的AOF文件切换到新的AOF文件，并开始对新的AOF文件进行追加操作。&lt;/li&gt;
&lt;li&gt;AOF文件有序地保存了对数据库执行的所有写入操作，这些写入操作以Redis协议的格式保存，因此AOF文件的内容非常容易被读懂，对文件镜像分析（parse）也很轻松。导出（export） AOF 文件也非常简单： 举个例子， 如果你不小心执行了 FLUSHALL 命令， 但只要 AOF 文件未被重写， 那么只要停止服务器， 移除 AOF 文件末尾的 FLUSHALL 命令， 并重启 Redis ， 就可以将数据集恢复到 FLUSHALL 执行之前的状态。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;AOF缺点&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;相对相同数量的数据集而言，AOF文件通常要大于RDB文件。RDB在恢复大数据集时的熟读比AOF恢复速度要快。&lt;/li&gt;
&lt;li&gt;根据同步的策略不同，AOF在运行效率上往往会慢于RDB。总之，每秒同步策略的效率是比较高的，同步禁用策略的效率和RDB一样高效。&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>Redis缓存、缓存击穿、缓存穿透、缓存雪崩、缓存淘汰</title><link>https://rjomg-blog.pages.dev/posts/wp-2494/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2494/</guid><pubDate>Mon, 26 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是Redis缓存击穿、缓存穿透、缓存雪崩、缓存淘汰策略&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;缓存概念&lt;/h2&gt;
&lt;p&gt;缓存是介于应用程序和物理数据源之间，其作用是为了降低应用程序对物理数据源访问的频次，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。比如我们通常是直接查询MySQL数据库，那在高并发情况下，大量查询MySQL数据库会导致数据库性能变慢，因此我们在应用层与MySQL之间搭建一个Cache层，让请求先访问Cache，这样就能大大降低数据库的压力，提高性能。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;分布式缓存&lt;/h2&gt;
&lt;p&gt;在分布式系统开发中，系统与系统之间都属于进程级别，缓存系统也能跨进程叫分布式缓存，市面上分布式缓存技术有Memcached和Redis这两种。二者区别大致如下：&lt;/p&gt;
&lt;h3&gt;性能&lt;/h3&gt;
&lt;p&gt;性能上都很出色，具体到细节，由于Redis只使用单核，而Memcached可以使用多核，所以平均每一个核上Redis在存储小数据时比Memcached性能更高。而在100K以上的数据中，Memcached性能要高于Redis，虽然Redis最近也在存储大数据的性能上进行优化，但是比起 Memcached，还是稍有逊色。&lt;/p&gt;
&lt;h3&gt;内存空间和数据量大小&lt;/h3&gt;
&lt;p&gt;MemCached可以修改最大内存，采用LRU算法。Redis增加了VM的特性，突破了物理内存的限制。&lt;/p&gt;
&lt;h3&gt;操作比较&lt;/h3&gt;
&lt;p&gt;MemCached数据结构单一，仅用来缓存数据，而Redis支持更加丰富的数据类型，也可以在服务器端直接对数据进行丰富的操作,这样可以减少网络IO次数和数据体积。&lt;/p&gt;
&lt;h3&gt;可靠性&lt;/h3&gt;
&lt;p&gt;MemCached不支持数据持久化，断电或重启后数据消失，但其稳定性是有保证的。Redis支持数据持久化和数据恢复，允许单点故障，但是同时也会付出性能的代价。&lt;/p&gt;
&lt;h3&gt;应用场景&lt;/h3&gt;
&lt;p&gt;Memcached：动态系统中减轻数据库负载，提升性能；做缓存，适合多读少写。&lt;br /&gt;
Redis：适用于对读写效率要求都很高，数据处理业务复杂和对安全性要求较高的系统。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;需要慎重考虑的部分&lt;/strong&gt;&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;Memcached单个key-value大小有限，一个value最大只支持1MB，而Redis最大支持512MB&lt;/li&gt;
&lt;li&gt;Memcached只是个内存缓存，对可靠性无要求；而Redis更倾向于内存数据库，因此对对可靠性方&lt;br /&gt;
面要求比较高&lt;/li&gt;
&lt;li&gt;从本质上讲，Memcached只是一个单一key-value内存Cache；而Redis则是一个数据结构内存数据&lt;br /&gt;
库，支持多种数据类型，因此Redis除单纯缓存作用外，还可以处理一些简单的逻辑运算，Redis不&lt;br /&gt;
仅可以缓存，而且还可以作为数据库用&lt;/li&gt;
&lt;li&gt;Redis还可以集群分布式，也就是说集群本身均衡客户端请求，各个节点可以交流，可拓展行、可&lt;br /&gt;
维护性更强大。而Memcached的集群则通过第三方才能搭建&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;存储方式&lt;/h2&gt;
&lt;p&gt;使用Redis做缓存的话，数据的存储结构有两种，一种采用&lt;code&gt;strings&lt;/code&gt;存储，另外使用&lt;code&gt;hashes&lt;/code&gt;存储。那使用哪种更好呢？得具体情况具体分析：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;strings&lt;/code&gt;存储比较简单的，固定的数据，比如存储一个简单的用户信息(用户名、昵称、头像、年龄等)。存储时需要将数据进行序列化，获取时要反序列化。在数据量较小的情况下还是可以忽略这种开销的&lt;/li&gt;
&lt;li&gt;但如果存储的的数据可能某些属性会有些变化，比如餐厅数据中，它有likeVotes(喜欢)和dislikeVotes(不喜欢)的数量，这类变的数据，那么我们采用&lt;code&gt;hashes&lt;/code&gt;会更好，而且存储的时候没有序列化开销&lt;/li&gt;
&lt;li&gt;官方推荐使用&lt;code&gt;hashes&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;缓存击穿&lt;/h2&gt;
&lt;p&gt;缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。做类电商项目的时候，把这货就称为“爆款”。&lt;/p&gt;
&lt;h3&gt;解决方案：&lt;/h3&gt;
&lt;p&gt;其实，大多数情况下这种爆款很难对数据库服务器造成压垮性的压力。达到这个级别的公司没有几家的。所以，对主打商品都是早早的做好了准备，让缓存永不过期。即便某些商品自己发酵成了爆款，也是直接设为永不过期就好了。&lt;/p&gt;
&lt;p&gt;(1) 从redis上看，确实没有设置过期时间，这就保证了，不会出现热点key过期问题，也就是“物理”不过期。&lt;/p&gt;
&lt;p&gt;(2) 从功能上看，如果不过期，那不就成静态的了吗？所以我们把过期时间存在key对应的value里，如果发现要过期了，通过一个后台的异步线程进行缓存的构建，也就是“逻辑”过期。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;缓存穿透&lt;/h2&gt;
&lt;p&gt;缓存穿透，是指查询一个数据库一定不存在的数据。正常的使用缓存流程大致是，数据查询先进行缓存查询，如果key不存在或者key已经过期，再对数据库进行查询，并把查询到的对象，放进缓存。如果数据库查询对象为空，则不放进缓存，就会每次都去查询数据库，而每次查询都是空，每次又都不会进行缓存。假如有恶意攻击，就可以利用这个漏洞，对数据库造成压力，甚至压垮数据库，导致所有的请求都怼到数据库上，从而数据库连接异常。&lt;/p&gt;
&lt;h3&gt;解决方案:&lt;/h3&gt;
&lt;p&gt;(1)利用互斥锁，缓存失效的时候，先去获得锁，得到锁了，再去请求数据库。没得到锁，则休眠一段时间重试&lt;/p&gt;
&lt;p&gt;(2)采用异步更新策略，无论key是否取到值，都直接返回。value值中维护一个缓存失效时间，缓存如果过期，异步起一个线程去读数据库，更新缓存。需要做缓存预热(项目启动前，先加载缓存)操作。&lt;/p&gt;
&lt;p&gt;(3)提供一个能迅速判断请求是否有效的拦截机制，比如，利用布隆过滤器，内部维护一系列合法有效的key。迅速判断出，请求所携带的Key是否合法有效。如果不合法，则直接返回。&lt;/p&gt;
&lt;p&gt;(4) 如果从数据库查询的对象为空，也放入缓存，只是设定的缓存过期时间较短，比如设置为60秒。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;缓存雪崩&lt;/h2&gt;
&lt;p&gt;缓存雪崩，是指缓存同一时间大面积的失效，这个时候又来了一波请求，结果请求都怼到数据库上，从而导致数据库连接异常。&lt;/p&gt;
&lt;p&gt;产生雪崩的原因之一，比如商城马上就要到双十一零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。&lt;/p&gt;
&lt;p&gt;其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，那么那个时候数据库也是可以顶住压力的，无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。&lt;/p&gt;
&lt;h3&gt;解决方案：&lt;/h3&gt;
&lt;p&gt;做电商项目的时候，一般是采取不同分类商品，缓存不同周期。在同一分类中的商品，加上一个随机因子。这样能尽可能分散缓存过期时间，而且，热门类目的商品缓存时间长一些，冷门类目的商品缓存时间短一些，也能节省缓存服务的资源。&lt;/p&gt;
&lt;p&gt;(1)给缓存的失效时间，加上一个随机值，避免集体失效。&lt;/p&gt;
&lt;p&gt;(2)使用互斥锁，但是该方案吞吐量明显下降了。&lt;/p&gt;
&lt;p&gt;(3)双缓存。我们有两个缓存，缓存A和缓存B。缓存A的失效时间为20分钟，缓存B不设失效时间。自己做缓存预热操作。然后细分以下几个小点&lt;/p&gt;
&lt;p&gt;a. 从缓存A读数据库，有则直接返回&lt;/p&gt;
&lt;p&gt;b. A没有数据，直接从B读数据，直接返回，并且异步启动一个更新线程。&lt;/p&gt;
&lt;p&gt;c. 更新线程同时更新缓存A和缓存B。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;缓存淘汰&lt;/h2&gt;
&lt;h3&gt;最大内存参数&lt;/h3&gt;
&lt;p&gt;我们的redis数据库的最大缓存、主键失效、淘汰机制等参数都是通过配置文件来配置的。这个文件是我们的redis.config文件。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;maxmemory &amp;lt;bytes&amp;gt;&lt;/code&gt;：设置最大内存&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/设置Redis内存大小.png&quot; class=&quot;wp-image-2516&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h3&gt;内存淘汰策略&lt;/h3&gt;
&lt;p&gt;截至目前 redis 一共为我们提供了八个不同的内存置换策略。很早之前提供了6种。&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/redis淘汰策略.png&quot; class=&quot;wp-image-2517&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;volatile-lru：从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。&lt;/li&gt;
&lt;li&gt;volatile-ttl：从已设置过期时间的数据集中挑选将要过期的数据淘汰。&lt;/li&gt;
&lt;li&gt;volatile-random：从已设置过期时间的数据集中任意选择数据淘汰。&lt;/li&gt;
&lt;li&gt;volatile-lfu：从已设置过期时间的数据集挑选使用频率最低的数据淘汰。&lt;/li&gt;
&lt;li&gt;allkeys-lru：从数据集中挑选最近最少使用的数据淘汰&lt;/li&gt;
&lt;li&gt;allkeys-lfu：从数据集中挑选使用频率最低的数据淘汰&lt;/li&gt;
&lt;li&gt;allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰&lt;/li&gt;
&lt;li&gt;no-enviction（驱逐）：禁止驱逐数据，这也是默认策略。意思是当内存不足以容纳新入数据时，新写入操作就会报错，请求可以继续进行，线上任务也不能持续进行，采用no-enviction策略可以保证数据不被丢失。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;淘汰机制的实现&lt;/h3&gt;
&lt;p&gt;既然是淘汰，那就需要把这些数据给删除，然后保存新的。&lt;/p&gt;
&lt;p&gt;Redis 删除策略主要有以下几种：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;**&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;惰性删除&amp;lt;/mark&amp;gt;：**master节点每次读取命令时都会检查键是否超时，如果超时则执行del命令删除键对象，之后异步把del命令slave节点，这样可以保证数据复制的一致性，slave节点是永远不会主动去删除超时数据的。&lt;/li&gt;
&lt;li&gt;**&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;定时删除&amp;lt;/mark&amp;gt;：**Redis的master节点在内部定时任务，会循环采样一定数量的键，当发现采样的键过期时，会执行del命令，之后再同步个slave节点。&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主动删除&amp;lt;/mark&amp;gt;：当前已用内存超过maxMemory限定时，触发主动清理策略。主动设置的前提是设置了maxMemory的值。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;参考&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;http://www.imooc.com/t/8217562&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;InCowboy&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Redis附近的人功能</title><link>https://rjomg-blog.pages.dev/posts/wp-2450/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2450/</guid><pubDate>Sun, 25 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：怎么使用Redis GEO命令实现附近的人&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;设计思路&lt;/h2&gt;
&lt;p&gt;解决基于地理位置的搜索，很多数据库品牌都支持：MySQL、MongoDB、Redis等都能支持地理位置的存储。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;当用户登录应用时，或者保持用户登录后用户在使用应用时，客户端是可以时刻获取用户位置信息的（前提是用户要开启位置获取的权限），客户端获取到最新的地理位置后，上传到后端服务器进行更新。&lt;/li&gt;
&lt;li&gt;当用户点击Near Me功能时，那么通过后台就可以以当前用户的位置为圆点，距离为半径查询相关的用户展示即可完成&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Redis GEO常用指令&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;命令&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;th&gt;参数&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GEOADD&lt;/td&gt;
&lt;td&gt;添加地理位置&lt;/td&gt;
&lt;td&gt;GEOADD key longitude latitude member [longitude latitude member …]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GEODIST&lt;/td&gt;
&lt;td&gt;两点间的距离&lt;/td&gt;
&lt;td&gt;GEODIST key member1 member2 [unit]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GEOHASH&lt;/td&gt;
&lt;td&gt;返回标准的Geohash值&lt;/td&gt;
&lt;td&gt;GEOHASH key member [member …]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GEOPOS&lt;/td&gt;
&lt;td&gt;返回key中给定元素的位置信息（经纬度）&lt;/td&gt;
&lt;td&gt;GEOPOS key member [member …]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GEOREDIUS&lt;/td&gt;
&lt;td&gt;返回以某点为圆心，距离为半径的其他位置元素&lt;/td&gt;
&lt;td&gt;GEOREDIUS key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GEORADIUSBYMEMBER&lt;/td&gt;
&lt;td&gt;跟GEOREDIUS一样，只不过圆心是给定的member元素&lt;/td&gt;
&lt;td&gt;GEORADIUSBYMEMBER key longitude latitude radius m | km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;GEOADD&lt;/h2&gt;
&lt;p&gt;GEOADD key longitude latitude member [longitude latitude member …] 添加位置信息&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 添加单个位置
127.0.0.1:0&amp;gt;GEOADD diner:location 121.446617 31.205593 &apos;zhangsan&apos;
&quot;1&quot;

# 添加多个位置信息
127.0.0.1:0&amp;gt;GEOADD diner:location 121.4465774 31.20485103  &apos;lisi&apos; 121.44534  31.2031 &apos;wangwu&apos;  121.4510648 31.2090667 &apos;zhangliu&apos;
&quot;3&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;GEODIST&lt;/h2&gt;
&lt;p&gt;GEODIST key member1 member2 [unit] 计算距离， 其中unit为单位 m|km|ft（英尺）|mi（英里）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 计算两点间的距离，返回距离的单位是米（m）
127.0.0.1:0&amp;gt;GEODIST diner:location zhangsan lisi m
&quot;82.4241&quot;
# 计算两点间的距离，返回距离的单位是千米（km）
127.0.0.1:0&amp;gt;GEODIST diner:location zhangsan lisi km
&quot;0.0824&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;GEOHASH&lt;/h2&gt;
&lt;p&gt;GEOHASH key member [member …] 返回一个或多个位置元素的Geohash。保存到Redis中是用Geohash位置52点整数编码。&lt;/p&gt;
&lt;p&gt;GeoHash将二维的经纬度转换成字符串，比如下图展示了北京9个区域的GeoHash字符串，分别是WX4ER，WX4G2、WX4G3等，每一个字符串代表了某一矩形区域。也就是说，这个矩形区域内所有的点（经纬度坐标）都共享相同的GeoHash字符串，这样既可以保护隐私（只表示大概区域位置而不是具体的点），又比较容易做缓存，比如左上角这个区域内的用户不断发送位置信息请求餐馆数据，由于这些用户的GeoHash字符串都是WX4ER，所以可以把WX4ER当作key，把该区域的餐馆信息当作value来进行缓存，而如果不使用GeoHash的话，由于区域内的用户传来的经纬度是各不相同的，很难做缓存。字符串越长，表示的范围越精确。&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/5fbb565409c2f99e02340237.png&quot; class=&quot;wp-image-2469&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 计算某个位置的GeoHash值
127.0.0.1:0&amp;gt;GEOHASH diner:location zhangsan
 1)  &quot;wtw3e8f9z20&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;GEOPOS&lt;/h2&gt;
&lt;p&gt;GEOPOS key member [member …]从&lt;code&gt;key&lt;/code&gt;里返回所有给定位置元素的位置（经度和纬度）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 返回zhangsan和lisi的位置信息
127.0.0.1:0&amp;gt;GEOPOS diner:location zhangsan lisi
 1)    1)   &quot;121.44661813974380493&quot;
  2)   &quot;31.20559220971455971&quot;

 2)    1)   &quot;121.44657522439956665&quot;
  2)   &quot;31.20485207113603821&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;GEORADIUS&lt;/h2&gt;
&lt;p&gt;GEORADIUS key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]&lt;/p&gt;
&lt;p&gt;给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。&lt;/p&gt;
&lt;p&gt;范围可以使用以下其中一个单位：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;m&lt;/strong&gt; 表示单位为米。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;km&lt;/strong&gt; 表示单位为千米。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;mi&lt;/strong&gt; 表示单位为英里。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;ft&lt;/strong&gt; 表示单位为英尺。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在给定以下可选项时， 命令会返回额外的信息：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;WITHDIST&lt;/code&gt;: 在返回位置元素的同时， 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;WITHCOORD&lt;/code&gt;: 将位置元素的经度和维度也一并返回。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;WITHHASH&lt;/code&gt;: 以 52 位有符号整数的形式， 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试， 实际中的作用并不大。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;命令默认返回未排序的位置元素。 通过以下两个参数， 用户可以指定被返回位置元素的排序方式：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;ASC&lt;/code&gt;: 根据中心的位置， 按照从近到远的方式返回位置元素。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;DESC&lt;/code&gt;: 根据中心的位置， 按照从远到近的方式返回位置元素。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在默认情况下， GEORADIUS 命令会返回所有匹配的位置元素。 虽然用户可以使用 **COUNT **选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 &lt;code&gt;COUNT&lt;/code&gt; 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 &lt;code&gt;COUNT&lt;/code&gt; 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 以121.446617 31.205593(张三位置)为圆心，3000m为半径，查询返回用户及其位置
127.0.0.1:0&amp;gt;GEORADIUS diner:location 121.446617 31.205593 3000 m WITHCOORD 
 1)    1)   &quot;wangwu&quot;
  2)      1)    &quot;121.44534140825271606&quot;
   2)    &quot;31.20310057881493293&quot;


 2)    1)   &quot;lisi&quot;
  2)      1)    &quot;121.44657522439956665&quot;
   2)    &quot;31.20485207113603821&quot;


 3)    1)   &quot;zhangsan&quot;
  2)      1)    &quot;121.44661813974380493&quot;
   2)    &quot;31.20559220971455971&quot;


 4)    1)   &quot;zhangliu&quot;
  2)      1)    &quot;121.45106524229049683&quot;
   2)    &quot;31.20906731242401833&quot;


# 以121.446617 31.205593(张三位置)为圆心，3000m为半径，查询返回用户及其距离(单位是米)
127.0.0.1:0&amp;gt;GEORADIUS diner:location 121.446617 31.205593 3000 m WITHDIST
 1)    1)   &quot;wangwu&quot;
  2)   &quot;302.6202&quot;

 2)    1)   &quot;lisi&quot;
  2)   &quot;82.5066&quot;

 3)    1)   &quot;zhangsan&quot;
  2)   &quot;0.1396&quot;

 4)    1)   &quot;zhangliu&quot;
  2)   &quot;573.0651&quot;
  
# 以121.446617 31.205593(张三位置)为圆心，3000m为半径，查询返回用户及其距离(单位是米) 由近及远
47.110.246.98:15&amp;gt;GEORADIUS diner:location 121.446617 31.205593 3000 m WITHDIST ASC
 1)    1)   &quot;zhangsan&quot;
  2)   &quot;0.1396&quot;

 2)    1)   &quot;lisi&quot;
  2)   &quot;82.5066&quot;

 3)    1)   &quot;wangwu&quot;
  2)   &quot;302.6202&quot;

 4)    1)   &quot;zhangliu&quot;
  2)   &quot;573.0651&quot;
  

# 以121.446617 31.205593(张三位置)为圆心，3000m为半径，查询返回用户及其GeoHash值
127.0.0.1:0&amp;gt;GEORADIUS diner:location 121.446617 31.205593 3000 m WITHHASH
 1)    1)   &quot;wangwu&quot;
  2)   &quot;4054756135204337&quot;

 2)    1)   &quot;lisi&quot;
  2)   &quot;4054756138536712&quot;

 3)    1)   &quot;zhangsan&quot;
  2)   &quot;4054756138736536&quot;

 4)    1)   &quot;zhangliu&quot;
  2)   &quot;4054756186304127&quot;

# 以121.446617 31.205593(张三位置)为圆心，3000m为半径，查询返回用户及其GeoHash值去2个
127.0.0.1:0&amp;gt;GEORADIUS diner:location 121.446617 31.205593 3000 m WITHHASH COUNT 2
 1)    1)   &quot;zhangsan&quot;
  2)   &quot;4054756138736536&quot;

 2)    1)   &quot;lisi&quot;
  2)   &quot;4054756138536712&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;GEORADIUSBYMEMBER&lt;/h2&gt;
&lt;p&gt;GEORADIUSBYMEMBER key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]，这个命令和 GEORADIUS 命令一样， 都可以找出位于指定范围内的元素， 但是 GEORADIUSBYMEMBER 的中心点是由给定的位置元素决定的， 而不是像 GEORADIUS 那样， 使用输入的经度和纬度来决定中心点&lt;/p&gt;
&lt;p&gt;指定成员的位置被用作查询的中心。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;原理&lt;/h2&gt;
&lt;p&gt;使用&lt;code&gt;GEOADD&lt;/code&gt;添加地理位置信息时，用标准格式的参数x,y,所以经度必须在纬度之前。这些坐标的限制是可以被编入索引的，区域面积可以很接近极点但是不能索引。具体的限制，由EPSG:900913 / EPSG:3785 / OSGEO:41001 规定如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;有效的经度从-180度到180度。&lt;/li&gt;
&lt;li&gt;有效的纬度从-85.05112878度到85.05112878度。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;当坐标位置超出上述指定范围时，该命令将会返回一个错误。&lt;/p&gt;
&lt;h3&gt;它是如何工作的？&lt;/h3&gt;
&lt;p&gt;sorted set使用一种称为Geohash的技术进行填充。经度和纬度的位是交错的，以形成一个独特的52位整数. 我们知道，一个sorted set 的double score可以代表一个52位的整数，而不会失去精度。&lt;/p&gt;
&lt;p&gt;这种格式允许半径查询检查的1 + 8个领域需要覆盖整个半径，并丢弃元素以外的半径。通过计算该区域的范围，通过计算所涵盖的范围，从不太重要的部分的排序集的得分，并计算得分范围为每个区域的sorted set中的查询。&lt;/p&gt;
&lt;h3&gt;使用什么样的地球模型（Earth model）？&lt;/h3&gt;
&lt;p&gt;这只是假设地球是一个球体，因为使用的距离公式是Haversine公式。这个公式仅适用于地球，而不是一个完美的球体。当在社交网站和其他大多数需要查询半径的应用中使用时，这些偏差都不算问题。但是，在最坏的情况下的偏差可能是0.5%，所以一些地理位置很关键的应用还是需要谨慎考虑。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;PHP示例&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;//连接redis
$redis = new Redis();
$redis-&amp;gt;connect(&apos;127.0.0.1&apos;, 6379);

//设置用户位置
$redis-&amp;gt;geoadd(&apos;user_location&apos;, 116.404, 39.915, &apos;user1&apos;);

//增加100个用户坐标数据
for ($i = 2; $i &amp;lt;= 101; $i++) {
    $redis-&amp;gt;geoadd(&apos;user_location&apos;, 116.404 + $i/1000, 39.915 + $i/1000, &apos;user&apos;.$i);
}

//获取用户最近的其他用户
$nearby_users = $redis-&amp;gt;georadius(&apos;user_location&apos;, 116.404, 39.915, 1000, &apos;m&apos;, [&apos;WITHDIST&apos;, &apos;ASC&apos;]);
print_r($nearby_users);

//获取某个用户附近的其他用户
$nearby_users_of_user1 = $redis-&amp;gt;georadiusbymember(&apos;user_location&apos;, &apos;user1&apos;, 1000, &apos;m&apos;, [&apos;WITHDIST&apos;, &apos;ASC&apos;, &apos;COUNT&apos;, 10]);
print_r($nearby_users_of_user1);

//计算两个用户之间的距离
$distance = $redis-&amp;gt;geodist(&apos;user_location&apos;, &apos;user1&apos;, &apos;user3&apos;, &apos;m&apos;);
echo &quot;用户1和用户3之间的距离是 &quot;.$distance.&quot; 米。&quot;;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis用户签到功能</title><link>https://rjomg-blog.pages.dev/posts/wp-2428/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2428/</guid><pubDate>Wed, 21 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：如何使用Redis实现用户签到功能&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;设计思路&lt;/h2&gt;
&lt;p&gt;使用Mysql的话1000w用户一个月就是3亿条数据，存储压力太大。&lt;/p&gt;
&lt;h3&gt;使用Redis的Bitmaps完成&lt;/h3&gt;
&lt;p&gt;Bitmaps叫位图，它不是Redis的基本数据类型（比如Strings、Lists、Sets、Hashes这类实际的数据类型），而是基于String数据类型的按位操作，高阶数据类型的一种。Bitmaps支持的最大位数是2&amp;lt;sup&amp;gt;32位。使用512M内存就可以存储多达42.9亿的字节信息（2&amp;lt;/sup&amp;gt;32 = 4,294,967,296）&lt;/p&gt;
&lt;p&gt;它是由一组bit位组成的，每个bit位对应0和1两个状态，虽然内部还是采用String类型存储，但Redis提供了一些指令用于直接操作位图，可以把它看作是一个bit数组，数组的下标就是偏移量。它的优点是内存开销小、效率高且操作简单，很适合用于签到这类场景。比如按月进行存储，一个月最多31天，那么我们将该月用户的签到缓存二进制就是00000000000000000000000000000000，当某天签到将0改成1即可，而且Redis提供对bitmap的很多操作比如存储、获取、统计等指令，使用起来非常方便。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;BitMaps常用指令&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;SETBIT key offset value: 将指定键（key）的位图中偏移量（offset）处的位设置为给定的值（value）。其中，offset 表示位图中的位索引，value 可以是 0 或 1。&lt;/li&gt;
&lt;li&gt;GETBIT key offset: 返回指定键（key）的位图中偏移量（offset）处的位的值（0 或 1）。&lt;/li&gt;
&lt;li&gt;BITCOUNT key [start end]: 统计指定键（key）的位图中指定范围内的位为 1 的个数。可选的 start 和 end 参数用于指定范围，如果不指定，则统计整个位图。&lt;/li&gt;
&lt;li&gt;BITOP operation destkey key [key ...]: 对指定键（key）的位图进行位操作，并将结果存储到 destkey 中。operation 可以是 AND、OR、XOR 或 NOT，用于指定位操作的类型。&lt;/li&gt;
&lt;li&gt;BITPOS key bit [start] [end]: 在指定键（key）的位图中查找第一个设置为指定 bit（0 或 1）的位的索引。可选的 start 和 end 参数用于指定查找范围。&lt;/li&gt;
&lt;li&gt;BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment]: BITFIELD 指令允许您在一个命令中执行多个位级操作，包括获取、设置和增减位值。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;功能开发&lt;/h2&gt;
&lt;h3&gt;需求说明&lt;/h3&gt;
&lt;p&gt;用户签到，默认是当天，但可以通过传入日期补签，返回用户连续签到次数（后续如果有积分规则，就会返回用户此次签到积分）&lt;/p&gt;
&lt;h3&gt;代码实现&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;SignService层关注方法&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;获取登录用户信息&lt;/li&gt;
&lt;li&gt;根据日期获取当前是多少号（使用BITSET指令关注时，offset从0开始计算，0就代表1号）&lt;/li&gt;
&lt;li&gt;构建用户按月存储key（user:sign:用户id:月份）&lt;/li&gt;
&lt;li&gt;判断用户是否签到（GETBIT指令）&lt;/li&gt;
&lt;li&gt;用户签到（SETBIT）&lt;/li&gt;
&lt;li&gt;返回用户连续签到次数（BITFIELD key GET [u/i] type offset value， 获取从用户从当前日期开始到1号的所有签到状态，然后进行位移操作，获取连续签到天数）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;PHP示例&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt; // 示例参数 假设今天是21号，所以数据只有到21号为止
$redis = new Redis();
$redis-&amp;gt;connect(&apos;redis&apos;, 6379);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 0, 1); // 这是1号的数据
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 1, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 2, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 3, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 4, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 5, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 6, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 7, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 8, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 9, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 10, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 11, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 12, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 13, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 14, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 15, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 16, 0); // 没有签到的日子
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 17, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 18, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 19, 1);
$redis-&amp;gt;setbit(&apos;user:sign:5:202306&apos;, 20, 1); // 这是21号的数据

// user:sign:5:202306 用户ID为5 2023年06月的签到数据
$sign_days = 0;
$today = date(&apos;j&apos;); // 今天的日期 可以手动设置为21
$decimal = $redis-&amp;gt;rawCommand(&apos;BITFIELD&apos;, &apos;user:sign:5:202306&apos;, ...[&apos;GET&apos;, &apos;u&apos; . $today, &apos;0&apos;]);
$binary = decbin($decimal[0]);
$sign_days = 0;
$length = strlen($binary);
for ($i = $length - 1; $i &amp;gt;= 0; $i--) {
    $bit = $binary[$i];
    if ($bit === &apos;1&apos;) {
        $sign_days++;
    } else {
        break;
    }
}

echo &quot;二进制数: &quot; . $binary;
echo &quot;
&quot;;
echo &quot;连续签到 $sign_days 天&quot;;
echo &quot;
&quot;;
echo &quot;一共签到 {$redis-&amp;gt;bitCount(&apos;user:sign:5:202306&apos;)}天&quot;;

# 结果
二进制数: 111111111111111101111
连续签到 4 天
一共签到 20天
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;&lt;/h2&gt;
</content:encoded></item><item><title>Redis如何实现好友功能</title><link>https://rjomg-blog.pages.dev/posts/wp-2377/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2377/</guid><pubDate>Mon, 19 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：实现关注/取关、关注列表，共同好友&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;设计思路&lt;/h2&gt;
&lt;p&gt;总体思路我们采用MySQL + Redis的方式结合完成。MySQL主要是保存落地数据，而利用Redis的&lt;strong&gt;Sets进行集合操作&lt;/strong&gt;。Sets拥有去重(我们不能多次关注同一用户)功能**。一个用户我们存贮两个集合：一个是保存用户关注的人 另一个是保存关注用户的人.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;SADD 添加成员；命令格式: SADD key member [member …] ----- 关注&lt;/li&gt;
&lt;li&gt;SREM 移除某个成员；命令格式: SREM key member [member …] -------取关&lt;/li&gt;
&lt;li&gt;SCARD 统计集合内的成员数；命令格式: SCARD key -------关注/粉丝个数&lt;/li&gt;
&lt;li&gt;SISMEMBER 判断是否是集合成员；命令格式:SISMEMBER key member ---------判断是否关注（如果关注那么只可以点击取关）&lt;/li&gt;
&lt;li&gt;SMEMBERS 查询集合内的成员；命令格式: SMEMBERS key -------列表使用（关注列表和粉丝列表）&lt;/li&gt;
&lt;li&gt;SINTER 查询集合的交集；命令格式: SINTER key [key …] --------共同关注、我关注的人关注了他&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/5fbb31570941071807450804.png&quot; class=&quot;wp-image-2426&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;Mysql示例表&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt; -- 表
CREATE TABLE t_follow (
id int(11) NOT NULL AUTO_INCREMENT ,
user_id int(11) NULL DEFAULT NULL COMMENT &apos;用户外键&apos; ,
follow_user_id int(11) NULL DEFAULT NULL COMMENT &apos;被关注用户外键&apos; ,
is_valid tinyint(1) NULL DEFAULT NULL ,
created_date datetime NULL DEFAULT NULL ,
updated_date datetime NULL DEFAULT NULL ,
PRIMARY KEY (id)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=utf8 COLLATE=utf8_general_ci
AUTO_INCREMENT=6
ROW_FORMAT=COMPACT;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Redis数据结构&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt; # Redis
# 被关注列表
SADD &quot;followers:1&quot; &quot;2&quot; &quot;3&quot; &quot;4&quot; &quot;5&quot;
SADD &quot;followers:2&quot; &quot;3&quot; &quot;4&quot; &quot;5&quot; &quot;6&quot;

# 关注列表
SADD &quot;following:2&quot; &quot;1&quot;
SADD &quot;following:3&quot; &quot;1&quot; &quot;2&quot;
SADD &quot;following:4&quot; &quot;1&quot; &quot;2&quot;
SADD &quot;following:5&quot; &quot;1&quot; &quot;2&quot;
SADD &quot;following:6&quot; &quot;2&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;共同关注列表&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;从Redis中读取登录用户的关注列表与查看用户的关注列表，然后进行交集操作，获取共同关注的用户id&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; # Redis
# ID2是共同关注的ID
&amp;gt; SINTER following:6 following:5
2

# 例子2
&amp;gt; SINTER following:4 following:5
1
2
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis实现Feed功能</title><link>https://rjomg-blog.pages.dev/posts/wp-2397/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2397/</guid><pubDate>Mon, 19 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：简单的Feed思路，实现类微博、类朋友圈功能。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是Feed&lt;/h2&gt;
&lt;p&gt;在互联网领域，尤其现在的移动互联网时代，Feed流产品是非常常见的，比如我们每天都会用到的朋友圈，微博，就是一种非常典型的Feed流产品，还有图片分享网站Pinterest，花瓣网等又是另一种形式的Feed流产品。除此之外，很多App的都会有一个模块，要么叫动态，要么叫消息广场，这些也是Feed流产品，可以说，Feed流产品是遍布天下所有的App中。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;概念&lt;/h2&gt;
&lt;p&gt;我们在讲如何设计Feed流系统之前，先来看一下Feed流中的一些概念：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Feed：Feed流中的每一条状态或者消息都是Feed，比如朋友圈中的一个状态就是一个Feed，微博中的一条微博就是一个Feed。&lt;/li&gt;
&lt;li&gt;Feed流：持续更新并呈现给用户内容的信息流。每个人的朋友圈，微博关注页等等都是一个Feed流。&lt;/li&gt;
&lt;li&gt;Timeline：Timeline其实是一种Feed流的类型，微博，朋友圈都是Timeline类型的Feed流，但是由于Timeline类型出现最早，使用最广泛，最为人熟知，有时候也用Timeline来表示Feed流。&lt;/li&gt;
&lt;li&gt;关注页Timeline：展示其他人Feed消息的页面，比如朋友圈，微博的首页等。&lt;/li&gt;
&lt;li&gt;个人页Timeline：展示自己发送过的Feed消息的页面，比如微信中的相册，微博的个人页等。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;特征&lt;/h2&gt;
&lt;p&gt;Feed流系统有一些非常典型的特点，比如：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;多账号内容流：Feed流系统中肯定会存在成千上万的账号，账号之间可以关注，取关，加好友和拉黑等操作。只要满足这一条，那么就可以当做Feed流系统来设计。&lt;/li&gt;
&lt;li&gt;非稳定的账号关系：由于存在关注，取关等操作，所以系统中的用户之间的关系就会一直在变化，是一种非稳定的状态。&lt;/li&gt;
&lt;li&gt;读写比例100:1：读写严重不平衡，读多写少，一般读写比例在10：1，甚至100：1以上。&lt;/li&gt;
&lt;li&gt;消息必达性要求高：比如发送了一条朋友圈后，结果部分朋友看到了，部分朋友没看到&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;分类&lt;/h2&gt;
&lt;p&gt;Feed流的分类有很多种，但最常见的分类有两种：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Timeline：按发布的时间顺序排序，先发布的先看到，后发布的排列在最顶端，类似于微信朋友圈，微博等。这也是一种最常见的形式。产品如果选择Timeline类型，那么就是认为&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Feed流中的Feed不多，但是每个Feed都很重要，都需要用户看到。&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;li&gt;Rank：按某个非时间的因子排序，一般是按照用户的喜好度排序，用户最喜欢的排在最前面，次喜欢的排在后面。这种一般假定用户可能看到的Feed非常多，而用户花费在这里的时间有限，那么就为用户选择出用户最想看的Top N结果，场景的应用场景有图片分享、新闻推荐类、商品推荐等。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;实现&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;解决Feed流最核心的两个问题：一个是存储，另一个是推送&lt;/strong&gt;&lt;/p&gt;
&lt;h3&gt;存储&lt;/h3&gt;
&lt;p&gt;因为该项目中Feed比较简单，就类比于空间说说，因此可以使用MySQL关系型数据库存储，如果对于数据结构比较复杂的Feed流就要使用NoSQL数据库，这样存储更方便与高效，比如MongoDB或者HBase。&lt;/p&gt;
&lt;h3&gt;推送&lt;/h3&gt;
&lt;p&gt;在推送方案里面的，有三种方案，分别是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;拉方案：也称为&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;读扩散&amp;lt;/mark&amp;gt;，用户主动去拉取关注人的Feed内容&lt;/li&gt;
&lt;li&gt;推方案：也成为&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;写扩散&amp;lt;/mark&amp;gt;，当用户添加Feed时，会自动将Feed通知给关注的人（优选）&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;使用Redis Sorted Sets（方便按时间排序Timeline）维护粉丝的Feed集合，当博主添加Feed时，主动将内容推送到粉丝的Feed集合中，这样用户可以很方便快速从集合中读取&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;推拉结合：比如微博，大部分用户的账号关系都是几百个，但是有个别用户是1000万以上才使用。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Mysql表结构&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt; -- 表
CREATE TABLE `feeds` (
`id`  int(11) NOT NULL AUTO_INCREMENT ,
`content`  varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT &apos;内容&apos; ,
`user_id`  int(11) NULL DEFAULT NULL ,
`praise_amount`  int(11) NULL DEFAULT NULL COMMENT &apos;点赞数量&apos; ,
`comment_amount`  int(11) NULL DEFAULT NULL COMMENT &apos;评论数量&apos; ,
`create_date`  datetime NULL DEFAULT NULL ,
`update_date`  datetime NULL DEFAULT NULL ,
`is_valid`  tinyint(1) NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=utf8mb4 COLLATE=utf8mb4_general_ci
AUTO_INCREMENT=14
ROW_FORMAT=COMPACT;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Redis结构&lt;/h2&gt;
&lt;p&gt;使用推方案：当用户ID为2所关注的用户发表一篇动态，按时间做为socre推送到following_feeds:2下面。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # Redis
# 示例
ZADD key score member [score] [member]

# 用户ID为2的Feed流ID组
ZADD &quot;following_feeds:2&quot; 1687179290 &quot;100005&quot; 1687179280 &quot;100002&quot; 1687179266 &quot;100001&quot;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis分布式锁</title><link>https://rjomg-blog.pages.dev/posts/wp-2344/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2344/</guid><pubDate>Sun, 18 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：什么是分布式锁，如何实现Redis分布式锁&lt;/p&gt;
&lt;h2&gt;什么是分布式锁&lt;/h2&gt;
&lt;p&gt;分布式锁是一种用于在分布式系统中实现资源的并发控制的机制。在分布式环境中，多个进程或节点需要协调对共享资源的访问，以避免并发访问导致的数据不一致或竞争条件的问题。分布式锁能够确保在多个进程或节点之间对共享资源的访问是有序的，避免了数据冲突和竞争条件。&lt;/p&gt;
&lt;p&gt;分布式锁可以通过多个工具实现：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;基于数据库、基于缓存、基于ZooKeeper&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;锁的获取与释放：进程或节点在获取锁时需要&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;确保只有一个能够成功获取到锁&amp;lt;/mark&amp;gt;，其他需要等待或重试。&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;在完成对共享资源的操作后，需要释放锁&amp;lt;/mark&amp;gt;，以便其他进程或节点能够获取到锁。&lt;/li&gt;
&lt;li&gt;锁的超时处理：为了避免因为某个进程或节点崩溃或异常导致锁一直被占用，可以设置锁的&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;超时时间&amp;lt;/mark&amp;gt;，在一定时间内未能正常释放锁时，可以由其他进程或节点获取锁。&lt;/li&gt;
&lt;li&gt;锁的可重入性：有些场景下，同一个进程或节点可能需要多次获取同一个锁，因此需要考虑锁的&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重入性&amp;lt;/mark&amp;gt;，即同一个进程或节点能够多次获取同一个锁而不会造成死锁。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Redis分布式锁&lt;/h2&gt;
&lt;h3&gt;简单的分布式锁&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# Redis分布式锁
SET KEY VALUE EX [seconds] PX [milliseconds] NX XX

# EX seconds – 设置键key的过期时间，单位时秒
# PX milliseconds – 设置键key的过期时间，单位时毫秒
# NX – 只有键key不存在的时候才会设置key的值
# XX – 只有键key存在的时候才会设置key的值
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;释放锁时可能的bug&lt;/h3&gt;
&lt;p&gt;案例：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;3个进程：A和B和C，在执行任务，并争抢锁，此时A获取了锁，并设置自动过期时间为60s&lt;/li&gt;
&lt;li&gt;A开始执行业务，因为某种原因，业务阻塞，耗时超过了60秒，此时锁自动释放了&lt;/li&gt;
&lt;li&gt;B恰好此时开始尝试获取锁，因为锁已经自动释放，成功获取锁&lt;/li&gt;
&lt;li&gt;A此时业务执行完毕，执行释放锁逻辑（删除key），于是B的锁被释放了，而B其实还在执行业务&lt;/li&gt;
&lt;li&gt;此时进程C尝试获取锁，也成功了，因为A把B的锁删除了。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这种情况就需要可重入锁就是文章开头说的可重入性&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;PHP什时候需要用分布式锁&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;分布式系统：当你的应用程序部署在多个服务器上，每个服务器都有自己的PHP进程，并且这些进程都连接到同一个Redis服务器时，就存在多个应用程序实例同时访问Redis的可能性。&lt;/li&gt;
&lt;li&gt;微服务架构：如果你的应用程序采用了微服务架构，其中不同的微服务可能运行在独立的服务器或容器中，并且每个微服务都可能需要访问共享的Redis服务，这样就会导致多个应用程序实例同时访问Redis。&lt;/li&gt;
&lt;li&gt;负载均衡：当你使用负载均衡器将请求分发到多个应用程序实例时，每个实例都有自己的PHP进程，这些进程可能会同时访问Redis&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;PHP示例&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;// PHP分布式锁
// 创建一个Redis分布式锁类
class RedisDistributedLock
{
    // Redis实例
    private $redis;

    // 锁的标识
    private $lockKey;

    // 可重入锁计数器
    private $counter;

    // 构造函数，初始化Redis实例和锁标识
    public function __construct($redis, $lockKey)
    {
        $this---&amp;gt;redis = $redis;
        $this-&amp;gt;lockKey = $lockKey;
        $this-&amp;gt;counter = 0;
    }

    // 加锁方法
    public function lock()
    {
        // 如果锁已经存在，增加计数器并返回true
        if ($this-&amp;gt;redis-&amp;gt;exists($this-&amp;gt;lockKey)) {
            $this-&amp;gt;counter++;
            return true;
        }

        // 尝试获取锁
        if ($this-&amp;gt;redis-&amp;gt;setnx($this-&amp;gt;lockKey, 1)) {
            // 设置锁过期时间，防止死锁
            $this-&amp;gt;redis-&amp;gt;expire($this-&amp;gt;lockKey, 10);
            // 初始化计数器
            $this-&amp;gt;counter = 1;
            return true;
        }

        // 获取锁失败
        return false;
    }

    // 解锁方法
    public function unlock()
    {
        // 如果计数器大于1，减少计数器并返回true
        if ($this-&amp;gt;counter &amp;gt; 1) {
            $this-&amp;gt;counter--;
            return true;
        }

        // 删除锁
        if ($this-&amp;gt;redis-&amp;gt;del($this-&amp;gt;lockKey)) {
            // 重置计数器
            $this-&amp;gt;counter = 0;
            return true;
        }

        // 解锁失败
        return false;
    }
}

// 链接Reids
$redis = new Redis();
$redis-&amp;gt;connect(&apos;127.0.0.1&apos;, 6379);

for ($i = 0; $i &amp;lt; 500; $i++) {
    // 调用示例
    $lockKey = &apos;Lock&apos;;
    $lock = new RedisTool($redis, $lockKey);
    $lock-&amp;gt;lock();
    // do something
    $lock-&amp;gt;unlock();
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis的基本类型</title><link>https://rjomg-blog.pages.dev/posts/wp-2269/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2269/</guid><pubDate>Wed, 14 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Redis的基本类型有哪些&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;基本类型&lt;/h2&gt;
&lt;p&gt;基本数据结构包含：字符串（strings）、 散列（hashes）、 列表（lists）、 集合（sets）、 有序集合（sorted sets）五种。这五种数据结构在我们工作中经常使用到，面试过程中经常被问到，因此熟练掌握这5种基本数据结构的使用和应用场景是Redis知识最基础也是最重要的部分。&lt;/p&gt;
&lt;h2&gt;字符串（Strings)&lt;/h2&gt;
&lt;p&gt;字符串(Strings)是Redis最简单的储存类型，它存储的值可以是&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;字符串&amp;lt;/mark&amp;gt;、&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;整数&amp;lt;/mark&amp;gt;或者&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;浮点数&amp;lt;/mark&amp;gt;，对整个字符串或者字符串的其中一部分执行操作；对整数或者浮点数执行自增（increment）或者自减（decrement）操作。&lt;/p&gt;
&lt;p&gt;Redis的字符串是一个由字节组成的序列，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;采用预分配冗余空间的方式来减少内存的频繁分配&amp;lt;/mark&amp;gt;，如图中所示，内部为当前字符串实际分配的空间 capacity 一般要高于实际字符串长度 len。当字符串长度小于 1M 时，扩容都是加倍现有的空间，如果超过 1M，扩容时一次只会多扩 1M 的空间。&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;需要注意的是字符串最大长度为 512M &amp;lt;/mark&amp;gt;。&lt;/p&gt;
&lt;h3&gt;应用场景&lt;/h3&gt;
&lt;p&gt;字符串类型在工作中使用广泛，主要用于缓存数据，提高查询性能。比如存储登录用户信息、电商中存储商品信息、可以做计数器（想知道什么时候封锁一个IP地址(访问超过几次)）等等。&lt;/p&gt;
&lt;h3&gt;操作命令&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;set key value:&lt;/strong&gt; 添加一条String类型数据&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;get key:&lt;/strong&gt; 获取一条String类型数据&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;mset key1 value1 key2 value2:&lt;/strong&gt; 添加多条String类型数据&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;mget key1 key2:&lt;/strong&gt; 获取多条String类型数据&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;incr key:&lt;/strong&gt; 自增（+1）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;incrby key step:&lt;/strong&gt; 按照步长（step）自增&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;decr key:&lt;/strong&gt; 自减（-1）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;decrby key step:&lt;/strong&gt; 按照步长（step）递减&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;散列（Hashes）&lt;/h2&gt;
&lt;p&gt;散列（Hashes）是一种存储键值对的数据结构，散列内部是无序字典，其中键和值都是字符串类型。散列可以看作是一个具有字段和值的哈希表，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;一个哈希表有多个节点，每个节点保存一个键值对&amp;lt;/mark&amp;gt;。&lt;/p&gt;
&lt;p&gt;Redis 为了高性能，不能堵塞服务，所以采用了渐进式 rehash 策略。&lt;/p&gt;
&lt;p&gt;渐进式 rehash 会在 rehash 的同时，保留新旧两个 hash 结构，查询时会同时查询两个 hash 结构，然后在后续的定时任务中以及 hash 操作指令中，循序渐进地将旧 hash 的内容一点点迁移到新的 hash 结构中。当搬迁完成了，就会使用新的hash结构取而代之。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;当 hash 移除了最后一个元素之后，该数据结构自动被删除，内存被回收&amp;lt;/mark&amp;gt;。&lt;/p&gt;
&lt;h3&gt;应用场景&lt;/h3&gt;
&lt;p&gt;Hash也可以同于对象存储，比如存储用户信息，与字符串不一样的是，字符串是需要将对象进行序列化（比如json序列化）之后才能保存，而Hash则可以讲用户对象的每个字段单独存储，这样就能节省序列化和反序列的时间。&lt;/p&gt;
&lt;h3&gt;操作命令&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;HSET key field value：将指定键的字段设置为指定的值。如果键不存在，则会创建一个新的散列并设置字段和值。&lt;/li&gt;
&lt;li&gt;HGET key field：获取指定键的字段对应的值。&lt;/li&gt;
&lt;li&gt;HGETALL key：获取指定键的所有字段和对应的值。&lt;/li&gt;
&lt;li&gt;HDEL key field1 [field2 ...]：删除指定键中的一个或多个字段及其对应的值。&lt;/li&gt;
&lt;li&gt;HEXISTS key field：检查指定键中是否存在指定的字段。&lt;/li&gt;
&lt;li&gt;HKEYS key：获取指定键中的所有字段。&lt;/li&gt;
&lt;li&gt;HVALS key：获取指定键中的所有值。&lt;/li&gt;
&lt;li&gt;HLEN key：获取指定键中字段的数量。&lt;/li&gt;
&lt;li&gt;HMSET key field1 value1 [field2 value2 ...]：设置指定键的多个字段和值。&lt;/li&gt;
&lt;li&gt;HMGET key field1 [field2 ...]：获取指定键的多个字段对应的值。&lt;/li&gt;
&lt;li&gt;&lt;em&gt;HINCRBY keyname field step：按照步长自增&lt;/em&gt;/&lt;em&gt;自减某个属性（该属性必须是数字）&lt;/em&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;列表（List）&lt;/h2&gt;
&lt;p&gt;列表（List）是一种有序、可重复的数据结构，它可以存储多个字符串值。列表按照插入顺序排序，并且可以在列表的两端执行插入、删除和查询操作。Redis的列表是基于链表实现的，因此在列表两端执行操作的时间复杂度为O(1)。&lt;/p&gt;
&lt;h3&gt;应用场景&lt;/h3&gt;
&lt;p&gt;lists的应用场景非常多，可以利用它轻松实现热销榜；可以实现工作队列（利用lists的push操作，将任务存在lists中，然后工作线程再用pop操作将任务取出进行执行 ）;可以实现最新列表，比如最新评论等。&lt;/p&gt;
&lt;h3&gt;操作命令&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;LPUSH key value1 [value2 ...]：将一个或多个值插入到列表的左侧（头部）。&lt;/li&gt;
&lt;li&gt;RPUSH key value1 [value2 ...]：将一个或多个值插入到列表的右侧（尾部）。&lt;/li&gt;
&lt;li&gt;LPOP key：移除并返回列表的左侧（头部）元素。&lt;/li&gt;
&lt;li&gt;RPOP key：移除并返回列表的右侧（尾部）元素。&lt;/li&gt;
&lt;li&gt;LINDEX key index：返回列表中指定索引位置的元素。&lt;/li&gt;
&lt;li&gt;LLEN key：返回列表的长度（即元素个数）。&lt;/li&gt;
&lt;li&gt;LRANGE key start stop：返回列表中指定范围内的元素（包括起始和结束位置）。&lt;/li&gt;
&lt;li&gt;LINSERT key BEFORE|AFTER pivot value：在列表中指定元素的前或后插入新元素。&lt;/li&gt;
&lt;li&gt;LSET key index value：将列表中指定索引位置的元素设置为新的值。&lt;/li&gt;
&lt;li&gt;LREM key count value：从列表中删除指定数量的匹配元素。&lt;/li&gt;
&lt;li&gt;RPOPLPUSH source destination：移除并返回源列表的最后一个元素，并将其插入到目标列表的头部。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;集合（Set）&lt;/h2&gt;
&lt;p&gt;集合（Set）是一种&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;无序&amp;lt;/mark&amp;gt;、&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;不重复&amp;lt;/mark&amp;gt;的数据结构，它可以存储多个字符串值。与列表不同，集合中的元素没有特定的顺序，并且&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;集合会自动去重&amp;lt;/mark&amp;gt;，确保每个元素的唯一性。Redis的集合是基于哈希表实现的，因此在集合中执行添加、删除和查询操作的时间复杂度为O(1)。&lt;/p&gt;
&lt;h3&gt;应用场景&lt;/h3&gt;
&lt;p&gt;redis的sets类型是使用哈希表构造的，因此复杂度是O(1)，它支持集合内的增删改查，并且支持多个集合间的交集、并集、差集操作。可以利用这些集合操作，解决程序开发过程当中很多数据集合间的问题。比如计算网站独立ip，用户画像中的用户标签，共同好友等功能&lt;/p&gt;
&lt;h3&gt;操作命令&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;SADD key member1 [member2 ...]：向集合中添加一个或多个成员。&lt;/li&gt;
&lt;li&gt;SREM key member1 [member2 ...]：从集合中移除一个或多个成员。&lt;/li&gt;
&lt;li&gt;SISMEMBER key member：判断指定成员是否存在于集合中。&lt;/li&gt;
&lt;li&gt;SMEMBERS key：返回集合中的所有成员。&lt;/li&gt;
&lt;li&gt;SCARD key：返回集合的基数（元素个数）。&lt;/li&gt;
&lt;li&gt;SPOP key [count]：随机移除并返回集合中的一个或多个成员。&lt;/li&gt;
&lt;li&gt;SRANDMEMBER key [count]：随机返回集合中的一个或多个成员，但不移除它们。&lt;/li&gt;
&lt;li&gt;SINTER key1 [key2 ...]：返回给定集合之间的交集。&lt;/li&gt;
&lt;li&gt;SUNION key1 [key2 ...]：返回给定集合之间的并集。&lt;/li&gt;
&lt;li&gt;SDIFF key1 [key2 ...]：返回给定集合之间的差集（第一个集合相对于其他集合的补集）。&lt;/li&gt;
&lt;li&gt;SINTERSTORE destination key1 [key2 ...]：将给定集合之间的交集存储到目标集合。&lt;/li&gt;
&lt;li&gt;SUNIONSTORE destination key1 [key2 ...]：将给定集合之间的并集存储到目标集合。&lt;/li&gt;
&lt;li&gt;SDIFFSTORE destination key1 [key2 ...]：将给定集合之间的差集存储到目标集合。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;有序集合（Sorted Set）&lt;/h2&gt;
&lt;p&gt;有序集合（Sorted Set）是一种数据结构，它类似于集合（Set），但每个成员都关联一个称为分数（score）的浮点数值。&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;有序集合中的成员是唯一的，但分数可以重复&amp;lt;/mark&amp;gt;。&lt;/p&gt;
&lt;h3&gt;应用场景&lt;/h3&gt;
&lt;p&gt;主要应用于根据某个权重进行排序的队列的场景，比如游戏积分排行榜，设置优先级的任务列表，学生成绩表等。&lt;/p&gt;
&lt;h3&gt;操作命令&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;ZADD key score member [score member ...]：将一个或多个成员及其对应的分数添加到有序集合中。&lt;/li&gt;
&lt;li&gt;ZREM key member [member ...]：从有序集合中移除一个或多个成员。&lt;/li&gt;
&lt;li&gt;ZCARD key：获取有序集合中成员的数量。&lt;/li&gt;
&lt;li&gt;ZSCORE key member：获取指定成员的分数。&lt;/li&gt;
&lt;li&gt;ZRANGE key start stop [WITHSCORES]：按照成员的排名范围获取有序集合中的成员。可选的 WITHSCORES 参数可以同时返回成员的分数。&lt;/li&gt;
&lt;li&gt;ZRANK key member：获取指定成员在有序集合中的排名（从低到高）。&lt;/li&gt;
&lt;li&gt;ZREVRANK key member：获取指定成员在有序集合中的排名（从高到低）。&lt;/li&gt;
&lt;li&gt;ZINCRBY key increment member：将指定成员的分数增加指定的增量值。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;参考&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;InCowboy电子书 - IMOOC&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mac M1/M2安装Apache JMeter</title><link>https://rjomg-blog.pages.dev/posts/wp-2333/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2333/</guid><pubDate>Wed, 14 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：在Mac上安装Apache JMeter&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 安装Java
brew install --cask temurin

# 查看是否安装成功
java -version

# 安装jmeter
brew install jmeter

# 启动
jmeter
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Redis介绍与特点</title><link>https://rjomg-blog.pages.dev/posts/wp-2204/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2204/</guid><pubDate>Fri, 09 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Redis的介绍、Redis的优势，为什么我们选用Redis而不选用Memcached&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;Redis介绍&lt;/h2&gt;
&lt;p&gt;Redis 是一个开源（BSD许可）的，&lt;strong&gt;内存&lt;/strong&gt;中的数据结构存储系统，它可以用作&lt;strong&gt;数据库、缓存和消息中间件&lt;/strong&gt;。 它支持多种类型的数据结构，如 字符串（strings），散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了复制（replication），LUA脚本（Lua scripting），LRU驱动事件（LRU eviction），事务（transactions）和不同级别的 &lt;strong&gt;磁盘持久化（persistence）&lt;/strong&gt;， 并通过&lt;strong&gt;Redis哨兵（Sentinel）&lt;/strong&gt; 和自动分区（Cluster）提供高可用性（high availability）&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;特点&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;内存数据库，速度快，也支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。&lt;/li&gt;
&lt;li&gt;Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等多种数据结构的存储。&lt;/li&gt;
&lt;li&gt;Redis支持&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;数据的备份&amp;lt;/mark&amp;gt;（master-slave）与&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;集群&amp;lt;/mark&amp;gt;（分片存储），以及拥有&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;哨兵监控机制&amp;lt;/mark&amp;gt;。&lt;/li&gt;
&lt;li&gt;支持事务&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;优势&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;性能极高 – &amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Redis能读的速度是110000次/s，写的速度是81000次/s &amp;lt;/mark&amp;gt;。&lt;/li&gt;
&lt;li&gt;丰富的数据类型 – Redis支持 Strings、Lists、 Hashes、Sets 、Sorted Sets 等数据类型操作。&lt;/li&gt;
&lt;li&gt;原子操作 – Redis的所有操作都是&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;原子性&amp;lt;/mark&amp;gt;的，同时Redis还支持对几个操作合并后的原子性执行。（事务）&lt;/li&gt;
&lt;li&gt;丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等特性。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Redis和Memcached的简单对比&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;Redis&lt;/td&gt;
&lt;td&gt;Memcached&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;开源&lt;/td&gt;
&lt;td&gt;是&lt;/td&gt;
&lt;td&gt;是&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;实现语言&lt;/td&gt;
&lt;td&gt;C&lt;/td&gt;
&lt;td&gt;C&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;数据类型&lt;/td&gt;
&lt;td&gt;不支持&lt;/td&gt;
&lt;td&gt;支持多种list，set，zset，hash等&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;客户端语言&lt;/td&gt;
&lt;td&gt;少&lt;/td&gt;
&lt;td&gt;多&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;原理&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;Redis是纯&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;内存数据库&amp;lt;/mark&amp;gt;，一般都是简单的存取操作，线程占用的时间很多，时间的花费主要集中在IO上，所以读取速度快。&lt;/li&gt;
&lt;li&gt;Redis使用的是&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;非阻塞IO&amp;lt;/mark&amp;gt;，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;IO多路复用&amp;lt;/mark&amp;gt;，使用了单线程来轮询描述符，将数据库的开、关、读、写都转换成了事件，减少了线程切换时上下文的切换和竞争。&lt;/li&gt;
&lt;li&gt;Redis采用了单线程的模型，保证了每个操作的原子性，也减少了线程的上下文切换和竞争。&lt;/li&gt;
&lt;li&gt;Redis存储结构多样化，不同的数据结构对数据存储进行了优化，如压缩表，对短数据进行压缩存储，再如，跳表，使用有序的数据结构加快读取的速度。&lt;/li&gt;
&lt;li&gt;Redis采用自己实现的&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;事件分离器&amp;lt;/mark&amp;gt;，效率比较高，内部采用非阻塞的执行方式，吞吐能力比较大。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;IO多路复用技术&lt;/h2&gt;
&lt;p&gt;redis 采用网络IO多路复用技术来保证在多连接的时候， 系统的高吞吐量。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;多路-指的是多个socket连接，复用-指的是复用一个线程&amp;lt;/mark&amp;gt;。多路复用主要有三种技术：select，poll，epoll。epoll是最新的也是目前最好的多路复用技术。&lt;/p&gt;
&lt;p&gt;这里“多路”指的是多个网络连接，“复用”指的是复用同一个线程。采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求（尽量减少网络IO的时间消耗），且Redis在内存中操作数据的速度非常快（内存内的操作不会成为这里的性能瓶颈），主要以上两点造就了Redis具有很高的吞吐量。&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/5fa95737082c346c06090326.jpg&quot; class=&quot;wp-image-2224&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>Mysql分析执行计划</title><link>https://rjomg-blog.pages.dev/posts/wp-2157/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2157/</guid><pubDate>Thu, 08 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：执行计划是什么？如何分析执行计划&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是执行计划&lt;/h2&gt;
&lt;p&gt;MySQL执行计划（Execution Plan）是数据库系统在执行查询语句时生成的查询执行策略的描述。它显示了MySQL优化器选择的查询执行方式，包括使用哪些索引、如何连接表、执行操作的顺序等信息。&lt;/p&gt;
&lt;p&gt;在MySQL中，可以使用&lt;code&gt;EXPLAIN&lt;/code&gt;关键字来获取查询的执行计划。以下是使用&lt;code&gt;EXPLAIN&lt;/code&gt;获取执行计划的基本语法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- 执行计划基本用法
EXPLAIN SELECT column1, column2, ...
FROM table
WHERE condition;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;分析执行计划&lt;/h2&gt;
&lt;p&gt;MySQL会返回一个描述查询执行计划的结果集。结果集中的各列提供了有关查询执行方式的详细信息&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;id：标识查询中的每个操作的唯一标识符。&lt;/li&gt;
&lt;li&gt;select_type：描述了操作类型，例如简单查询、子查询、联接等。&lt;/li&gt;
&lt;li&gt;table：表示涉及的表。&lt;/li&gt;
&lt;li&gt;partitions：表示涉及的分区表。&lt;/li&gt;
&lt;li&gt;type：表示表的连接类型，如全表扫描、索引扫描、范围扫描等。&lt;/li&gt;
&lt;li&gt;possible_keys：表示查询时可能使用的索引。多个索引以逗号分隔。&lt;/li&gt;
&lt;li&gt;key：表示查询使用的索引。&lt;/li&gt;
&lt;li&gt;key_len：表示索引使用的字节数&lt;/li&gt;
&lt;li&gt;ref：对于联接操作，表示连接条件使用的列。&lt;/li&gt;
&lt;li&gt;rows：表示每个操作扫描的行数。&lt;/li&gt;
&lt;li&gt;Extra：显示附加信息，例如排序、临时表等。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;id列&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;标识查询中的每个操作的唯一标识符。&lt;/li&gt;
&lt;li&gt;ID表示查询执行的顺序&lt;/li&gt;
&lt;li&gt;ID是由上到下执行的&lt;/li&gt;
&lt;li&gt;ID不同由大到小执行&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;select_type列&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;值&lt;/td&gt;
&lt;td&gt;含义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SIMPLE&lt;/td&gt;
&lt;td&gt;不包含子查询或是UNION操作查询&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PRIMARY&lt;/td&gt;
&lt;td&gt;查询中如果包含任何子查询，那么最外层的查询则被标记为PRIMARY&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SUBQUERY&lt;/td&gt;
&lt;td&gt;SELECT列表中的子查询&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DEPENDENT SUBQUERY&lt;/td&gt;
&lt;td&gt;依赖外部结果的子查询&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;UNION&lt;/td&gt;
&lt;td&gt;UNION操作的第二个或者是之后的查询值为UNION&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DEPENDENT UNION&lt;/td&gt;
&lt;td&gt;当UNION作为子查询时，第二或者第二个后查询的select_type值&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;UNION RESULT&lt;/td&gt;
&lt;td&gt;UNION产生的结果集&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DERIVED&lt;/td&gt;
&lt;td&gt;出现在FROM子句的子查询&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;table列&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;表示涉及的表。&lt;/li&gt;
&lt;li&gt;&amp;lt;union M,N&amp;gt;由ID为M，N查询Union产生的结果集&lt;/li&gt;
&lt;li&gt;&amp;lt;derived N&amp;gt; / &amp;lt;subqueery N&amp;gt;由ID为N的查询产生的结果&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;partitions列&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;显示查询的分区表ID&lt;/li&gt;
&lt;li&gt;对于非分区表，先是NULL&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;type列&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;性能&lt;/td&gt;
&lt;td&gt;值&lt;/td&gt;
&lt;td&gt;含义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;td&gt;system&lt;/td&gt;
&lt;td&gt;表示表只有一行，通常是由于访问系统表或常量表。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;td&gt;const&lt;/td&gt;
&lt;td&gt;表示基于常量条件的等值访问，即查询条件中的值是常量，并且只能匹配一个结果。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;td&gt;eq_ref&lt;/td&gt;
&lt;td&gt;表示基于唯一索引的等值访问，通常出现在连接操作中，使用的是索引的主键或唯一键。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;td&gt;ref&lt;/td&gt;
&lt;td&gt;表示基于普通索引的等值访问，通常出现在连接操作中，使用的是索引的非唯一键。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;td&gt;ref_or_null&lt;/td&gt;
&lt;td&gt;表示使用普通索引的等值访问，但还包括对NULL值的匹配。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;一般&lt;/td&gt;
&lt;td&gt;index_merge&lt;/td&gt;
&lt;td&gt;表示使用多个索引进行合并扫描。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;一般&lt;/td&gt;
&lt;td&gt;range&lt;/td&gt;
&lt;td&gt;表示使用索引的范围扫描，根据索引的范围条件进行访问。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;一般&lt;/td&gt;
&lt;td&gt;index&lt;/td&gt;
&lt;td&gt;表示进行全索引扫描，即扫描整个索引树而不访问数据行。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;低&lt;/td&gt;
&lt;td&gt;all&lt;/td&gt;
&lt;td&gt;表示全表扫描，遍历整个表的所有数据行。&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;keys相关列&lt;/h3&gt;
&lt;h4&gt;possible_keys列&lt;/h4&gt;
&lt;p&gt;表示查询时可能使用的索引。多个索引以逗号分隔。&lt;/p&gt;
&lt;h4&gt;keys列&lt;/h4&gt;
&lt;p&gt;实际使用的索引。如果为NULL，则表示没有使用索引。&lt;/p&gt;
&lt;h4&gt;key_len列&lt;/h4&gt;
&lt;p&gt;表示索引使用的字节数&lt;/p&gt;
&lt;h3&gt;Extra列&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;值&lt;/td&gt;
&lt;td&gt;含义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Using index&lt;/td&gt;
&lt;td&gt;表示查询使用了覆盖索引，即只通过索引就可以满足查询的需求，无需访问实际的数据行。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Using where&lt;/td&gt;
&lt;td&gt;表示查询使用了WHERE子句中的条件进行过滤。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Using temporary&lt;/td&gt;
&lt;td&gt;表示查询使用了临时表来存储中间结果集。这通常发生在查询中包含GROUP BY、ORDER BY、DISTINCT等操作时。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Using filesort&lt;/td&gt;
&lt;td&gt;表示查询需要进行文件排序操作，即对结果集进行排序。这可能发生在查询中包含ORDER BY操作时。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Using join buffer&lt;/td&gt;
&lt;td&gt;表示查询使用了连接缓冲区进行连接操作。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Impossible where&lt;/td&gt;
&lt;td&gt;表示查询的WHERE子句包含了不可能满足的条件，导致查询结果为空。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Full scan on NULL key&lt;/td&gt;
&lt;td&gt;表示对于某个索引，MySQL需要进行全表扫描来处理具有NULL键值的情况。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Select tables optimized away&lt;/td&gt;
&lt;td&gt;表示查询优化器通过优化操作将一些无用的表过滤掉，从而提高查询效率。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Distinct&lt;/td&gt;
&lt;td&gt;表示查询包含DISTINCT操作，用于返回唯一的结果。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Range checked for each record&lt;/td&gt;
&lt;td&gt;表示查询使用了范围检查操作，即对每个记录都进行了范围检查。&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
</content:encoded></item><item><title>Mysql8.0公共表达式</title><link>https://rjomg-blog.pages.dev/posts/wp-2115/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2115/</guid><pubDate>Wed, 07 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是公共表达式，公共表达式能做什么&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是公共表达式&lt;/h2&gt;
&lt;p&gt;MySQL 8.0 引入了公共表达式（Common Table Expressions，CTE），它是一种临时命名的结果集，可以在查询中多次引用。公共表达式提供了一种简洁和可读性强的方式来定义复杂的查询逻辑。&lt;/p&gt;
&lt;p&gt;公共表达式使用 WITH 关键字定义，并且可以包含一个或多个命名的查询表达式。每个命名的查询表达式由一个名称和一个查询体组成。公共表达式可以在主查询中像表一样引用，并且可以嵌套使用。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;示例&lt;/h2&gt;
&lt;h3&gt;普通查询&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 公共表达式
-- 定义一张临时表cte
WITH cte AS (
  SELECT id, name, salary
  FROM employees
  WHERE salary &amp;gt; 5000
)
-- 查询临时表
SELECT id, name, salary
FROM cte；
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;递归&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 公共表达式
-- 定义一张临时表test
WITH RECURSIVE test as (
SELECT 1 AS n
-- 合并两个查询结果
UNION ALL
-- 1+n
SELECT 1+n FROM test WHERE n&amp;lt;10
)
-- 查询临时表
SELECT * FROM test;

输出结果：
1
2
3
4
5
6
7
8
9
10
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql慢查询日志</title><link>https://rjomg-blog.pages.dev/posts/wp-2138/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2138/</guid><pubDate>Wed, 07 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：怎么开启和设置慢查询日志&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;开启和设置&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;SHOW VARIABLES LIKE &apos;slow_query_log&apos;; ：查询是否开启了慢查询&lt;/li&gt;
&lt;li&gt;SHOW VARIABLES LIKE &apos;slow_query_log_file&apos;; ：查询慢查询日志文件路径&lt;/li&gt;
&lt;li&gt;SET GLOBAL slow_query_log = [ON | OFF] ： 开启慢查询&lt;/li&gt;
&lt;li&gt;SET GLOBAL slow_query_log_file = /sql_log/slowlog.log ：设置慢查询日志目录&lt;/li&gt;
&lt;li&gt;SET GLOBAL long_query_time = XX.XXX秒（如需记录所有日志 设置为0）：设置记录为慢查询的时间&lt;/li&gt;
&lt;li&gt;SET GLOBAL log_queries_not_using_indexes = [ON | OFF] ：该变量用于确定是否将查询中未使用索引的语句记录到日志文件中。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;慢查询查询工具&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;mysqldumpslow [OPTS...][LOGS]（举例：mysqldumpslow /sql_log/slowlog.log）&lt;/li&gt;
&lt;li&gt;pt-query-digest[OPTIONS][FILES][DSN]（需要安装工具：&lt;a href=&quot;https://www.percona.com/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;链接&amp;lt;/mark&amp;gt;&lt;/a&gt;）&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql窗口函数</title><link>https://rjomg-blog.pages.dev/posts/wp-2127/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-2127/</guid><pubDate>Wed, 07 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是窗口函数，窗口函数能干什么&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;窗口函数&lt;/h2&gt;
&lt;p&gt;窗口函数：（Window Functions），它提供了一种在查询结果集的特定窗口范围内计算和分析数据的功能。窗口函数可以在 SELECT 语句中使用，并且可以对分组的行进行排序、排名、聚合以及计算行与窗口中其他行的相对位置等操作。&lt;/p&gt;
&lt;p&gt;窗口函数使用 OVER 子句来定义窗口规范，它指定了窗口函数要操作的数据集合范围。&lt;/p&gt;
&lt;h2&gt;常用的窗口函数&lt;/h2&gt;
&lt;p&gt;PARTITION BY：用于分组数据，窗口函数将在每个分组内独立计算。可以根据一个或多个列进行分组。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;ROW_NUMBER：为每一行分配一个唯一的整数序号，可以根据指定的排序规则进行排序。&lt;/li&gt;
&lt;li&gt;RANK：计算行在排序结果中的排名，相同值的行将获得相同的排名，但可能会跳过排名。&lt;/li&gt;
&lt;li&gt;DENSE_RANK：计算行在排序结果中的排名，相同值的行将获得相同的排名，不会跳过排名。&lt;/li&gt;
&lt;li&gt;SUM、AVG、COUNT、MIN、MAX 等聚合函数：在窗口范围内计算指定列的总和、平均值、计数、最小值、最大值等。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;示例&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt; -- 窗口函数
WITH test(name,type,score) AS (
SELECT &apos;sqlercn&apos;, &apos;Mysql&apos;, 95
UNION ALL
SELECT &apos;tom&apos;, &apos;Mysql&apos;, 99
UNION ALL
SELECT &apos;Jerry&apos;, &apos;Mysql&apos;, 99
UNION ALL
SELECT &apos;Gavin&apos;, &apos;Mysql&apos;, 98
UNION ALL
SELECT &apos;sqkercn&apos;, &apos;PositionSQL&apos;, 99
UNION ALL
SELECT &apos;tom&apos;, &apos;PositionSQL&apos;, 99
UNION ALL
SELECT &apos;Jerry&apos;, &apos;PositionSQL&apos;, 98
)

SELECT name, type, score
-- ROW_NUMBER
, ROW_NUMBER() OVER(PARTITION BY type ORDER BY score DESC ) AS rw
, RANK() OVER(PARTITION BY type ORDER BY score DESC ) AS rk
, DENSE_RANK() OVER(PARTITION BY type ORDER BY score DESC ) AS drk
FROM test ORDER BY type, rw;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出结果&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;tom&lt;/td&gt;
&lt;td&gt;Mysql&lt;/td&gt;
&lt;td&gt;99&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Jerry&lt;/td&gt;
&lt;td&gt;Mysql&lt;/td&gt;
&lt;td&gt;99&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Gavin&lt;/td&gt;
&lt;td&gt;Mysql&lt;/td&gt;
&lt;td&gt;98&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sqlercn&lt;/td&gt;
&lt;td&gt;Mysql&lt;/td&gt;
&lt;td&gt;95&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sqkercn&lt;/td&gt;
&lt;td&gt;PositionSQL&lt;/td&gt;
&lt;td&gt;99&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;tom&lt;/td&gt;
&lt;td&gt;PositionSQL&lt;/td&gt;
&lt;td&gt;99&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Jerry&lt;/td&gt;
&lt;td&gt;PositionSQL&lt;/td&gt;
&lt;td&gt;98&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
</content:encoded></item><item><title>Mysql DCL、DDL、DML、TCL操作</title><link>https://rjomg-blog.pages.dev/posts/wp-1846/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1846/</guid><pubDate>Mon, 05 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是DCL、DDL、DML、TCL&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;DCL&lt;/h2&gt;
&lt;p&gt;DCL（Data Control Language）：是用于定义和管理数据库访问权限的语言。DCL语句用于授权和撤销用户对数据库对象的访问权限，以及管理用户角色和权限的分配。&lt;/p&gt;
&lt;p&gt;以下是常用方法&lt;/p&gt;
&lt;h3&gt;1.授予权限&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 授予权限
REATE DATABASE dbname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.撤销权限&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; --撤销权限
REVOKE privileges ON object FROM user;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.创建角色&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 创建角色
CREATE ROLE rolename;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.删除角色&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除角色
DROP ROLE rolename;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.授予角色&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 授予角色
GRANT rolename TO user;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.撤销角色&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 撤销角色
REVOKE rolename FROM user;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;7.创建用户&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 创建用户
CREATE USER username IDENTIFIED BY &apos;password&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8.删除用户&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除用户
DROP USER username;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9.设置用户密码&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 设置用户密码
SET PASSWORD FOR user = &apos;password&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;10.修改用户密码&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 修改用户密码
ALTER USER user IDENTIFIED BY &apos;new_password&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;11.查看用户权限&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 查看用户权限
SHOW GRANTS FOR user;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;DDL&lt;/h2&gt;
&lt;p&gt;DDL（DATA Definition Language）：是MySQL中用于定义和管理数据库对象的语言。DDL语句用于创建、修改和删除数据库、表、索引、视图和其他数据库对象。&lt;/p&gt;
&lt;p&gt;以下是常用方法&lt;/p&gt;
&lt;h3&gt;1.创建数据库&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 创建数据库
REATE DATABASE dbname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.删除数据库&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除数据库
DROP DATABASE dbname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.使用数据库&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 使用数据库
USE dbname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.创建表&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 创建表
CREATE TABLE tablename (
  column1 datatype,
  column2 datatype,
  ...
);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.修改表名&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 修改表名
ALTER TABLE oldname RENAME TO newname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.修改表结构&lt;/h3&gt;
&lt;h4&gt;添加列&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt; -- 添加列
ALTER TABLE tablename ADD COLUMN columnname datatype;
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;修改列&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt; -- 修改列
ALTER TABLE tablename MODIFY COLUMN columnname datatype;
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;删除列&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt; -- 删除列
ALTER TABLE tablename DROP COLUMN columnname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;7.删除表&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除表
DROP TABLE tablename;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8.创建索引&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 创建索引
CREATE INDEX indexname ON tablename (columnname);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9.删除索引&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除索引
DROP INDEX indexname ON tablename;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;10.创建视图&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 创建视图
CREATE VIEW viewname AS SELECT column1, column2 FROM tablename WHERE condition;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;11.修改视图&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 修改视图
ALTER VIEW viewname AS SELECT column1, column2 FROM tablename WHERE condition;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;12.删除视图&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除视图
DROP VIEW viewname;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;13.清空表&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 清空表
truncate tablename;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;DML&lt;/h2&gt;
&lt;p&gt;DML（Data Manipulation Language）：用于操作数据库中的数据。&lt;/p&gt;
&lt;h3&gt;插入数据&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 插入数据
INSERT INTO table_name (column1, column2, ...) VALUES (value1, value2, ...);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;更新数据&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 更新数据
UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE condition;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;删除数据&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 删除数据
DELETE FROM table_name WHERE condition;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;查询数据&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 查询数据
SELECT column1, column2, ... FROM table_name WHERE condition;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;TCL&lt;/h2&gt;
&lt;p&gt;TCL（Transaction Control Language）用于控制数据库事务的提交（commit）和回滚（rollback）。&lt;/p&gt;
&lt;h3&gt;1.开始事务&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 开始事务
START TRANSACTION;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.提交事务&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 提交事务
COMMIT;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.回滚事务&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 回滚事务
ROLLBACK;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.设置保存点&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 设置保存点
SAVEPOINT savepoint_name;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.回滚到保存点&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 回滚到保存点 
ROLLBACK TO SAVEPOINT savepoint_name;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.释放保存点&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt; -- 释放保存点
RELEASE SAVEPOINT savepoint_name;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql常用函数</title><link>https://rjomg-blog.pages.dev/posts/wp-1940/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1940/</guid><pubDate>Mon, 05 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：常用函数的用法&lt;/p&gt;
&lt;h2&gt;字符串函数&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;CONCAT(str1, str2, ...)：将多个字符串连接在一起。&lt;/li&gt;
&lt;li&gt;CONCAT_WS(separator,str1,str2,…):用指定的分割符separator连接字符串&lt;/li&gt;
&lt;li&gt;LEFT(str,len)/RIGHT(str,len):从字符串左/右边起，返回len长度的子字符串&lt;/li&gt;
&lt;li&gt;SUBSTRING(str, start, length): 返回字符串的子串。&lt;/li&gt;
&lt;li&gt;SUBSTRING_INDEX(str,delim,count):返回字符串str按delim分割的前count个字符串&lt;/li&gt;
&lt;li&gt;UPPER(str): 将字符串转换为大写。&lt;/li&gt;
&lt;li&gt;LOWER(str): 将字符串转换为小写。&lt;/li&gt;
&lt;li&gt;REPLACE(str, search, replace): 替换字符串中的子串。&lt;/li&gt;
&lt;li&gt;LENGTH(str):返回字节个数&lt;/li&gt;
&lt;li&gt;CHAR_LENGTH(str):返回字符个数&lt;/li&gt;
&lt;li&gt;FORMAT(X,D):将数字X格式化为&apos;#,###,###.##&apos;,并舍入到D位小数&lt;/li&gt;
&lt;li&gt;LOCATE(substr,str,pos):在字符串中返回子串substr第一次出现的位置&lt;/li&gt;
&lt;li&gt;TRIM([remstr FROM] str):从字符串两端删除不需要的字符remstr&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;1.CONCAT&lt;/h3&gt;
&lt;p&gt;CONCAT(str1, str2, ...)：将多个字符串连接在一起。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- CONCAT函数
SELECT CONCAT(&apos;Hello&apos;, &apos; &apos;, &apos;World&apos;) AS result;

输出结果：Hello World
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.CONCAT_WS&lt;/h3&gt;
&lt;p&gt;CONCAT_WS(separator,str1,str2,…):用指定的分割符separator连接字符串。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- CONCAT_WS函数
SELECT CONCAT_WS(&apos;,&apos;,&apos;张三&apos;,&apos;李四&apos;) AS result;

输出结果：张三,李四
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.LEFT/RIGHT&lt;/h3&gt;
&lt;p&gt;LEFT(str,len)/RIGHT(str,len):从字符串左/右边起，返回len长度的子字符串&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- LEFT函数
SELECT LEFT(&apos;www.rjomg.com&apos;,3) AS result;

输出结果：www

 -- RIGHT函数
SELECT RIGHT(&apos;www.rjomg.com&apos;,3) AS result;

输出结果：com
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.SUBSTRING&lt;/h3&gt;
&lt;p&gt;SUBSTRING(str, start, length): 返回字符串的子串。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- SUBSTRING函数
SELECT SUBSTRING(&apos;Hello World&apos;, 7, 5) AS result;

输出结果：World
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.SUBSTRING_INDEX&lt;/h3&gt;
&lt;p&gt;SUBSTRING_INDEX(str,delim,count):返回字符串str按delim分割的前count个字符串&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- SUBSTRING_INDEX函数
SELECT SUBSTRING_INDEX(&apos;www.rjomg.com&apos;,&apos;.&apos;,-2) AS result;

输出结果：rjomg.com
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.UPPER&lt;/h3&gt;
&lt;p&gt;UPPER(str): 将字符串转换为大写。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- UPPER函数
SELECT UPPER(&apos;hello&apos;) AS result;

输出结果：HELLO
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;7.LOWER&lt;/h3&gt;
&lt;p&gt;LOWER(str): 将字符串转换为小写。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- LOWER函数
SELECT LOWER(&apos;WORLD&apos;) AS result;

输出结果：world
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8.REPLACE&lt;/h3&gt;
&lt;p&gt;REPLACE(str, search, replace): 替换字符串中的子串。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- REPLACE函数
SELECT REPLACE(&apos;Hello World&apos;, &apos;World&apos;, &apos;Universe&apos;) AS result;

输出结果：Hello Universe
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9.LENGTH&lt;/h3&gt;
&lt;p&gt;LENGTH(str):返回字节个数&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- LENGTH函数
SELECT LENGTH(&apos;数据库&apos;) AS result;

输出结果：9
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;10.CHAR_LENGTH&lt;/h3&gt;
&lt;p&gt;CHAR_LENGTH(str):返回字符个数&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- CHAR_LENGTH函数
SELECT CHAR_LENGTH(&apos;数据库&apos;) AS result;

输出结果：3
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;11.FORMAT&lt;/h3&gt;
&lt;p&gt;FORMAT(X,D):将数字X格式化为&apos;#,###,###.##&apos;,并舍入到D位小数&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- FORMAT函数
SELECT FORMAT(&apos;1234567.789&apos;,4) AS result;

输出结果：1,234,567.7890
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;12.LOCATE&lt;/h3&gt;
&lt;p&gt;LOCATE(substr,str,pos):在字符串中返回子串substr第一次出现的位置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- LOCATE函数
SELECT LOCATE(&apos;mysql常用函数-12.LOCATE&apos;) AS result;

输出结果：10

-- 配合SUBSTRING
SELECT SUBSTRING(&apos;mysql常用函数-12.LOCATE&apos;, 1, LOCATE(&apos;-&apos;,&apos;mysql常用函数-12.LOCATE&apos;))  AS result;

输出结果：mysql常用函数-

-- 配合SUBSTRING并且在LOCATE函数后加了-1
SELECT SUBSTRING(&apos;mysql常用函数-12.LOCATE&apos;, 1, LOCATE(&apos;-&apos;,&apos;mysql常用函数-12.LOCATE&apos;)-1)  AS result;

输出结果：mysql常用函数
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;13.TRIM&lt;/h3&gt;
&lt;p&gt;TRIM([remstr FROM] str)&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- TRIM函数
SELECT TRIM(&apos;    tempstr    &apos;)  AS result;

输出结果：tempstr

-- 删除字符串里面x字符
SELECT TRIM(&apos;x&apos; FROM &apos;xxxxtempstrxxxx&apos;)  AS result;

输出结果：tempstr
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;数值函数&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;ABS(x): 返回一个数的绝对值。&lt;/li&gt;
&lt;li&gt;ROUND(x, d): 将数值进行四舍五入。&lt;/li&gt;
&lt;li&gt;CEIL(x): 返回不小于给定数的最小整数。&lt;/li&gt;
&lt;li&gt;FLOOR(x): 返回不大于给定数的最大整数。&lt;/li&gt;
&lt;li&gt;RAND(): 返回一个0到1之间的随机数。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;1.ABS&lt;/h3&gt;
&lt;p&gt;ABS(x): 返回一个数的绝对值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- ABS函数
SELECT ABS(-5) AS result;

输出结果：5
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.ROUND&lt;/h3&gt;
&lt;p&gt;ROUND(x, d): 将数值进行四舍五入。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- ROUND函数
SELECT ROUND(3.14159, 2) AS result;

输出结果：3.14
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.CEIL&lt;/h3&gt;
&lt;p&gt;CEIL(x): 返回不小于给定数的最小整数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- CEIL函数
SELECT CEIL(4.2) AS result;

输出结果：5
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.FLOOR&lt;/h3&gt;
&lt;p&gt;FLOOR(x): 返回不大于给定数的最大整数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- FLOOR函数
SELECT FLOOR(4.8) AS result;

输出结果：4
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.RAND&lt;/h3&gt;
&lt;p&gt;RAND(): 返回一个0到1之间的随机数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- RAND函数
SELECT RAND() AS result;

输出结果：随机生成的一个介于0和1之间的数。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;日期和时间函数&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;NOW(): 返回当前日期和时间。&lt;/li&gt;
&lt;li&gt;DATE_FORMAT(date, format): 将日期格式化为指定的格式。&lt;/li&gt;
&lt;li&gt;DATE_ADD(date, INTERVAL expr unit): 在日期上进行加法运算。&lt;/li&gt;
&lt;li&gt;DATE_SUB(date, INTERVAL expr unit): 在日期上进行减法运算。&lt;/li&gt;
&lt;li&gt;DATEDIFF(date1, date2): 计算两个日期之间的天数差。&lt;/li&gt;
&lt;li&gt;CURDATE():返回当前日期/CURTIM():返回当前时间&lt;/li&gt;
&lt;li&gt;SEC_TO_TIME(seconds):把秒转换为时：分：秒&lt;/li&gt;
&lt;li&gt;TIME_TO_SEC(time):把时间转换成秒&lt;/li&gt;
&lt;li&gt;EXTRACT(unit FROM date):返回日期DATE指定部分&lt;/li&gt;
&lt;li&gt;UNIX_TIMESTAMP():返回UNIX时间戳&lt;/li&gt;
&lt;li&gt;FROM_UNIXTIME():把UNIX时间戳转换为日期时间&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;1.NOW&lt;/h3&gt;
&lt;p&gt;NOW(): 返回当前日期和时间。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- NOW函数
SELECT NOW() AS result;

输出结果：当前日期和时间的值。
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.DATE_FORMAT&lt;/h3&gt;
&lt;p&gt;DATE_FORMAT(date, format): 将日期格式化为指定的格式。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- DATE_FORMAT函数
SELECT DATE_FORMAT(&apos;2023-06-15&apos;, &apos;%Y-%m-%d&apos;) AS result;

输出结果：2023-06-15
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;DATE_FORMAT(date,format) 该函数的format：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;%Y：四位数的年份（例如：2023）&lt;/li&gt;
&lt;li&gt;%y：两位数的年份（例如：23）&lt;/li&gt;
&lt;li&gt;%m：两位数的月份（例如：01表示一月）&lt;/li&gt;
&lt;li&gt;%d：两位数的日期（例如：01表示第一天）&lt;/li&gt;
&lt;li&gt;%H：小时（00-23）&lt;/li&gt;
&lt;li&gt;%i：分钟（00-59）&lt;/li&gt;
&lt;li&gt;%s：秒（00-59）&lt;/li&gt;
&lt;li&gt;%W：星期的完整名称（例如：Monday）&lt;/li&gt;
&lt;li&gt;%w：星期的数字表示（0表示周日，1表示周一，依此类推）&lt;/li&gt;
&lt;li&gt;%M：月份的完整名称（例如：January）&lt;/li&gt;
&lt;li&gt;%b：月份的缩写（例如：Jan）&lt;/li&gt;
&lt;li&gt;%D：日期的序数词表示（例如：1st、2nd、3rd）&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3.DATE_ADD&lt;/h3&gt;
&lt;p&gt;DATE_ADD(date, INTERVAL expr unit): 在日期上进行加法运算。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- DATE_ADD函数
SELECT DATE_ADD(&apos;2023-06-15&apos;, INTERVAL 7 DAY) AS result;

输出结果：2023-06-22
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.DATE_SUB&lt;/h3&gt;
&lt;p&gt;DATE_SUB(date, INTERVAL expr unit): 在日期上进行减法运算。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- DATE_SUB函数
SELECT DATE_SUB(&apos;2023-06-15&apos;, INTERVAL 1 MONTH) AS result;

输出结果：2023-05-15
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.DATEDIFF&lt;/h3&gt;
&lt;p&gt;DATEDIFF(date1, date2): 计算两个日期之间的天数差。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- DATEDIFF函数
SELECT DATEDIFF(&apos;2023-06-15&apos;, &apos;2023-05-31&apos;) AS result;

输出结果：15
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.CURDATE/CURTIME&lt;/h3&gt;
&lt;p&gt;CURDATE():返回当前日期&lt;/p&gt;
&lt;p&gt;CURTIME():返回当前时间&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- CURDATE函数
SELECT CURDATE() AS result;

输出结果：2023-05-15

 -- CURTIME函数
SELECT CURTIME() AS result;

输出结果：03:12:21
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;7.SEC_TO_TIME&lt;/h3&gt;
&lt;p&gt;SEC_TO_TIME(seconds):把秒转换为时：分：秒&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- SEC_TO_TIME函数
SELECT SEC_TO_TIME(&apos;&apos;) AS result;

输出结果：01:00:00
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8.TIME_TO_SEC&lt;/h3&gt;
&lt;p&gt;TIME_TO_SEC(time):把时间转换成秒&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- TIME_TO_SEC函数
SELECT TIME_TO_SEC(&apos;01:00:00&apos;) AS result;

输出结果：3600
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9.EXTRACT&lt;/h3&gt;
&lt;p&gt;EXTRACT(unit FROM date):返回日期DATE指定部分&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- EXTRACT函数
SELECT EXTRACT(YEAR FROM NOW())  result;

输出结果：2023
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;10.UNIX_TIMESTAMP&lt;/h3&gt;
&lt;p&gt;UNIX_TIMESTAMP():返回UNIX时间戳&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- UNIX_TIMESTAMP函数
SELECT UNIX_TIMESTAMP() AS result;

输出结果：1685950799
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;11.FROM_UNIXTIME&lt;/h3&gt;
&lt;p&gt;FROM_UNIXTIME():把UNIX时间戳转换为日期时间&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- FROM_TIMESTAMP函数
SELECT FROM_UNIXTIME(&apos;1685950799&apos;) AS result;

输出结果：2023-06-05 15:39:59.000000
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;条件函数&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;IF(expr, true_value, false_value): 如果表达式为真，则返回true_value，否则返回false_value。&lt;/li&gt;
&lt;li&gt;CASE WHEN condition THEN result ELSE else_result END: 根据条件进行选择性的返回结果。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;1.IF&lt;/h3&gt;
&lt;p&gt;IF(expr, true_value, false_value): 如果表达式为真，则返回true_value，否则返回false_value。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- IF函数
SELECT IF(10 &amp;gt; 5, &apos;True&apos;, &apos;False&apos;) AS result;

输出结果：True
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.CASE WHEN&lt;/h3&gt;
&lt;p&gt;CASE WHEN condition THEN result ELSE else_result END: 根据条件进行选择性的返回结果。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- CASE WHEN函数
SELECT CASE WHEN score &amp;gt;= 90 THEN &apos;A&apos; WHEN score &amp;gt;= 80 THEN &apos;B&apos; ELSE &apos;C&apos; END AS result FROM students;

根据学生的分数，返回对应的等级。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;聚合函数&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;SUM(column): 计算指定列的总和。&lt;/li&gt;
&lt;li&gt;AVG(column): 计算指定列的平均值。&lt;/li&gt;
&lt;li&gt;COUNT(column): 计算指定列的非NULL值的数量。&lt;/li&gt;
&lt;li&gt;MAX(column): 返回指定列的最大值。&lt;/li&gt;
&lt;li&gt;MIN(column): 返回指定列的最小值。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;1.SUM&lt;/h3&gt;
&lt;p&gt;SUM(column): 计算指定列的总和。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- SUM函数
SELECT SUM(sales) AS result FROM orders;

输出结果：指定列的总和。
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.AVG&lt;/h3&gt;
&lt;p&gt;AVG(column): 计算指定列的平均值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- AVG函数
SELECT AVG(price) AS result FROM products;

输出结果：指定列的平均值。
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.COUNT&lt;/h3&gt;
&lt;p&gt;COUNT(column): 计算指定列的非NULL值的数量。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- COUNT函数
SELECT COUNT(*) AS result FROM customers;

输出结果：指定列的非NULL值的数量。
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.MAX&lt;/h3&gt;
&lt;p&gt;MAX(column): 返回指定列的最大值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- MAX函数
SELECT MAX(age) AS result FROM users;

输出结果：指定列的最大值。
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5.MIN&lt;/h3&gt;
&lt;p&gt;MIN(column): 返回指定列的最小值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- MIN函数
示例：SELECT MIN(age) AS result FROM users;

输出结果：指定列的最小值。
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql设计范式和物理设计建议</title><link>https://rjomg-blog.pages.dev/posts/wp-1796/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1796/</guid><pubDate>Thu, 01 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是设计范式，设计范式有那几种&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;设计范式&lt;/h2&gt;
&lt;p&gt;在关系数据库中，范式是用于规范化数据库设计的一组原则。它们旨在减少数据冗余、提高数据一致性和减少数据更新异常。MySQL数据库可以按照范式设计，常见的范式包括第一范式（1NF）、第二范式（2NF）、第三范式（3NF）和BC范式（BCNF）。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第一范式（1NF）&lt;/h2&gt;
&lt;p&gt;确保每个表中的每一列都是原子的，不可再分的。表中的每个字段应该只包含单一的数据值，而不是重复的数据集合。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第二范式（2NF）&lt;/h2&gt;
&lt;p&gt;在满足1NF的基础上，确保表中的非主键字段完全依赖于整个主键，而不是部分依赖于主键。换句话说，每个非主键字段必须直接依赖于整个主键。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第三范式（3NF）&lt;/h2&gt;
&lt;p&gt;在满足2NF的基础上，确保表中的非主键字段不依赖于其他非主键字段。换句话说，表中的每个非主键字段只应该依赖于主键或其他唯一键。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;BC范式（BCNF）&lt;/h2&gt;
&lt;p&gt;在满足3NF的基础上，进一步消除主键和非主键之间的依赖关系。表中的每个非主键字段都不应该依赖于其他非主键字段，而是完全依赖于主键。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;范式化设计的优缺点&lt;/h2&gt;
&lt;h3&gt;优点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;减少冗余&lt;/li&gt;
&lt;li&gt;减少数据的插入、更新、删除异常&lt;/li&gt;
&lt;li&gt;让数据的关系之间更清晰明了&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;缺点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;查询需要关联多个表&lt;/li&gt;
&lt;li&gt;对查询性能有一定影响&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;反范式化设计&lt;/h2&gt;
&lt;p&gt;反范式化（Denormalization）是在数据库设计中的一种技术，旨在提高查询性能和简化复杂查询操作。它违反了范式化的原则，通过增加冗余数据来优化读取操作的性能。在MySQL中，可以使用反范式化设计来满足特定的业务需求，尤其是对于大型数据集或复杂查询场景。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;冗余数据：通过将相关数据复制到其他表中，避免了频繁的表关联操作，从而提高查询性能。例如，将某个实体的属性冗余到其他表中，避免多表关联查询。&lt;/li&gt;
&lt;li&gt;聚合数据：将多个关联表的数据聚合到一个表中，以减少关联查询的复杂性。例如，将多个子表中的数据聚合到一个父表中，以简化复杂的查询操作。&lt;/li&gt;
&lt;li&gt;范式化设计和反范式化设计都需要把握一个度，在效率和少量数据冗余之间平衡选择&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;物理设计建议&lt;/h2&gt;
&lt;h3&gt;库和表&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;所有数据库对象名称必须使用小写字母可选用下划线分隔。&lt;/li&gt;
&lt;li&gt;所有数据库对象名称定义禁止使用MySQL保留关键字。&lt;/li&gt;
&lt;li&gt;数据库队形的命名要能做到见名识义，并且最好不超过32个字。&lt;/li&gt;
&lt;li&gt;临时表必须以tmp为前缀并以日期为后缀。&lt;/li&gt;
&lt;li&gt;用于备份的库、表必须以bak为前缀并以日期为后缀。&lt;/li&gt;
&lt;li&gt;所有存储相同数据的列名和列类型必须一致。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;字段类型&lt;/h3&gt;
&lt;p&gt;字段类型的设计尽量贴合需求：&lt;a href=&quot;https://www.rjomg.com/2023/06/01/1814/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;链接&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/p&gt;
</content:encoded></item><item><title>Mysql字段类型</title><link>https://rjomg-blog.pages.dev/posts/wp-1814/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1814/</guid><pubDate>Thu, 01 Jun 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：mysql分别有哪些类型，每个类型分别怎么使用&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;整数类型&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/常用的int类型-1.png&quot; class=&quot;wp-image-1823&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h2&gt;浮点类型&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/常用浮点-1.png&quot; class=&quot;wp-image-1824&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;123456789.987654321 这个浮点数，在DECIMAL下面占用了9个字节，小数点前面1~9占用4个字节，小数点占用1个字节，小数点后9~1占用4个字节&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;123456789.987654321 = decimal(18,9) 占用9个字节&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;时间类型&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/时间类型.png&quot; class=&quot;wp-image-1829&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;TIME类型、DATATIME类型、TIMESTAMP类型存储空间字节长度根据微秒值长度决定。&lt;/p&gt;
&lt;h2&gt;字符串类型&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/字符串类型.png&quot; class=&quot;wp-image-1832&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>Mysql 宽表模式</title><link>https://rjomg-blog.pages.dev/posts/wp-1777/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1777/</guid><pubDate>Wed, 31 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是宽表模式，宽表模式的优劣&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;宽表&lt;/h2&gt;
&lt;p&gt;在数据库中，宽表（Wide Table）是指包含大量列的表。相比于传统的关系型数据库设计中的窄表（Narrow Table），宽表具有更多的列。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;应用场景&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;配合列存储数据表表应用（基本不会遇上缺点中的问题）&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;优势&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;查询性能提升：宽表可以减少表关联操作的次数，从而减少查询的复杂性和提高查询性能。&lt;/li&gt;
&lt;li&gt;简化数据模型：宽表可以将相关数据聚合在一张表中，简化数据模型和查询逻辑，提高开发和维护效率。&lt;/li&gt;
&lt;li&gt;减少表关联操作：宽表可以避免频繁的表关联操作，降低系统开销和数据库负载。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;缺点&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;数据插入异常：部分数据由于缺失主键信息而无法写入表中&lt;/li&gt;
&lt;li&gt;数据更新异常：修改一行中某列的值时，同时修改了多行数据&lt;/li&gt;
&lt;li&gt;数据删除异常：删除某一数据时不得不删除另一数据&lt;/li&gt;
&lt;li&gt;数据冗余：相同的数据在一个表中出现多次，需要在设计时权衡数据冗余和数据一致性。&lt;/li&gt;
&lt;li&gt;表设计和维护复杂性：宽表的设计和维护可能更加复杂，因为需要考虑更多的列和相关的数据处理逻辑。&lt;/li&gt;
&lt;li&gt;数据增长：宽表可能在数据增长时变得庞大，需要合理规划和管理存储空间。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql ACID</title><link>https://rjomg-blog.pages.dev/posts/wp-1759/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1759/</guid><pubDate>Wed, 31 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是ACID&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是ACID&lt;/h2&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;ACID（原子性、一致性、隔离性和持久性）是关系型数据库管理系统（RDBMS）中的一组特性，用于确保数据的可靠性和一致性。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;原子性（Atomicity）&lt;/li&gt;
&lt;li&gt;一致性（Consistency）&lt;/li&gt;
&lt;li&gt;隔离性（Isolation）&lt;/li&gt;
&lt;li&gt;持久性（Durability）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;原子性（Atomicity）&lt;/h2&gt;
&lt;p&gt;指一个事务（Transaction）被视为一个不可分割的操作单元，要么全部执行成功，要么全部回滚。如果事务的所有操作成功执行，那么更改将被永久保存，否则，所有更改都将被回滚，不会对数据库产生影响。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;一致性（Consistency）&lt;/h2&gt;
&lt;p&gt;指在事务开始之前和结束之后，数据库必须保持一致的状态。这意味着事务的操作将使数据库从一个一致的状态转变为另一个一致的状态，即满足预定义的一致性规则。如果事务执行失败或违反了一致性规则，那么数据库将回滚到事务开始之前的状态。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;隔离性（Isolation）&lt;/h2&gt;
&lt;p&gt;指多个并发事务在同时执行时，每个事务都被隔离并且相互独立地执行，就像它是唯一在系统中运行的事务一样。隔离性确保了事务之间的相互隔离，防止并发事务之间产生不一致的结果。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;持久性（Durability）&lt;/h2&gt;
&lt;p&gt;指一旦事务提交成功，对数据库的更改将是永久的，并且将在系统故障或重启后仍然存在。持久性通过将事务的更改写入磁盘存储介质（如硬盘）来保证数据的持久性，以防止数据丢失。&lt;/p&gt;
</content:encoded></item><item><title>Mysql主从切换策略</title><link>https://rjomg-blog.pages.dev/posts/wp-1724/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1724/</guid><pubDate>Mon, 29 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：可靠优先和可用性优先&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;可靠优先策略&lt;/h2&gt;
&lt;h3&gt;策略&lt;/h3&gt;
&lt;p&gt;一主一从：A主库 B从库&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;通过在B库运行&lt;code&gt;SHOW SLAVE STATUS \G；&lt;/code&gt;查看Seconds_Behind_Master，不能过大&lt;/li&gt;
&lt;li&gt;设置A库只读，read-only = true&lt;/li&gt;
&lt;li&gt;检测B库，只要Seconds_Behind_Master = 0则代表从库已经追上了主库&lt;/li&gt;
&lt;li&gt;B库只读关闭，read-only = false&lt;/li&gt;
&lt;li&gt;B库停止复制A库，设置A库复制B库 （具体设置方法可以看：&lt;a href=&quot;https://www.rjomg.com/2023/05/13/1547/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主从配置&amp;lt;/mark&amp;gt;&lt;/a&gt;）&lt;/li&gt;
&lt;li&gt;结果：A从 B主&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;优劣&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;数据不会丢失&lt;/li&gt;
&lt;li&gt;有几秒（Seconds_Behind_Master这个字段决定）两个数据库均不能写入&lt;/li&gt;
&lt;li&gt;若一开始为检测Seconds_Behind_Master，不可用时间无法控制&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;可用性优先策略&lt;/h2&gt;
&lt;h3&gt;策略&lt;/h3&gt;
&lt;p&gt;一主一从：A主库 B从库&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;取消等待数据同步一致的过程&lt;/li&gt;
&lt;li&gt;A库只读，B库关闭只读&lt;/li&gt;
&lt;li&gt;B库停止复制A库，设置A库复制B库&lt;/li&gt;
&lt;li&gt;结果：A从 B主 （未同步的数据丢失）&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;优劣&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;系统没有不可写时间&lt;/li&gt;
&lt;li&gt;若切换时还有没重放完的relay log，造成数据不一致错误&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;切换后业务怎么自动切换&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;最基础的就是修改框架下面的配置文件&lt;/li&gt;
&lt;li&gt;搭建内部DNS（CoreDNS），通过&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;域名链接&amp;lt;/mark&amp;gt;，实现自动切换&lt;/li&gt;
&lt;li&gt;使用VIP漂移（Keepalived），&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;IP不变&amp;lt;/mark&amp;gt;，也不需要使用域名，自动检测数据库IP，根据”活“和优先级自动切换&lt;/li&gt;
&lt;li&gt;使用代理自动探测或者手动修改，自动转发到新库的ip&lt;/li&gt;
&lt;li&gt;MHA&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;总结&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;普通业务执行，尽量使用可靠优先策略&lt;/li&gt;
&lt;li&gt;日志、流水等不太需要数据可靠性的业务，可以使用可用优先策略&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql分表（Server层上的）</title><link>https://rjomg-blog.pages.dev/posts/wp-1686/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1686/</guid><pubDate>Sat, 27 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是分表，怎么分表&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是分表&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;垂直分表：按照字段分表，一般分为冷和热&lt;/li&gt;
&lt;li&gt;水平分表：按照行分表，常用范围分表、Hash切分&lt;/li&gt;
&lt;li&gt;水平分表类似于分区表，但是Server层也进行了分表。（&lt;a href=&quot;https://www.rjomg.com/2023/05/16/1656/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;分区表&amp;lt;/mark&amp;gt;&lt;/a&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;什么是分库&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;垂直分库：将数据表分散在多个数据库或者多个节点中&lt;/li&gt;
&lt;li&gt;水平分库：将所有表水平拆分，每个数据库结构相同&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;分库分表的优劣&lt;/h2&gt;
&lt;h3&gt;优点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;增加隔离性&lt;/li&gt;
&lt;li&gt;提升容量与并发性能&lt;/li&gt;
&lt;li&gt;水平分表类似于分区表，但Sever层也分了&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;缺点&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;部分失效可能性成倍增加（某个冷表数据库宕机，直接全部不能使用）&lt;/li&gt;
&lt;li&gt;无法会用单点事务（没办法同时锁库锁表）&lt;/li&gt;
&lt;li&gt;垂直切分后无法JOIN链接&lt;/li&gt;
&lt;li&gt;范围查询更加困难&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;缺点的解决方式&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;特殊业务特殊处理&lt;/li&gt;
&lt;li&gt;使用mysql分库分表中间件（Mycat、Dble等）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;使用了分库分表反而更慢了怎么办？&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;例如使用时间分片：查询语句中尽可能的带有拆分的关键词（时间节点）&lt;/li&gt;
&lt;li&gt;精简IN查询&lt;/li&gt;
&lt;li&gt;DISTINCT、GROUP BY、 ORDER BY 尽量一条sql只有一个&lt;/li&gt;
&lt;li&gt;经常需要JOIN的表，按照相同的规则，放在同一个库里面&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>Mysql分区表</title><link>https://rjomg-blog.pages.dev/posts/wp-1656/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1656/</guid><pubDate>Tue, 16 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是分区表，怎么分区&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是分区表&lt;/h2&gt;
&lt;p&gt;分区表是一种将单个表的数据分布到多个子表（分区）中的方法。每个分区可以单独存储在文件系统中，可以单独备份和恢复，可以单独优化，甚至可以放在不同的硬盘上。在查询 数据时，MySQL 只需要访问包含所需数据的分区，从而提高查询效率。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;请注意，分区表并不总是提高性能，而且它会增加数据库的复杂性。在决定使用分区表之前，你需要充分考虑你的数据量、查询模式和硬件环境。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;将INNODB的一个表分成多个表&lt;/li&gt;
&lt;li&gt;Server层依然当做是一个整体的表&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;范围分区表&lt;/h2&gt;
&lt;p&gt;例如，你可以根据日期字段将数据分配到不同的分区，其中每个分区包含一个特定的日期范围的数据。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;DATA DIRECTORY = /data1：数据目录&lt;/li&gt;
&lt;li&gt;INDEX DIRECTORY = /data2：索引目录&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt; -- 范围分区
CREATE TABLE orders (
    id INT NOT NULL,
    order_date DATE NOT NULL
)
PARTITION BY RANGE( YEAR(order_date) ) (
    PARTITION p0 VALUES LESS THAN (1990),
    PARTITION p1 VALUES LESS THAN (2000),
    PARTITION p2 VALUES LESS THAN (2010),
    PARTITION p3 VALUES LESS THAN (2020),
    PARTITION p4 VALUES LESS THAN MAXVALUE
);
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Hash分区&lt;/h2&gt;
&lt;p&gt;这种类型的分区基于某个列的哈希值来进行。哈希分区可以将数据均匀地分布到多个分区，这对于负载均衡特别有用。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- Hash分区
CREATE TABLE orders (
    id INT NOT NULL,
    order_date DATE NOT NULL
)
PARTITION BY HASH( MONTH(order_date) )
PARTITIONS 12;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;&lt;strong&gt;列表分区&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;这种类型的分区基于某个列的离散值来进行。你可以为每个分区指定一个或多个值，当插入一条新的记录时，MySQL会将其存储在包含其列值的分区。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- Hash分区
CREATE TABLE employees (
    id INT NOT NULL,
    city VARCHAR(50)
)
PARTITION BY LIST (city) (
    PARTITION p0 VALUES IN (&apos;New York&apos;, &apos;Boston&apos;),
    PARTITION p1 VALUES IN (&apos;San Francisco&apos;, &apos;Los Angeles&apos;),
    PARTITION p2 VALUES IN (&apos;Chicago&apos;, &apos;Houston&apos;)
);
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;总结&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;分区表可以优化单节点容量、增强分区之间的隔离&lt;/li&gt;
&lt;li&gt;第一次访问需要打开所有的ibd文件，数量越多，操作系统会越卡，可能会达到打开文件的上限&lt;/li&gt;
&lt;li&gt;可以通过存储在不同的硬盘上提高容量&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>Mysql备库延迟太大，怎么办？</title><link>https://rjomg-blog.pages.dev/posts/wp-1612/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1612/</guid><pubDate>Mon, 15 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么导致备库延迟，怎么解决备库延迟问题&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;备库延迟的原因&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;binlog传送开销较小，主要是备库消费relaylog耗时比较多&lt;/li&gt;
&lt;li&gt;备库的性能不如主库&lt;/li&gt;
&lt;li&gt;备库承担了很多分析的SQL（例如：备库做数据分析，数据统计）&lt;/li&gt;
&lt;li&gt;主库的长事务未提交&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主库是多线程、多用户并发的处理数据，备库是单线程单用户（主要原因）&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;处理方法&lt;/h2&gt;
&lt;h3&gt;基本处理方法&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;主备使用相同配置的机器（时刻准备顶替主库的备库，理应使用相同配置）&lt;/li&gt;
&lt;li&gt;备库关闭log实时落盘&lt;/li&gt;
&lt;li&gt;增加从库的数量，分析的SQL、定时任务尽量在业务低峰运行&lt;/li&gt;
&lt;li&gt;binlog传送至大数据分析系统，不要选用mysql，选用转门分析的数据库&lt;/li&gt;
&lt;li&gt;长事务，拆分成多个小事务，拆分的去提交事务&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;从库并行复制方法&lt;/h3&gt;
&lt;p&gt;该方法是5.6引入的&lt;/p&gt;
&lt;p&gt;mysql5.6使用按库并行策略&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;优点：分发选择快，支持各种log格式&lt;/li&gt;
&lt;li&gt;缺点：按库分发粒度太大了，很难负载平衡&lt;/li&gt;
&lt;li&gt;开启方式：slave-parallel-type = DATABASE&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;mysql5.7使用按事务组并行策略&lt;/p&gt;
&lt;p&gt;备库可以同时应用多个事务，只要这些事务在主库上是独立的（也就是说，它们不会相互冲突）&lt;/p&gt;
&lt;p&gt;事务组并行策略&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;同时处于prepare状态的事务，在备库执行时是可以并行的&lt;/li&gt;
&lt;li&gt;开启方式：slave-parallel-type = LOGICAL_CLOCK&lt;/li&gt;
&lt;li&gt;binlog_group_commit_sync_delay：延迟多少微妙后才调用fsync&lt;/li&gt;
&lt;li&gt;binlog_group_commit_sync_no_delay_count：累积多少次以后才调用fsync&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;5.7.22新参数&lt;/p&gt;
&lt;p&gt;binlog-transaction-dependency-tracking参数：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;COMMIT_ORDER：按事务组并行（5.7）&lt;/li&gt;
&lt;li&gt;WRITESET：没有修改相同行的事务可以并行&lt;/li&gt;
&lt;li&gt;WRITESET_SESSION：同一个线程先后执行的两个事务不能并行&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;怎么样才能读到最新的数据&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;强制实时性强的业务，敏感业务，读主库&lt;/li&gt;
&lt;li&gt;在前端业务增加读取进度条，按照备库延迟的时间去按需增加&lt;/li&gt;
&lt;li&gt;对比binlog执行位点&lt;/li&gt;
&lt;li&gt;对比GTID执行的情况&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;理论上来讲从库的延迟是无法被消灭的。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- 等待binlog位点
select master_pos_wait(file, pos[, timeout]);

-- 等待GTID（5.7.6之后可以返回每次事务的GTID）
select wait_for_executed_gtid_set(gtid_set, 1);
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql的Binlog格式</title><link>https://rjomg-blog.pages.dev/posts/wp-1567/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1567/</guid><pubDate>Sun, 14 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：binlog的格式有哪几种？分别用来干什么&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;Binlog的三种格式&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;Statement（基于语句的格式）&lt;/li&gt;
&lt;li&gt;Row（基于行的格式）&lt;/li&gt;
&lt;li&gt;Mixed（混合格式）&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;Statement（&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;基于语句的格式&amp;lt;/mark&amp;gt;）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;5.0之前默认使用Statement格式的binlog&lt;/li&gt;
&lt;li&gt;Statement的binlog记录的是SQL语句原文（基于语句的格式）&lt;/li&gt;
&lt;li&gt;由于主备库对于SQL同一个语句，执行效果不一致，可能有数据安全风险&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Row（&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;基于行的格式&amp;lt;/mark&amp;gt;）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;不记录SQL语句原文&lt;/li&gt;
&lt;li&gt;记录数据行的变化（基于行的格式）&lt;/li&gt;
&lt;li&gt;不是物理日志，还是逻辑日志&lt;/li&gt;
&lt;li&gt;占用的空间比较大&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;后期运维，可恢复性，可操作性更高，推荐直接使用ROW格式&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Mixed（&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;混合格式&amp;lt;/mark&amp;gt;）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;两种格式混合使用&lt;/li&gt;
&lt;li&gt;有数据风险的语句使用ROW&lt;/li&gt;
&lt;li&gt;无风险的使用Statement&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql的InnoDB逻辑存储结构</title><link>https://rjomg-blog.pages.dev/posts/wp-1589/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1589/</guid><pubDate>Sun, 14 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：InnoDB逻辑存储结构是怎么样的&lt;/p&gt;
&lt;h2&gt;逻辑存储结构&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/05/INNODB逻辑存储结构.png&quot; class=&quot;wp-image-1592&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;表空间（tablespace）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;表空间指的是数据表在硬盘上的存储空间&lt;/li&gt;
&lt;li&gt;mysql5.6默认，所有数据表都在一个共享表空间，可设置为单独表空间。&lt;/li&gt;
&lt;li&gt;mysql8.0默认，每个数据表都有单独表空间空间（ibd文件）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;段（segment）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;段默认是128MB&lt;/li&gt;
&lt;li&gt;数据段：B+树的叶子节点&lt;/li&gt;
&lt;li&gt;索引段：B+树的非叶子节点&lt;/li&gt;
&lt;li&gt;INNODB中，段由存储引擎自动管理&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;区（extent）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;区是由连续页组成的空间，每个区大小为1MB&lt;/li&gt;
&lt;li&gt;一次从磁盘申请4~5个区&lt;/li&gt;
&lt;li&gt;一般来讲含有64个页（page）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;页（page）&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;页是INNODB中磁盘读写的最小逻辑单位，页默认是16KB&lt;/li&gt;
&lt;li&gt;一个数据页就是一个B+树的节点（B+ Tree Node）&lt;/li&gt;
&lt;li&gt;为了硬盘的读写效率和便利，页的大小是充分考虑了机械硬盘盒SSD的最小单元（512B和4KB）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;总结&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;INNODB的逻辑存储结构为表空间、段、区、页、行&lt;/li&gt;
&lt;li&gt;INNODB的逻辑存储结构充分考虑了基于B+树的表结构&lt;/li&gt;
&lt;li&gt;INNODB中的也是INNODB自身的逻辑概念，与硬件的页无关&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql高并发、高性能、高可用</title><link>https://rjomg-blog.pages.dev/posts/wp-1352/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1352/</guid><pubDate>Sat, 13 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是“三高”，怎么样达到高并发、高性能、高可用&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是“三高”&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;高并发：通过复制和拓展，将数据分散至多个节点&lt;/li&gt;
&lt;li&gt;高性能：复制提升速度、拓展提升容量&lt;/li&gt;
&lt;li&gt;高可用：节点间身份的切换，保证随时可用&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;主从复制&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://www.rjomg.com/2023/05/13/1547/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql主从配置（一主一从）&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;拓展&lt;/h2&gt;
&lt;p&gt;数据库容量不够怎么办？&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;切换&lt;/h2&gt;
&lt;p&gt;数据库经常宕机怎么办？&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>Mysql主从配置（一主一从）</title><link>https://rjomg-blog.pages.dev/posts/wp-1547/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1547/</guid><pubDate>Sat, 13 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：主从的原理，怎么实现主从&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;主从复制的基本原理&lt;/h2&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/05/复制的基本原理-1.png&quot; class=&quot;wp-image-1370&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;复制的类型&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;异步复制（Asynchronous Replication）&lt;/li&gt;
&lt;li&gt;半同步复制（Semisynchronous Replication）&lt;/li&gt;
&lt;li&gt;组复制（Group Replication）&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;1.异步复制&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;原理简单&lt;/li&gt;
&lt;li&gt;对网络延迟要求比较小&lt;/li&gt;
&lt;li&gt;不保证日志被传送到了备库，可能会丢失数据&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;异步复制的原理&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/05/异步复制.png&quot; class=&quot;wp-image-1379&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h3&gt;2.半同步复制&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;原理简单&lt;/li&gt;
&lt;li&gt;对网络延迟有一定要求，最好在同一机房&lt;/li&gt;
&lt;li&gt;可以保证日志被传送到了备库，不易丢失数据&lt;/li&gt;
&lt;li&gt;rpl_semi_sync_master_timeout 该参数可以设置主从超时时间（默认值：10秒），退化成异步复制（如果备库无法连接，也不会长时间影响主库）&lt;/li&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;半同步是兼顾数据安全与效率的最好选择&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;半同步复制的原理&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/05/半同步复制.png&quot; class=&quot;wp-image-1384&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;h3&gt;3. 组复制&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;原理比较复杂&lt;/li&gt;
&lt;li&gt;需要依赖共识算法&lt;/li&gt;
&lt;li&gt;实际应用比较少&lt;/li&gt;
&lt;li&gt;是数据库走向原生分布式的示范&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;组复制的原理&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/05/组复制.png&quot; class=&quot;wp-image-1392&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;实现一主一从&lt;/h2&gt;
&lt;h3&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;异步复制&amp;lt;/mark&amp;gt;&lt;/h3&gt;
&lt;h4&gt;1.mysql.cnf配置&lt;/h4&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;配置完成后需要重启数据库&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;主库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主库
[mysqld]
secure_file_priv=/home # mysqldump备份后的路径，你可以设置到你想要的目录
server-id = 1 # 配置服务器ID，2个数据库server-id不一致即可
log_bin = /var/lib/mysql/binlog # 开启binlog，目录/var/lib/mysql/就会有binlog.000001这样的文件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
[mysqld]
secure_file_priv=/home # mysqldump备份后的路径，你可以设置到你想要的目录
server-id = 2 # 配置服务器ID，2个数据库server-id不一致即可
log_bin = /var/lib/mysql/binlog # 开启binlog，目录/var/lib/mysql/就会有binlog.000001这样的文件
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.主从数据库配置&lt;/h4&gt;
&lt;p&gt;主库-查看binlog状态，参数用于后续从库同步使用&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主库
-- 查看binlog读取的位置
SHOW MASTER STATUS;
&lt;/code&gt;&lt;/pre&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;File&lt;/td&gt;
&lt;td&gt;Position&lt;/td&gt;
&lt;td&gt;Binlog_Do_DB&lt;/td&gt;
&lt;td&gt;Binlog_Ignore_DB&lt;/td&gt;
&lt;td&gt;Executed_Gtid_Set&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;binlog.000033&lt;/td&gt;
&lt;td&gt;1381&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;主库-全表加读锁，防止binlog备份时被更新&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主库
-- 给主库加上全表读锁
FLUSH TABLES WITH READ LOCK;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;主库-全表备份&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 主库
# mysql5.6给全库备份
mysqldump -uroot -p123456 --all-databases --master-data &amp;gt; dbdump.sql

# mysql8.0给全库备份
mysqldump -uroot -p123456 --all-databases --source-data &amp;gt; dbdump.sql

mysqldump -uroot -p123456 --all-databases --triggers --routines --events  --source-data &amp;gt; dbdump.sql
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;主库-备份完成后，解锁全表&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主库
-- 解锁
UNLOCK TABLES；
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;主库-把主库备份的文件复制到从库&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; # 主库
# 通过scp传输到从库
scp dbdump.sql root@192.ip.0.0:/home/

# 因为我是开发环境用的是docker
docker cp mysql8:/home/dbdump.sql mysql/app/dbdump.sql
docker mysql/app/dbdump.sql mysql8-slave1:/home/dbdump.sql
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库-导入备份数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- 从库还原
source /home/dbdump.sql
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库-查询状态&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- 查询一下从库状态
show slave status;

-- 如果已经配置好,可以停止，再重置（如果没有则不需要重置）
stop slave;
reset slave;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库-配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- 配置从库 mysql5.6
CHANGE MASTER TO
  MASTER_HOST = &apos;&amp;lt;主服务器的主机名&amp;gt;&apos;,
  MASTER_PORT = &amp;lt;主服务器的端口号&amp;gt;,
  MASTER_USER = &apos;&amp;lt;复制账户用户名&amp;gt;&apos;,
  MASTER_PASSWORD = &apos;&amp;lt;复制账户密码&amp;gt;&apos;,
  MASTER_LOG_FILE = &apos;&amp;lt;主服务器的二进制日志文件名&amp;gt;&apos;,
  MASTER_LOG_POS = &amp;lt;主服务器的二进制日志位置&amp;gt;;

-- 示例
CHANGE MASTER TO
  MASTER_HOST = &apos;mysql8&apos;, -- 没有使用docker的填写ip即可
  MASTER_PORT = 3306 ,
  MASTER_USER = &apos;root&apos;,
  MASTER_PASSWORD = &apos;123456&apos;,
  MASTER_LOG_FILE = &apos;binlog.000032&apos;, -- 上面主库查询出来的数据
  MASTER_LOG_POS = 157; -- 上面主库查询出来的数据

-- 示例 mysql8.0
-- GET_MASTER_PUBLIC_KEY=1, 这个是为了绕过SSL/HTTPS错误
CHANGE REPLICATION SOURCE TO
  GET_MASTER_PUBLIC_KEY=1,
  SOURCE_HOST = &apos;mysql8&apos;,
  SOURCE_PORT = 3306 ,
  SOURCE_USER = &apos;root&apos;,
  SOURCE_PASSWORD = &apos;123456&apos;,
  SOURCE_LOG_FILE = &apos;binlog.000032&apos;, -- 上面主库查询出来的数据
  SOURCE_LOG_POS = 157; -- 上面主库查询出来的数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库-开启并查看状态&lt;/p&gt;
&lt;p&gt;均为yes则异步同步开启成功&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Slave_IO_Running: Yes&lt;br /&gt;
Slave_SQL_Running: Yes&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- 开启从库
START SLAVE;

-- 查看从库配置
show slave status \G;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;异步复制（GTID）&amp;lt;/mark&amp;gt;&lt;/h3&gt;
&lt;p&gt;简化了查询binlog步骤和配置写binlog部分&lt;/p&gt;
&lt;h4&gt;GTID（Global Transaction Identifier）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Mysql5.6引入了GTID&lt;/li&gt;
&lt;li&gt;GTID可以给事务分配全局唯一ID&lt;/li&gt;
&lt;li&gt;GTID方便了主从复制的配置，推荐打开&lt;/li&gt;
&lt;li&gt;GTID对主从切换、故障恢复也有很大意义&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;如何启动GTID&lt;/h4&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主从均要设置&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主从库
[mysqld]
secure_file_priv=/home # mysqldump备份后的路径，你可以设置到你想要的目录
server-id = 1 # 配置服务器ID，2个数据库server-id不一致即可
log_bin = /var/lib/mysql/binlog # 开启binlog，目录/var/lib/mysql/就会有binlog.000001这样的文件

# 启动GTID
gtid_mode = no
enforce-gtid-consistency = true

# mysql5.6 半同步复制设置
plugin-load = &quot;rpl_semi_sync_master=semisync_master.so;rpl_semi_sync_slave=semisync_slave.so&quot; rpl-semi-sync-master-enabled = 1 rpl-semi-sync-slave-enabled = 1

# mysql8.0 半同步复制设置
plugin-load = &quot;rpl_semi_sync_source=semisync_source.so;rpl_semi_sync_replica=semisync_replica.so&quot; rpl-semi-sync-source-enabled = 1 rpl-semi-sync-replica-enabled = 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- 停止
stop slave;

-- 配置从库
-- 示例 Mysql5.6
CHANGE MASTER TO
  MASTER_HOST = &apos;mysql8&apos;,
  MASTER_PORT = 3306 ,
  MASTER_USER = &apos;root&apos;,
  MASTER_PASSWORD = &apos;123456&apos;,
  MASTER_AUTO_POSITION = 1;

-- 示例 Mysql8.0
-- GET_MASTER_PUBLIC_KEY=1, 这个是为了绕过SSL/HTTPS错误
CHANGE REPLICATION SOURCE TO
  GET_MASTER_PUBLIC_KEY=1,
  SOURCE_HOST = &apos;mysql8&apos;,
  SOURCE_PORT = 3306 ,
  SOURCE_USER = &apos;root&apos;,
  SOURCE_PASSWORD = &apos;123456&apos;,
  SOURCE_AUTO_POSITION = 1;

-- 启动
START SLAVE;

-- 查看从库配置
show slave status \G;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;半同步复制&amp;lt;/mark&amp;gt;&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;半同步复制需要先完成上面异步复制的操作。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h4&gt;1.mysql.cnf配置&lt;/h4&gt;
&lt;p&gt;主库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主库
[mysqld]
secure_file_priv=/home # mysqldump备份后的路径，你可以设置到你想要的目录
server-id = 1 # 配置服务器ID，2个数据库server-id不一致即可
log_bin = /var/lib/mysql/binlog # 开启binlog，目录/var/lib/mysql/就会有binlog.000001这样的文件

# mysql5.6
plugin-load = &quot;rpl_semi_sync_master=semisync_master.so;rpl_semi_sync_slave=semisync_slave.so&quot; rpl-semi-sync-master-enabled = 1 rpl-semi-sync-slave-enabled = 1

# mysql8.0
plugin-load = &quot;rpl_semi_sync_source=semisync_source.so;rpl_semi_sync_replica=semisync_replica.so&quot; rpl-semi-sync-source-enabled = 1 rpl-semi-sync-replica-enabled = 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
[mysqld]
secure_file_priv=/home # mysqldump备份后的路径，你可以设置到你想要的目录
server-id = 2 # 配置服务器ID，2个数据库server-id不一致即可
log_bin = /var/lib/mysql/binlog # 开启binlog，目录/var/lib/mysql/就会有binlog.000001这样的文件

# mysql5.6
plugin-load = &quot;rpl_semi_sync_master=semisync_master.so;rpl_semi_sync_slave=semisync_slave.so&quot; rpl-semi-sync-master-enabled = 1 rpl-semi-sync-slave-enabled = 1

# mysql8.0
plugin-load = &quot;rpl_semi_sync_source=semisync_source.so;rpl_semi_sync_replica=semisync_replica.so&quot; rpl-semi-sync-source-enabled = 1 rpl-semi-sync-replica-enabled = 1
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.半同步复制配置&lt;/h4&gt;
&lt;p&gt;主库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主库
-- mysql 5.6
-- 启用插件
INSTALL PLUGIN rpl_semi_sync_master SONAME &apos;semisync_master.so&apos;;
-- 全局设置
SET GLOBAL rpl_semi_sync_master_enabled = 1;

-----------分隔线--------------

-- mysql8.0
-- 启用插件
INSTALL PLUGIN rpl_semi_sync_source SONAME &apos;semisync_source.so&apos;; 

-- 全局设置
SET GLOBAL rpl_semi_sync_source_enabled = 1;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从库配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 从库
-- mysql 5.6
-- 启用插件
INSTALL PLUGIN rpl_semi_sync_slave SONAME &apos;semisync_slave.so&apos;;
-- 全局设置
SET GLOBAL rpl_semi_sync_slave_enabled = 1;

-----------分隔线--------------

-- mysql8.0
-- 启用插件
INSTALL PLUGIN rpl_semi_sync_replica SONAME &apos;semisync_replica.so&apos;;

-- 全局设置
SET GLOBAL rpl_semi_sync_replica_enabled = 1;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看是否成功&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; -- 主从均可查看
-- 查看是否开启半同步
SELECT PLUGIN_NAME, PLUGIN_STATUS FROM INFORMATION_SCHEMA.PLUGINS WHERE PLUGIN_NAME LIKE &apos;%semi%&apos;;

SHOW GLOBAL VARIABLES LIKE &apos;rpl_semi_sync%&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;参考&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;mysql文档：&lt;a href=&quot;https://dev.mysql.com/doc/refman/8.0/en/replication-semisync-installation.html&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;链接&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql的备份</title><link>https://rjomg-blog.pages.dev/posts/wp-1210/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1210/</guid><pubDate>Thu, 11 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是数据库备份，怎么去备份&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是MySQL备份&lt;/h2&gt;
&lt;h3&gt;备份数据库时的状态&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;Hot Backup（热备份）：正常运行中直接备份&lt;/li&gt;
&lt;li&gt;Cold Backup（冷备份）：数据库完全停止后再进行备份&lt;/li&gt;
&lt;li&gt;Warm Backup（温备份）：介于热备和冷备之间， 数据库只能读&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;备份文件的格式&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;逻辑备份：输出文本或SQL语句 （导出成人可读的逻辑性的文本）&lt;/li&gt;
&lt;li&gt;物理备份（裸文件）：备份数据库底层文件&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;备份的内容&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;完全备份：备份完整数据&lt;/li&gt;
&lt;li&gt;增量备份：备份数据的差异&lt;/li&gt;
&lt;li&gt;日志备份：备份Binlog（严格讲也属于增量备份的一种，增量备份一般指逻辑的备份。）&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;备份工具&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;mysqldump：备份的是逻辑备份、热备份、全量备份&lt;/li&gt;
&lt;li&gt;xtrabackup：物理备份、热备份、全量备份 + 增量备份&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;备份实践&lt;/h2&gt;
&lt;h3&gt;OUTFILE的使用方式&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;OUTFILE&amp;lt;/mark&amp;gt;是Mysql的原生SQL指令，它是最原始的逻辑备份方式。&lt;/p&gt;
&lt;p&gt;它的备份的功能和效果完全取决于如何写SQL语句&lt;/p&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;1.导出路径&lt;/h4&gt;
&lt;p&gt;首先查出Mysql导出路径&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;show variables like &apos;%secure%&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;2.修改导出路径&lt;/h4&gt;
&lt;p&gt;如果&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;secure_file_priv&amp;lt;/mark&amp;gt;为Null，则需要修改&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;my.cnf&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[mysqld]
secure_file_priv=/home
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;3.使用INTO导出&lt;/h4&gt;
&lt;p&gt;注意事项：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;在INNODB事务下面，可以做到一致性视图&amp;lt;/mark&amp;gt;&lt;/li&gt;
&lt;li&gt;修改分隔符：fields terminated by&lt;/li&gt;
&lt;li&gt;修改换行符：lines terminated by&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;-- 直接导出
select * into outfile &apos;/home/t3-out&apos; from t3;

-- 修改分隔符，用逗号分隔
select * into outfile &apos;/home/t3-out&apos; fields terminated by &apos;,&apos; from t3;

-- 修改换行符，用分号
select * into outfile &apos;/home/t3-out&apos; fields terminated by &apos;,&apos; lines terminated by &apos;;&apos; from t3;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;4. OUTFILE的缺陷&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;输出的文本比较简单&lt;/li&gt;
&lt;li&gt;很难进行还原，现在往往用来导出简单的数据&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;mysqldump的使用方式&lt;/h3&gt;
&lt;h4&gt;1.全量备份&lt;/h4&gt;
&lt;p&gt;全量备份&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mysqldump -uroot -p123456 --databases sakila --single-transaction &amp;gt; test.sql
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;还原&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;source test.sql
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;2.全量备份+Binlog增量备份&lt;/h4&gt;
&lt;p&gt;增量备份思路&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Binlog忠实的记录了Mysql的数据变化&lt;/li&gt;
&lt;li&gt;mysqldump全量备份之后，可用Binlog作为增量&lt;/li&gt;
&lt;li&gt;mysqldump全量备份后，切换新的Binlog文件&lt;/li&gt;
&lt;li&gt;从零还原时，采用全量备份还原+Binlog还原&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;全量备份+增量备份的准备工作&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;--flush-logs： 备份后切换Binlog文件&lt;/li&gt;
&lt;li&gt;--master-data=2：记录切换后的Binlog文件名，并且注释方式写入到test.sql文件里&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;mysqldump -uroot -p123456 --databases sakila --single-transaction --flush-logs --master-data=2 &amp;gt; test.sql
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Binlog增量备份&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;需要增量备份时，使用&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;mysqladmin&amp;lt;/mark&amp;gt;切换Binlog文件&lt;/li&gt;
&lt;li&gt;将所有新增的Binlog文件备份&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;mysqladmin -uroot -p123456 flush-logs
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;还原&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 如果全量恢复
source test.sql

# 然后将增量的Binlog还原到数据库
mysqlbinlog 「文件名」| mysql -uroot -p123456
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:24px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;3.mysqldump注意事项&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;--single-tranction：在RR（可重复读）级别下进行（INNODB）&lt;/li&gt;
&lt;li&gt;--lock-all-tables：使用FTWRL锁所有表（MyISAM）&lt;/li&gt;
&lt;li&gt;--lock-tables：使用READ LOCAL锁当前库的表（MyISAM）&lt;/li&gt;
&lt;li&gt;--all-databases：备份所有的库&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;4.mysqldump缺点&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;导出逻辑数据，备份慢，会影响性能&lt;/li&gt;
&lt;li&gt;还原需要执行SQL，解析速度也比较慢&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;5.mysqldump总结&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;mysqldump使用简单，可以热备份&lt;/li&gt;
&lt;li&gt;SQL文件可以直接执行、占用空间少、可阅读性高&lt;/li&gt;
&lt;li&gt;备份、还原的性能不如物理备份&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h3&gt;XtraBackup备份&lt;/h3&gt;
&lt;h4&gt;物理备份的优点&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;直接备份INNODB底层文件&lt;/li&gt;
&lt;li&gt;导出不需要转换，速度快&lt;/li&gt;
&lt;li&gt;工作时对数据库的压力比较小&lt;/li&gt;
&lt;li&gt;更容易实现增量备份&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;XtraBackup：&lt;a href=&quot;https://www.percona.com/downloads&quot;&gt;下载地址&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;mysql8.0选择XtraBackup8.0、mysql5.2~5.6选择XtraBackup2.4版本&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/05/XtraBackup下载地址.png&quot; class=&quot;wp-image-1350&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>Mysql 怎么查看所有的锁和事务</title><link>https://rjomg-blog.pages.dev/posts/wp-1163/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1163/</guid><pubDate>Sun, 07 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：怎么查看锁、长事务、阻塞的事务 &amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;通用&lt;/h2&gt;
&lt;h3&gt;查看当前长事务&lt;/h3&gt;
&lt;p&gt;information_schema库下面的innodb_trx表&lt;/p&gt;
&lt;h2&gt;Mysql5.6&lt;/h2&gt;
&lt;h3&gt;查看当前所有的锁&lt;/h3&gt;
&lt;p&gt;information_schema库下面的innodb_locks表&lt;/p&gt;
&lt;h3&gt;查看阻塞的事务&lt;/h3&gt;
&lt;p&gt;information_schema库下面的innodb_lock_waits 表&lt;/p&gt;
&lt;h2&gt;Mysql8.0&lt;/h2&gt;
&lt;h3&gt;查看当前所有的锁&lt;/h3&gt;
&lt;p&gt;performance_schema库下面的data_locks表&lt;/p&gt;
&lt;h3&gt;查看锁等待&lt;/h3&gt;
&lt;p&gt;performance_schema库下面的data_lock_waits表&lt;/p&gt;
&lt;h3&gt;查看MDL锁&lt;/h3&gt;
&lt;p&gt;performance_schema库下面的metadata_locks表&lt;/p&gt;
</content:encoded></item><item><title>Mysql MDL锁</title><link>https://rjomg-blog.pages.dev/posts/wp-1180/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1180/</guid><pubDate>Sun, 07 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么事MDL锁&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是MDL锁&lt;/h2&gt;
&lt;p&gt;全称为meta data lock， 中文叫元数据锁，是从MySQL5.5开始引入的锁，是为了解决DDL操作和DML操作之间操作一致性。从锁的作用范围上来说，MDL算是一种表级锁。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;预防MDL锁导致卡死&lt;/h2&gt;
&lt;p&gt;在业务繁忙期间，不要进行表结构的修改。&lt;/p&gt;
</content:encoded></item><item><title>Mysql死锁</title><link>https://rjomg-blog.pages.dev/posts/wp-1117/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1117/</guid><pubDate>Sun, 07 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是死锁，怎么解决死锁。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是死锁&lt;/h2&gt;
&lt;p&gt;MySQL中的死锁是指两个或多个事务在相互竞争数据库资源（如行锁或表锁）时发生的阻塞现象。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;死锁是怎么生成的&lt;/h2&gt;
&lt;p&gt;通过下面2个事务说明。（示例表/数据在下面）&lt;/p&gt;
&lt;h3&gt;TXA&lt;/h3&gt;
&lt;p&gt;因为2个事务流程分别都要锁ID10和ID20,因为先后顺序，互相占用了。导致进程无法往下运行，这个时候主动检测死锁的功能将自动启动。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- 事务1
begin;
select * from t3 where id = 10 for update; -- 第一步

select * from t3 where id = 20 for update; -- 第三步
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;TXB&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;-- 事务2
begin;
select * from t3 where id = 20 for update; -- 第二步

select * from t3 where id = 10 for update; -- 第四步
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;解决死锁的一些方法&lt;/h2&gt;
&lt;h3&gt;临时设置方式&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;SET [SESSION | GLOBAL] innodb_lock_wait_timeout = value;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;设置事务超时时间&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;innodb_lock_wait_timeout 默认值是50秒&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[mysqld]
innodb_lock_wait_timeout = 50；
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;主动检测死锁&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;innodb_deadlock_detect默认开启&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;p&gt;回滚代价比较低的事务，让另外一个事务成功执行。&lt;/p&gt;
&lt;p&gt;但是当项目比较大，成千上万的事务在执行，这个会是导致数据库卡的一个原因之一（可以选择关闭主动检测，并且优化业务逻辑的事务）。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[mysqld]
innodb_deadlock_detect = OFF
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;主动发现阻塞&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;SELECT waiting_pid AS &apos;被阻塞的线程&apos;,
waiting_query AS &apos;被阻塞的SQL&apos;,
blocking_pid AS &apos;阻塞线程&apos;,
blocking_query AS &apos;阻塞SQL&apos;,
wait_age AS &apos;阻塞时间&apos;,
sql_kill_blocking_query AS &apos;操作建议&apos;
FROM sys.innodb_lock_waits
-- 设置阻塞时间大于N
WHERE (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(wait_started)) &amp;gt; 30
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;业务逻辑优化建议&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;控制长事务，非必要，不用开启事务&lt;/li&gt;
&lt;li&gt;数据更新、删除、等尽量放到事务的最后部分，可以有效降低锁存在的时间&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;示例结构/数据&lt;/h2&gt;
&lt;p&gt;表结构&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CREATE TABLE `t3` (
    `id` INT ( 11 ) NOT NULL,
    `c` INT ( 11 ) DEFAULT NULL,
    `d` INT ( 11 ) DEFAULT NULL,
    PRIMARY KEY ( `id` ),
KEY `c` ( `c` ) 
) ENGINE = INNODB;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;INSERT INTO t3
VALUES
    ( 0, 0, 0 ),
    ( 10, 10, 10 ),
    ( 20, 20, 20 ),
    ( 30, 30, 30 ),
    ( 40, 40, 40 ),
    ( 50, 50, 50 );
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql非唯一索引范围查询，加锁逻辑</title><link>https://rjomg-blog.pages.dev/posts/wp-1052/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1052/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Mysql非唯一索引范围查询时，间隙锁是怎么工作的&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;工作示例&lt;/h2&gt;
&lt;p&gt;需要在事务隔离级别：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读&amp;lt;/mark&amp;gt; (URL：&lt;a href=&quot;https://www.rjomg.com/2023/05/03/732/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql设置事务隔离级别方法&amp;lt;/mark&amp;gt;&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;使用一个窗口，运行Sql语句。（示例表/数据在下面）&lt;/p&gt;
&lt;h3&gt;TXA&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口1
begin;
select * from t3 where c between 20 and 30 for update;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;图表示例&lt;/h3&gt;
&lt;p&gt;首先等值查询20，不是唯一索引，锁定(10,20]&lt;/p&gt;
&lt;p&gt;向右扫描至30，锁定(20,30]&lt;/p&gt;
&lt;p&gt;向右扫描，锁(30,40]&lt;/p&gt;
&lt;p&gt;40不符合，然后取消锁&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;辅助索引c&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;记录值↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;(0,10)&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;20&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(20,30)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;30&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(30,40)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;40&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;↓&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;辅助索引c&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;记录值↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;(0,10)&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;20&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(20,30)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;30&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(30,40)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;示例结构/数据&lt;/h2&gt;
&lt;p&gt;表结构&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CREATE TABLE `t3` (
    `id` INT ( 11 ) NOT NULL,
    `c` INT ( 11 ) DEFAULT NULL,
    `d` INT ( 11 ) DEFAULT NULL,
    PRIMARY KEY ( `id` ),
KEY `c` ( `c` ) 
) ENGINE = INNODB;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;INSERT INTO t3
VALUES
    ( 0, 0, 0 ),
    ( 10, 10, 10 ),
    ( 20, 20, 20 ),
    ( 30, 30, 30 ),
    ( 40, 40, 40 ),
    ( 50, 50, 50 );
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql非索引字段查询，加锁逻辑</title><link>https://rjomg-blog.pages.dev/posts/wp-1071/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1071/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Mysql非索引字段查询时，间隙锁是怎么工作的&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;工作示例&lt;/h2&gt;
&lt;p&gt;需要在事务隔离级别：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读&amp;lt;/mark&amp;gt; (URL：&lt;a href=&quot;https://www.rjomg.com/2023/05/03/732/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql设置事务隔离级别方法&amp;lt;/mark&amp;gt;&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;使用一个窗口，运行Sql语句。（示例表/数据在下面）&lt;/p&gt;
&lt;h3&gt;TXA&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口1
begin;
select * from t3 where d = 20 for update;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;图表示例&lt;/h3&gt;
&lt;p&gt;因为字段没有索引，走主键索引扫描，锁全表。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;主键索引&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;主键↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;（-♾️,0）&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;0&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(0,10)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;10&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;20&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(20,30)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;30&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(30,40)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;40&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(40,50)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;50&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(50,+♾️)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;+♾️&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;示例结构/数据&lt;/h2&gt;
&lt;p&gt;表结构&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CREATE TABLE `t3` (
    `id` INT ( 11 ) NOT NULL,
    `c` INT ( 11 ) DEFAULT NULL,
    `d` INT ( 11 ) DEFAULT NULL,
    PRIMARY KEY ( `id` ),
KEY `c` ( `c` ) 
) ENGINE = INNODB;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;INSERT INTO t3
VALUES
    ( 0, 0, 0 ),
    ( 10, 10, 10 ),
    ( 20, 20, 20 ),
    ( 30, 30, 30 ),
    ( 40, 40, 40 ),
    ( 50, 50, 50 );
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql主键索引范围查询，加锁逻辑</title><link>https://rjomg-blog.pages.dev/posts/wp-1033/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1033/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Mysql主键索引范围时，间隙锁是怎么工作的&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;工作示例&lt;/h2&gt;
&lt;p&gt;需要在事务隔离级别：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读&amp;lt;/mark&amp;gt; (URL：&lt;a href=&quot;https://www.rjomg.com/2023/05/03/732/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql设置事务隔离级别方法&amp;lt;/mark&amp;gt;&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;使用两个窗口，运行Sql语句。（示例表/数据在下面）&lt;/p&gt;
&lt;h3&gt;TXA&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口1
begin;
select * from t3 where id between 20 and 30 for update;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;TXB&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口2
select * from t3 where id = 20 for update;
insert into t3 value (12, 12, 12);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;图表示例&lt;/h3&gt;
&lt;p&gt;因为主键是唯一索引，所以查询到了20不需要加上（10,20）这个间隙，只锁20。&lt;/p&gt;
&lt;p&gt;向右扫描至30，锁(20,30]&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主键索引&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;主键↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;(0,10)&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;(10,20)&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;20&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(20,30)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;30&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;(30,40)&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;示例结构/数据&lt;/h2&gt;
&lt;p&gt;表结构&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CREATE TABLE `t3` (
    `id` INT ( 11 ) NOT NULL,
    `c` INT ( 11 ) DEFAULT NULL,
    `d` INT ( 11 ) DEFAULT NULL,
    PRIMARY KEY ( `id` ),
KEY `c` ( `c` ) 
) ENGINE = INNODB;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;INSERT INTO t3
VALUES
    ( 0, 0, 0 ),
    ( 10, 10, 10 ),
    ( 20, 20, 20 ),
    ( 30, 30, 30 ),
    ( 40, 40, 40 ),
    ( 50, 50, 50 );
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql脏页、刷脏</title><link>https://rjomg-blog.pages.dev/posts/wp-1081/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-1081/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是脏页，怎么刷脏。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是脏页&lt;/h2&gt;
&lt;p&gt;当内存数据页跟磁盘数据页内容不一致的时候，我们称这个不一致的内存页为“脏页”。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;刷脏配置&lt;/h2&gt;
&lt;h3&gt;临时设置方式&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;SET [SESSION | GLOBAL] innodb_io_capacity = value;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;脏页IO配置&lt;/h3&gt;
&lt;p&gt;查看返回结果的read和write下面的iops avg=xxx&lt;/p&gt;
&lt;p&gt;根据avg来决定&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;innodb_io_capacity&amp;lt;/mark&amp;gt;参数的大小&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 简单的查看磁盘IO语句
fio -filename=io_test -direct=1 -iodepth 1 -thread -rw=randrw -ioengine=psync -bs=16K  -size=500M -numjobs=10  -runtime=10 -group_reporting -name=mytest
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;通过&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;innodb_io_capacity&amp;lt;/mark&amp;gt;设置，修改刷脏的速度&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[mysqld]
innodb_io_capacity = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;配置合理的脏页比例上限&lt;/h3&gt;
&lt;p&gt;通过&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;innodb_max_dirty_pages_pct&amp;lt;/mark&amp;gt;设置脏页比例上限&lt;/p&gt;
&lt;p&gt;当脏页比例接近此值，会加速刷脏页&lt;/p&gt;
&lt;p&gt;建议保持默认值75%&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[mysqld]
innodb_max_dirty_pages_pct = 75
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:35px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;邻近刷脏配置&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;innodb_flush_negihbors&amp;lt;/mark&amp;gt;是一个MySQL数据库的InnoDB存储引擎的配置参数，用于设置在刷新脏页时是否同时刷新相邻的脏页。这个参数对于减少磁盘随机写操作，提高磁盘利用率，特别是在机械硬盘（HDD）上效果明显。&lt;/p&gt;
&lt;p&gt;SSD建议设置为0，Mysql8.0已经默认为0&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;0：禁用邻居刷新。InnoDB仅刷新请求的脏页，而不刷新相邻的脏页。&lt;/li&gt;
&lt;li&gt;1：启用邻居刷新。在刷新脏页时，InnoDB会同时刷新相邻的脏页，以减少随机写操作。这在使用机械硬盘（HDD）时效果较好。&lt;/li&gt;
&lt;li&gt;2：始终刷新邻居。不仅在刷新脏页时刷新相邻的脏页，还会在任何时候都尝试刷新邻居。这种设置可能会导致更多的写操作，但在某些情况下可能会提高性能。&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;[mysqld]
innodb_flush_neighbors = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;总结&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;刷脏可能会导致Mysql卡住，造成性能的问题。&lt;/li&gt;
&lt;li&gt;通过告知Mysql服务器IO的性能，可以控制合理的刷脏IO&lt;/li&gt;
&lt;li&gt;合理的脏页比例上限，建议保持默认值&lt;/li&gt;
&lt;li&gt;“邻近刷脏页”功能在SSD硬盘下需要禁用&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Mysql Next-Key锁</title><link>https://rjomg-blog.pages.dev/posts/wp-851/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-851/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：什么是Next-Key Lock，Next-Key Lock的加锁逻辑&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;什么是Next-Key锁&lt;/h2&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Next-Key锁&amp;lt;/mark&amp;gt;是&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;间隙锁&amp;lt;/mark&amp;gt; + &amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;行锁&amp;lt;/mark&amp;gt;（记录锁）的组合&lt;/p&gt;
&lt;p&gt;事务隔离级别分别为&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读&amp;lt;/mark&amp;gt;（REPEATABLE READ）和&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;串行化&amp;lt;/mark&amp;gt;（SERIALIZABLE）下，&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;InnoDB&amp;lt;/mark&amp;gt;才会使用间隙锁。&lt;/p&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;间隙锁&amp;lt;/mark&amp;gt;是一种锁定记录之间的“间隙”的锁。它并不锁定任何真实存在的记录，而是锁定一个范围，以防止其他事务在这个范围内插入新的记录。间隙锁的主要目的是为了防止&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;幻读&amp;lt;/mark&amp;gt;问题。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;Next-Key锁的加锁逻辑&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;加锁时以Next-Key为基本单位&lt;/li&gt;
&lt;li&gt;查找过程中扫描过的范围才加锁&lt;/li&gt;
&lt;li&gt;唯一索引等值查询，没有间隙锁，只加行锁&lt;/li&gt;
&lt;li&gt;索引等值查询最右一个扫描到的不满足条件值的不加行锁&lt;/li&gt;
&lt;li&gt;索引覆盖且只加S锁时，不锁主键索引&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;示例&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rjomg.com/2023/05/05/898/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;等值查询&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rjomg.com/2023/05/05/976/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;非唯一索引等值查询&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rjomg.com/2023/05/05/1033/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主键索引范围查询&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rjomg.com/2023/05/05/1052/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;非唯一索引范围查询&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rjomg.com/2023/05/05/1071/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;非索引字段查询&amp;lt;/mark&amp;gt;&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>Mysql 等值查询时，加锁逻辑</title><link>https://rjomg-blog.pages.dev/posts/wp-898/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-898/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Mysql等值查询时，间隙锁是怎么工作的&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;工作示例&lt;/h2&gt;
&lt;p&gt;需要在事务隔离级别：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读&amp;lt;/mark&amp;gt; (URL：&lt;a href=&quot;https://www.rjomg.com/2023/05/03/732/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql设置事务隔离级别方法&amp;lt;/mark&amp;gt;&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;使用两个窗口，运行Sql语句。（示例表/数据在下面）&lt;/p&gt;
&lt;h3&gt;TXA&lt;/h3&gt;
&lt;p&gt;查询t3表，id等于11并且加上&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;排他锁&amp;lt;/mark&amp;gt;（Exclusive Locks，简称X锁，写锁）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口1
begin;
select * from t3 where id = 11 for update;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;TXB&lt;/h3&gt;
&lt;p&gt;当执行了窗口1的命令后，会锁定间隙(10,20),所以窗口2的插入语句是不能在id为10~20之间插入任何id的，但是因为ID11不等于ID20，所以20的锁会被解除。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口2
-- 插入id为12的数据，在窗口1不commit（提交）或者rollback（回滚）之前，是执行不成功的
insert into t3 value(12, 12, 12); 

-- ID20因为没有被锁定，所以是可以执行成功的
select * from t3 where id = 20 for update;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;图表示例&lt;/h3&gt;
&lt;p&gt;首先锁定&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)间隙&amp;lt;/mark&amp;gt;和&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;行记录ID20&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主键索引&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;主键↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;(0,10)&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;20&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;(20,30)&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;td&gt;(30,40)&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;↓因为查询的id是11不等于20,ID20这条行记录是不被需要的，所以ID20这条行记录会解锁&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;主键索引&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;主键↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;(0,10)&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;20&lt;/td&gt;
&lt;td&gt;(20,30)&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;td&gt;(30,40)&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;示例结构/数据&lt;/h2&gt;
&lt;p&gt;表结构&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CREATE TABLE `t3` (
    `id` INT ( 11 ) NOT NULL,
    `c` INT ( 11 ) DEFAULT NULL,
    `d` INT ( 11 ) DEFAULT NULL,
    PRIMARY KEY ( `id` ),
KEY `c` ( `c` ) 
) ENGINE = INNODB;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;INSERT INTO t3
VALUES
    ( 0, 0, 0 ),
    ( 10, 10, 10 ),
    ( 20, 20, 20 ),
    ( 30, 30, 30 ),
    ( 40, 40, 40 ),
    ( 50, 50, 50 );
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql 非唯一索引等值查询，加锁逻辑</title><link>https://rjomg-blog.pages.dev/posts/wp-976/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-976/</guid><pubDate>Fri, 05 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：Mysql非唯一索引等值查询时，间隙锁是怎么工作的&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;工作示例&lt;/h2&gt;
&lt;p&gt;需要在事务隔离级别：&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读&amp;lt;/mark&amp;gt; (URL：&lt;a href=&quot;https://www.rjomg.com/2023/05/03/732/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;Mysql设置事务隔离级别方法&amp;lt;/mark&amp;gt;&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;使用两个窗口，运行Sql语句。（示例表/数据在下面）&lt;/p&gt;
&lt;h3&gt;TXA&lt;/h3&gt;
&lt;p&gt;查询t3表，辅助索引c等于10并且加上&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;共享锁&amp;lt;/mark&amp;gt;（Shared Locks，简称S锁，读锁）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口1
begin;
select id from t3 where c = 10 lock in share mode;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;TXB&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;-- 窗口2
select * from t3 where id = 20 for update;
insert into t3 value (12, 12, 12);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;图表示例&lt;/h3&gt;
&lt;p&gt;辅助索引C是非唯一索引，所以首先锁间隙(0,10)和一条记录值为10的记录，然后因为不知道右面是否还有记录值为10的，所以向右扫描时间隙(10,20)和20被锁定了。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;辅助索引c&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;索引值↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(0,10)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;10&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;20&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;(20,30)&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;td&gt;(30,40)&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;↓然后因为等值查询最后一个扫描20,20锁解除&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;辅助索引c&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;索引值↓&lt;/td&gt;
&lt;td&gt;间隙↓&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;红色是被锁&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;（-♾️,0）&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(0,10)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;10&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;(10,20)&amp;lt;/mark&amp;gt;&lt;/td&gt;
&lt;td&gt;20&lt;/td&gt;
&lt;td&gt;(20,30)&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;td&gt;(30,40)&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;(40,50)&lt;/td&gt;
&lt;td&gt;50&lt;/td&gt;
&lt;td&gt;(50,+♾️)&lt;/td&gt;
&lt;td&gt;+♾️&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;示例结构/数据&lt;/h2&gt;
&lt;p&gt;表结构&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CREATE TABLE `t3` (
    `id` INT ( 11 ) NOT NULL,
    `c` INT ( 11 ) DEFAULT NULL,
    `d` INT ( 11 ) DEFAULT NULL,
    PRIMARY KEY ( `id` ),
KEY `c` ( `c` ) 
) ENGINE = INNODB;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数据&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;INSERT INTO t3
VALUES
    ( 0, 0, 0 ),
    ( 10, 10, 10 ),
    ( 20, 20, 20 ),
    ( 30, 30, 30 ),
    ( 40, 40, 40 ),
    ( 50, 50, 50 );
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Mysql设置事务隔离级别方法</title><link>https://rjomg-blog.pages.dev/posts/wp-732/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-732/</guid><pubDate>Wed, 03 May 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;目标：设置Mysql的事务隔离级别&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h2&gt;查看当前事务隔离级别&lt;/h2&gt;
&lt;h3&gt;Mysql8.0&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;SELECT @@transaction_isolation;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;Mysql5.6&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;警告⚠️：在Mysql8.0.3及以后的版本中弃用&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;SSELECT @@tx_isolation;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;设置事务隔离&lt;/h2&gt;
&lt;h3&gt;四种事务隔离级别&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;READ UNCOMMITTED&amp;lt;/mark&amp;gt;&lt;/strong&gt;（读未提交）: 最低的隔离级别，允许事务看到其他未提交事务的修改。这可能会导致所谓的“脏读”现象，也就是一个事务读取到另一个事务未提交的修改。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;READ COMMITTED&amp;lt;/mark&amp;gt;&lt;/strong&gt;（读已提交）: 较高的隔离级别，只允许事务读取其他已提交事务的修改。这避免了脏读，但仍可能出现不可重复读和幻读现象。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;REPEATABLE READ&amp;lt;/mark&amp;gt;&lt;/strong&gt;（可重复读）: 更高的隔离级别，确保在同一个事务中多次读取同一数据的结果是一致的。这是MySQL的默认事务隔离级别。它避免了脏读和不可重复读，但在某些情况下可能会出现幻读。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;strong&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;SERIALIZABLE&amp;lt;/mark&amp;gt;（串行化）&lt;/strong&gt;&lt;/strong&gt;: 最高的隔离级别，会在读取的每一行数据上都加锁，从而阻止其他事务进行并发修改。这避免了脏读、不可重复读和幻读，但是性能开销也最大。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;具体设置&lt;/h3&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;提示：Mysql5.6和Mysql8设置事务隔离的方式是一样的。&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;h4&gt;样例&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;-- 样例 SESSION：只影响当前会话 | GLOBAL： 全局设置
SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL 级别名称;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;&lt;strong&gt;READ UNCOMMITTED&lt;/strong&gt;（读未提交）&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;-- READ UNCOMMITTED（读未提交）
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;READ COMMITTED（读已提交）&lt;/h4&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;读已提交：为Oracle的默认事务隔离级别&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- READ UNCOMMITTED（读未提交）
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;&lt;strong&gt;REPEATABLE READ&lt;/strong&gt;（可重复读）&lt;/h4&gt;
&lt;p&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;可重复读：为Mysql的默认事务隔离级别&amp;lt;/mark&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-- REPEATABLE READ（可重复读）
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h4&gt;SERIALIZABLE（串行化）&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;-- SERIALIZABLE（串行化）
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;Mysql不同隔离级别的对照&lt;/h1&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;隔离级别&lt;/td&gt;
&lt;td&gt;脏读&lt;/td&gt;
&lt;td&gt;不可重复读&lt;/td&gt;
&lt;td&gt;幻读&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;读未提交&lt;/td&gt;
&lt;td&gt;❌&lt;/td&gt;
&lt;td&gt;❌&lt;/td&gt;
&lt;td&gt;❌&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;读已提交&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;❌&lt;/td&gt;
&lt;td&gt;❌&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;可重复读&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;部分✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;串行化&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;注释&lt;/h1&gt;
&lt;ol&gt;
&lt;li&gt;脏读：读到了其他事务未提交的数据&lt;/li&gt;
&lt;li&gt;不可重复读：同样的查询，读到的数据内容不一致&lt;/li&gt;
&lt;li&gt;幻读：同样的查询读到了更多的数据&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>PyCharm使用Lima安装的Docker开发</title><link>https://rjomg-blog.pages.dev/posts/wp-567/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-567/</guid><pubDate>Thu, 20 Apr 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：Pycharm使用Docker开发环境&lt;/p&gt;
&lt;h2&gt;1.在MacOS设置变量&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;export DOCKER_HOST=unix://$HOME/.lima/docker.sock
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.PyCharm设置&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;打开 PyCharm，然后转到 &quot;Preferences&quot;（macOS）或 &quot;Settings&quot;（Windows/Linux）。&lt;/li&gt;
&lt;li&gt;在左侧面板中，导航到 &quot;Build, Execution, Deployment&quot; &amp;gt; &quot;Docker&quot;。&lt;/li&gt;
&lt;li&gt;点击 &quot;+&quot; 图标以添加新的 Docker 配置。&lt;/li&gt;
&lt;li&gt;在 &quot;Server&quot; 部分，选择 &quot;TCP socket&quot;。&lt;/li&gt;
&lt;li&gt;在 &quot;Engine API URL&quot; 字段中，输入 Lima 提供的 Docker API URL。这应该是unix:///Users/&amp;lt;your_username&amp;gt;/.lima/&amp;lt;your_instance&amp;gt;/sock/docker.sock。请根据你的 Lima 实例和用户名进行相应更改。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;完成这些设置后，PyCharm 应该能够与 Lima Docker 环境通信。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 示例
unix:///Users/rjomg/.lima/default/sock/docker.sock
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/04/PyCharm设置Docker示例图.png&quot; class=&quot;wp-image-577&quot; alt=&quot;PyCharm设置Docker环境示例图&quot; /&amp;gt;&amp;lt;figcaption aria-hidden=&quot;true&quot;&amp;gt;PyCharm设置Docker环境示例图&amp;lt;/figcaption&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:50px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>Dokcer安装RabbitMQ</title><link>https://rjomg-blog.pages.dev/posts/wp-581/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-581/</guid><pubDate>Thu, 20 Apr 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：通过Docker File + Docker Compose 安装RabbitMQ&lt;/p&gt;
&lt;h2&gt;1.编写Dockerfile&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;# 使用官方 RabbitMQ 基础镜像
FROM rabbitmq:3.9-management

SHELL [&quot;/bin/bash&quot;, &quot;-c&quot;]

# 设置环境变量，以便在管理界面中使用
ENV RABBITMQ_DEFAULT_USER=admin
ENV RABBITMQ_DEFAULT_PASS=admin

# 暴露 RabbitMQ 所需的端口
EXPOSE 5672 15672
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.编写DockerCompose&lt;/h2&gt;
&lt;p&gt;networks可以去掉，是我个人的项目网络&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;version: &quot;3.8&quot;

services:
  rabbitmq:
    build:
      context: ./rabbitmq
      dockerfile: rabbitmq.dockerfile
    image: rabbitmq:rjomg
    container_name: rabbitmq
    ports:
      - &quot;5672:5672&quot;
      - &quot;15672:15672&quot;
    networks:
      - project-network

networks:
  project-network:
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3.运行&lt;/h2&gt;
&lt;p&gt;RabbitMQ管理后台&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;http://127.0.0.1:15672/#/&quot;&gt;http://127.0.0.1:15672/#/&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:29px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>MacOSM1/M2安装Lima</title><link>https://rjomg-blog.pages.dev/posts/wp-425/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-425/</guid><pubDate>Thu, 06 Apr 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：MacOSM1/M2下安装和启动Lima，构建和Win一致的内核环境，为后面使用Docker做准备&lt;/p&gt;
&lt;h2&gt;0.碎碎念&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;为什么会有这一篇文章呢，是因为本人十分好奇MacOS，然后上了一个终极大当（不是），在某一个夜晚，冲动的夜晚，剁手买了M2的Mac。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;然后自然是到了喜闻乐见的安装环境。先是使用了Mac下面的Docker Desktop，通过DockerFile+DockerCpmpose安装Oracle19C的时候反复出现了错误，经过多次排查安装方式是绝对没有问题的，在阿里云Centos8和腾讯云Ubuntu22.04分别安装成功！！！安装成功的那一瞬间我的内心是崩溃的，一度产生卖掉Mac的冲动，本着既然已经买了就算要卖，也要把这个问题解决的信念，反复搜索，偶然在GitHub的一些Issues让我看到了一个回答，M1/M2芯片目前是无法通过Docker安装Oracle的。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;这是一个M1/M2永远都不可能安装成功的错误（目前）！！！原因是因为Oracle19C运行需要使用到系统的底层内核AMD4才可以，然而苹果下的Docker任何版本都是ARM64，这就导致目前Oracle根本没有办法在Mac M2/M1芯片上正常运行。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;后面经历了将近一周的排坑我使用了Github上的一个项目Lima（&lt;a href=&quot;https://github.com/lima-vm/lima&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;此处&amp;lt;/mark&amp;gt;&lt;/a&gt;）和Colima（&lt;a href=&quot;https://github.com/abiosoft/colima&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;此处&amp;lt;/mark&amp;gt;&lt;/a&gt;），感谢Lima！！不然我的Mac就要转手卖掉了（Mac是非常好的学习机！！强制学习）。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;1.Lima&lt;/h2&gt;
&lt;h3&gt;1.安装Lima&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 通过MacOS终端安装Lima
brew install lima
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;2.创建Lima实例&lt;/h3&gt;
&lt;p&gt;通过docker_lima.yaml文件，创建一个Docker模板的实例&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;limactl start --name=default /usr/local/share/lima/examples/docker_lima.yaml
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;docker_lima.yaml文件&lt;/strong&gt;文件值得注意的地方&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 挂载设置
mounts:
- location: &quot;~&quot; # 挂载目录，这是挂载整个Users目录
  writable: true # 是否能在Lima容器里编辑文件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;docker_lima.yaml文件&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# Example to use Docker instead of containerd &amp;amp; nerdctl
# $ limactl start ./docker.yaml
# $ limactl shell docker docker run -it -v $HOME:$HOME --rm alpine

# To run `docker` on the host (assumes docker-cli is installed):
# $ export DOCKER_HOST=$(limactl list docker --format &apos;unix://{{.Dir}}/sock/docker.sock&apos;)
# $ docker ...

# This example requires Lima v0.8.0 or later
images:
# Try to use release-yyyyMMdd image if available. Note that release-yyyyMMdd will be removed after several months.
- location: &quot;https://cloud-images.ubuntu.com/releases/22.04/release-20230210/ubuntu-22.04-server-cloudimg-amd64.img&quot;
  arch: &quot;x86_64&quot;
  digest: &quot;sha256:4401cf7e994842f11398a54d0159b689b2fcace166be6147013f128ddb15875e&quot;
- location: &quot;https://cloud-images.ubuntu.com/releases/22.04/release-20230210/ubuntu-22.04-server-cloudimg-arm64.img&quot;
  arch: &quot;aarch64&quot;
  digest: &quot;sha256:d044311b6e2d838f1175a67a5f7fa6bc0936f8001180df539025ec6587c33d28&quot;
# Fallback to the latest release image.
# Hint: run `limactl prune` to invalidate the cache
- location: &quot;https://cloud-images.ubuntu.com/releases/22.04/release/ubuntu-22.04-server-cloudimg-amd64.img&quot;
  arch: &quot;x86_64&quot;
- location: &quot;https://cloud-images.ubuntu.com/releases/22.04/release/ubuntu-22.04-server-cloudimg-arm64.img&quot;
  arch: &quot;aarch64&quot;
arch: &quot;x86_64&quot;
mounts:
- location: &quot;~&quot;
  writable: true
  # 9p:
  #   # 对于可写的共享目录, cache 推荐类型为 mmap, 不写好像默认 fscache
  #   cache: &quot;mmap&quot;
# containerd is managed by Docker, not by Lima, so the values are set to false here.
containerd:
  system: false
  user: false
provision:
- mode: system
  # This script defines the host.docker.internal hostname when hostResolver is disabled.
  # It is also needed for lima 0.8.2 and earlier, which does not support hostResolver.hosts.
  # Names defined in /etc/hosts inside the VM are not resolved inside containers when
  # using the hostResolver; use hostResolver.hosts instead (requires lima 0.8.3 or later).
  script: |
    #!/bin/sh
    sed -i &apos;s/host.lima.internal.*/host.lima.internal host.docker.internal/&apos; /etc/hosts
- mode: system
  script: |
    #!/bin/bash
    set -eux -o pipefail
    command -v docker &amp;gt;/dev/null 2&amp;gt;&amp;amp;1 &amp;amp;&amp;amp; exit 0
    export DEBIAN_FRONTEND=noninteractive
    curl -fsSL https://get.docker.com | sh
    # NOTE: you may remove the lines below, if you prefer to use rootful docker, not rootless
    systemctl disable --now docker
    apt-get install -y uidmap dbus-user-session
- mode: user
  script: |
    #!/bin/bash
    set -eux -o pipefail
    systemctl --user start dbus
    dockerd-rootless-setuptool.sh install
    docker context use rootless
probes:
- script: |
    #!/bin/bash
    set -eux -o pipefail
    if ! timeout 30s bash -c &quot;until command -v docker &amp;gt;/dev/null 2&amp;gt;&amp;amp;1; do sleep 3; done&quot;; then
      echo &amp;gt;&amp;amp;2 &quot;docker is not installed yet&quot;
      exit 1
    fi
    if ! timeout 30s bash -c &quot;until pgrep rootlesskit; do sleep 3; done&quot;; then
      echo &amp;gt;&amp;amp;2 &quot;rootlesskit (used by rootless docker) is not running&quot;
      exit 1
    fi
  hint: See &quot;/var/log/cloud-init-output.log&quot;. in the guest
hostResolver:
  # hostResolver.hosts requires lima 0.8.3 or later. Names defined here will also
  # resolve inside containers, and not just inside the VM itself.
  hosts:
    host.docker.internal: host.lima.internal
portForwards:
- guestSocket: &quot;/run/user/{{.UID}}/docker.sock&quot;
  hostSocket: &quot;{{.Dir}}/sock/docker.sock&quot;
message: |
  To run `docker` on the host (assumes docker-cli is installed), run the following commands:
  ------
  docker context create lima-{{.Name}} --docker &quot;host=unix://{{.Dir}}/sock/docker.sock&quot;
  docker context use lima-{{.Name}}
  docker run hello-world
  ------
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;3.使用Lima&lt;/h3&gt;
&lt;p&gt;输入lima即可启动default容器，启动后的容器，启动后的容器和正常的Debian没有区别&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lima
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;4.当lima下面的docker想使用科学上网&lt;/h3&gt;
&lt;p&gt;注意：MacOS Socks需要开启局域网模式。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 查看宿主机IP地址
ipconfig getifaddr en0


# Docker容器内设置socks
export http_proxy=&quot;http://192.168.50.75:7890&quot;
export https_proxy=&quot;http://192.168.50.75:7890&quot;
export all_proxy=&quot;socks5://192.168.50.75:7890&quot;


# 还原socks
unset http_proxy
unset https_proxy
unset all_proxy

&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>让Nginx的日志文件减少到固定大小</title><link>https://rjomg-blog.pages.dev/posts/wp-469/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-469/</guid><pubDate>Thu, 06 Apr 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：让Nginx的日志文件减少到固定大小。&lt;/p&gt;
&lt;h2&gt;1.Truncate&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;truncate&lt;/code&gt;命令截断文件时，会从文件的开始位置截断文件，因此会优先保留文件的新数据，而删除文件的旧数据。具体来说，&lt;code&gt;truncate&lt;/code&gt;命令会将文件的大小截断到指定的大小，并将文件的末尾部分删除。因此，文件的开始部分将保留，而文件的结尾部分将被删除。&lt;/li&gt;
&lt;li&gt;例如，如果你将一个大小为10GB的文件截断到5GB，那么文件的前5GB数据将会被保留，而文件的后5GB数据将会被删除。因此，&lt;code&gt;truncate&lt;/code&gt;命令会优先保留文件的新数据，而删除文件的旧数据。&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;# 0.5G是修改后的的目标大小
truncate -s 0.5G /var/log/nginx/access.log
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>Docker的简单入门</title><link>https://rjomg-blog.pages.dev/posts/wp-311/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-311/</guid><pubDate>Thu, 16 Mar 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：Linux下安装和简单使用Docker&lt;/p&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.下载&amp;amp;安装Docker&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;# 下载Docker安装文件，名命为get-docker.sh
curl -fsSL https://get.docker.com -o get-docker.sh


# 安装Docker
sh get-docker.sh


# 查看Docker是否安装成功
docker -v


# 启动Docker
systemctl start docker
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.Docker镜像&lt;/h2&gt;
&lt;p&gt;Docker的镜像一般是通过DockerHub下载的或者通过Dockerfile自制、容器打包成镜像，三种最常用的方法&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 查看镜像
docker images


# 拉取新的镜像
docker pull nginx:latest


# 删除镜像
docker rmi nginx


# 查询镜像
docker search php 
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3.Docker应用&lt;/h2&gt;
&lt;p&gt;--name 设置容器的名称&lt;/p&gt;
&lt;p&gt;-p 设置宿主机和容器的端口映射，-p 宿主机端口：容器端口&lt;/p&gt;
&lt;p&gt;-v 设置目录挂载， -p 宿主机路径：容器路径&lt;/p&gt;
&lt;p&gt;最后的nginx代表，nginx镜像，如果本地没有该镜像，会自动到Dockerhub上面下载&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 查看当前启动的容器 -a 可以查看全部容器
docker ps


# 创建一个Nginx容器 
docker run --name nginx -p 80:80 -v /project:/var/www/html nginx 


# 进入容器 -u root 可以指定进入容器侯的用户为root
docker exec -it nginx bash
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Docker的其他文章&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rjomg.com/2022/09/23/159/&quot;&gt;Docker搭建PHP环境（PHP+Nginx+Mysql）&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>Oracle通过表名查库名</title><link>https://rjomg-blog.pages.dev/posts/wp-289/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-289/</guid><pubDate>Fri, 18 Nov 2022 00:00:00 GMT</pubDate><content:encoded>&lt;pre&gt;&lt;code&gt;-- &apos;table_name&apos; = 你的表名 
select * from all_tables where table_name = &apos;table_name&apos;;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Laravel Excel 3.1 导入报错</title><link>https://rjomg-blog.pages.dev/posts/wp-244/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-244/</guid><pubDate>Tue, 01 Nov 2022 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;1.项目信息&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Laravel 9&lt;/li&gt;
&lt;li&gt;DcatAdmin 2.0&lt;/li&gt;
&lt;li&gt;Laravel Excel 3.1 (\Maatwebsite\Excel\Facades\Excel)&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;主要报错&lt;/h3&gt;
&lt;p&gt;导入Xlsx文件时 Laravel Excel 报的错误 Could not find zip member zip://&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2.结论&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;导入的文件有问题，重新新建一个正常的xls,xlsx.csv等文件，都可以解决问题。&lt;/strong&gt;&lt;/p&gt;
&lt;h3&gt;发现过程&lt;/h3&gt;
&lt;p&gt;出现这个问题之后，Google找遍全网，都没有发现怎么解决该问题。直到重复看到&lt;a href=&quot;https://github.com/SpartnerNL/Laravel-Excel/discussions/3432&quot;&gt;Github的一篇文章&lt;/a&gt;，里面有人提示了这不是一个正确的文件！！！&lt;/p&gt;
&lt;p&gt;才发现有可能不是代码的错，是文件出了问题。经过暴打产品后发现，他把xls用重命名的方式改成了xlsx。o(╥﹏╥)o&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3.Error Massage&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;{
    &quot;message&quot;: &quot;Could not find zip member zip://R:\\Project\\DcatAdmin\\storage\\framework\\cache\\laravel-excel\\laravel-excel-M8psDacF0JJvHn437QjTtu2DzanptjCU.xlsx#_rels/.rels&quot;,
    &quot;exception&quot;: &quot;PhpOffice\\PhpSpreadsheet\\Reader\\Exception&quot;,
    &quot;file&quot;: &quot;R:\\Project\\DcatAdmin\\vendor\\phpoffice\\phpspreadsheet\\src\\PhpSpreadsheet\\Shared\\File.php&quot;,
    &quot;line&quot;: 159,
    &quot;trace&quot;: [
        {
            &quot;file&quot;: &quot;R:\\Project\\DcatAdmin\\vendor\\phpoffice\\phpspreadsheet\\src\\PhpSpreadsheet\\Reader\\Xlsx.php&quot;,
            &quot;line&quot;: 408,
            &quot;function&quot;: &quot;assertFile&quot;,
            &quot;class&quot;: &quot;PhpOffice\\PhpSpreadsheet\\Shared\\File&quot;,
            &quot;type&quot;: &quot;::&quot;
        }
        ...
    ]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;4.参考：&lt;/h2&gt;
&lt;p&gt;再次感谢这个讨论，让我恍然大悟。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;https://github.com/SpartnerNL/Laravel-Excel/discussions/3432&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>Docker搭建PHP环境（PHP+Nginx+Mysql+Redis+Swoole）</title><link>https://rjomg-blog.pages.dev/posts/wp-159/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-159/</guid><pubDate>Fri, 23 Sep 2022 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;目标：使用Docker、Docker Hub、PHP、Nginx、Mysql、Redis、Swoole搭建WordPress博客网站。&lt;/p&gt;
&lt;h2&gt;1.准备工作&lt;/h2&gt;
&lt;p&gt;在DokcerHub准备Docker镜像，镜像是为了Docker创建容器&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://hub.docker.com/_/nginx&quot;&gt;DockerHub Nginx&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://hub.docker.com/_/php/tags?page=1&amp;amp;name=7.4-fpm&quot;&gt;DockerHub php7.4-fpm&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://hub.docker.com/_/mysql/tags?page=1&quot;&gt;DockerHub Mysql&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;# 在DockerHub拉取Nginx镜像
docker pull nginx


# 在DockerHub拉取PHP7.4-fpm镜像
docker pull php:7.4-fpm


# 在DockerHub拉取Mysql镜像
docker pull mysql
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.简单介绍&lt;/h2&gt;
&lt;p&gt;--name 自定义容器名称&lt;/p&gt;
&lt;p&gt;-p 将容器内部使用的网络端口映射到宿主机上（宿主机端口：容器端口）&lt;/p&gt;
&lt;p&gt;-d 让容器后台运行&lt;/p&gt;
&lt;p&gt;-v 将容器内部目录和宿主机目录相互映射，（宿主机目录：容器目录）&lt;/p&gt;
&lt;p&gt;docker-php-ext-install 安装php扩展&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3.创建Mysql容器&lt;/h2&gt;
&lt;p&gt;mysql:8.0.29是镜像名称&lt;/p&gt;
&lt;p&gt;PS：Password改成自己的Mysql密码&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 构建Mysql容器
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=Password -d -v /work/mysql:/var/lib/mysql mysql:8.0.29
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;4.创建PHP容器&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;docker run --name php7.4 -p 9000:9000 -d \
-v /project:/project \
php:7.4-fpm
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;PHP安装自带的扩展&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 安装mysqli扩展
docker-php-ext-install mysqli


# 安装pdo_mysql扩展
docker-php-ext-install pdo_mysql
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;PHP容器安装Swoole扩展&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 下载Swoole扩展
wget https://pecl.php.net/get/swoole-4.8.12.tgz


# 解压压缩包
tar -xzvf swoole-4.8.12.tgz


# 将解压出来的安装包copy到php容器，/usr/src/php/ext/是docker-php扩展包目录
docker cp swoole-4.8.12 php7.4:/usr/src/php/ext/swoole


# 进入PHP容器
docker exec -it php7.4 /bin/bash


# 执行安装
docker-php-ext-install swoole
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;添加自定义的php.ini&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 新建ini文件
vim uploads.ini


# 在ini文件输入需要更新的内容
file_uploads = On
memory_limit = 500M
upload_max_filesize = 500M
post_max_size = 500M
max_execution_time = 600


# 复制ini进入docker-php自动读取的文件夹
docker cp uploads.ini php7.4:/usr/local/etc/php/conf.d/uploads.ini
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;5.创建Nginx容器&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;docker run --name nginx -p 80:80 -p 443:443 -d \
-v /project:/project \
-v /work/nginx/conf:/etc/nginx/conf.d \
-v /work/nginx/logs:/var/log/nginx \
-v /work/nginx/cert:/etc/nginx/cert \
--link php7.4:php \
nginx

// 使用acme.sh
docker run --name nginx -p 80:80 -p 443:443 -d \
-v /project:/project \
-v /work/nginx/conf:/etc/nginx/conf.d \
-v /work/nginx/logs:/var/log/nginx \
-v /work/nginx/cert:/etc/nginx/cert \
-v /work/nginx/acme-challenge:/etc/nginx/acme-challenge \
--link php7.4:php \
nginx
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;6.创建Redis容器&lt;/h2&gt;
&lt;h3&gt;简单启动&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;docker run --name redis -p 6379:6379 -d redis --requirepass &quot;Password&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;redis.conf启动&lt;/h3&gt;
&lt;p&gt;根据版本，在官方下载一个redis.conf文件(&lt;a href=&quot;https://redis.io/docs/management/config/&quot;&gt;&amp;lt;mark class=&quot;wp-highlight&quot;&amp;gt;链接&amp;lt;/mark&amp;gt;&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;&amp;lt;figure&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2023/06/redis配置文件图.png&quot; class=&quot;wp-image-2249&quot; width=&quot;232&quot; height=&quot;197&quot; /&amp;gt;&amp;lt;/figure&amp;gt;&lt;/p&gt;
&lt;p&gt;配置redis.conf&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;bind 127.0.0.1 -::1 # 注释掉这部分，这是限制redis只能本地访问&lt;/li&gt;
&lt;li&gt;protected-mode no # 默认yes，开启保护模式，限制为本地访问&lt;/li&gt;
&lt;li&gt;daemonize no # 默认no，改为yes意为以守护进程方式启动，可后台运行，除非kill进程（可选），改为yes会使配置文件方式启动redis失败&lt;/li&gt;
&lt;li&gt;appendonly yes # redis持久化（可选）&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// redis.conf启动
docker run --name redis -p 6379:6379 -d \
-v /你的路径/redis.conf:/usr/local/redis/redis.conf redis \
redis-server /usr/local/redis/redis.conf \
--requirepass &quot;Password&quot; \
--appendonly yes \
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-spacer&quot; style=&quot;height:30px&quot; aria-hidden=&quot;true&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>在CentOS搭建Git仓库</title><link>https://rjomg-blog.pages.dev/posts/wp-55/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-55/</guid><pubDate>Sun, 26 Sep 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;div class=&quot;wp-block-cover is-light&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;span class=&quot;wp-block-cover__background has-background-dim-0 has-background-dim&quot; aria-hidden=&quot;true&quot;&amp;gt;&amp;lt;/span&amp;gt;&amp;lt;img src=&quot;/wp-content/uploads/2021/09/git.jpeg&quot; class=&quot;wp-block-cover__image-background wp-image-56&quot; /&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-cover__inner-container&quot;&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;目标：在Centos操作系统上面搭建一个Git仓库&lt;/p&gt;
&lt;p&gt;&amp;lt;div class=&quot;wp-block-group&quot;&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.安装Git&lt;/h2&gt;
&lt;p&gt;&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 安装扩展
$ yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel perl-devel


# 安装Git
$ yum install git
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.创建组和用户&lt;/h2&gt;
&lt;p&gt;为操作系统创建一个Git组和Git用户，用来运行git服务&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 创建Git组
$ groupadd git


# 创建Git用户
$ useradd git -g git
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3.SSH登录&lt;/h2&gt;
&lt;h3&gt;生成SSH秘钥&lt;/h3&gt;
&lt;p&gt;如果已经生成直接看下面配置SSH登录&lt;/p&gt;
&lt;h4&gt;windows&lt;/h4&gt;
&lt;p&gt;1.在Windows下查看**[c盘-&amp;gt;用户-&amp;gt;自己的用户名-&amp;gt;.ssh]*&lt;em&gt;下是否有&lt;/em&gt;&quot;id_rsa、id_rsa.pub&quot;*文件&lt;/p&gt;
&lt;p&gt;2.如果没有，在windows下安装Git，打开&lt;strong&gt;Git Bash&lt;/strong&gt;输入命令&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ ssh-keygen
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;3.输入完毕后按回车，程序会要求输入一个密码，输入完密码后按回车会要求再确认一次密码，如果不想要密码可以在要求输入密码的时候按两次回车，表示密码为空，并且确认密码为空，此时**[c盘&amp;gt;用户&amp;gt;自己的用户名&amp;gt;.ssh]**目录下已经生成好了。&lt;/p&gt;
&lt;h4&gt;CentOS&lt;/h4&gt;
&lt;p&gt;1.CentOS查看 &lt;strong&gt;[ /root/.ssh/ ]&lt;/strong&gt; 下是否有*&quot;id_rsa、id_rsa.pub&quot;*文件&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 进入.ssh目录 查看是否有&quot;id_rsa、id_rsa.pub&quot;文件 
$ cd /root/.ssh/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;2.如果不存在输入命令生成SSHkey秘钥&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ ssh-keygen
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;3.输入完毕后按回车，程序会要求输入一个密码，输入完密码后按回车会要求再确认一次密码，如果不想要密码可以在要求输入密码的时候按两次回车，表示密码为空，并且确认密码为空，此时**[ /root/.ssh/ ]**目录下已经生成好了。&lt;/p&gt;
&lt;h3&gt;配置SSH登录&lt;/h3&gt;
&lt;p&gt;公钥位于id_rsa.pub文件中，把我们的公钥导入到/home/git/.ssh/authorized_keys文件里，一行一个。&lt;/p&gt;
&lt;p&gt;如没有 authorized_keys 则需要创建&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd /home/git/
$ mkdir .ssh
$ chmod 755 .ssh
$ touch .ssh/authorized_keys
$ chmod 644 .ssh/authorized_keys
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;4.初始化Git仓库&lt;/h2&gt;
&lt;p&gt;首先我们选定一个目录作为Git仓库，假定是/home/gitrepo/xxx.git，在/home/gitrepo目录下输入命令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd /home
$ mkdir gitrepo
$ chown git:git gitrepo/
$ cd gitrepo

# xxx.git xxx是你的创库名称
$ git init --bare xxx.git
Initialized empty Git repository in /home/gitrepo/xxx.git/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;以上命令Git创建一个空仓库，服务器上的Git仓库通常都以.git结尾。然后，把仓库所属用户改为git：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ chown -R git:git xxx.git
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;5.克隆仓库&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;# 192.x.x.x 是服务器IP地址
$ git clone git@192.x.x.x:/home/gitrepo/xxx.git
Cloning into &apos;xxx&apos;...
warning: You appear to have cloned an empty repository.
Checking connectivity... done.
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;参考：&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.runoob.com/git/git-server.html&quot;&gt;菜鸟教程-Git服务器搭建&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Code</title><link>https://rjomg-blog.pages.dev/posts/wp-13/</link><guid isPermaLink="true">https://rjomg-blog.pages.dev/posts/wp-13/</guid><pubDate>Thu, 05 Aug 2021 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;测试代码&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;?php
class temp
{
    function temp(){
      echo 1;
    }
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item></channel></rss>