echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf && echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf

2 启用配置

sysctl -p

3 查看内核是否生效

sysctl net.ipv4.tcp_available_congestion_control

显示net.ipv4.tcp_available_congestion_control = reno cubic bbr为已生效

4 查看BBR是否启动

lsmod | grep bbr

显示tcp_bbr 20480 1即为已生效

图床的基础是Minio, 但minio并不提供图片缩略和裁剪功能，所以还需要用到Imageproxy和Nginx。

基于Docker安装更方便，但是不是很想用Docker，所以采用了编译安装。

编译安装nginx

安装第三方依赖:

yum -y install gcc gcc-c++ automake pcre pcre-devel zlib zlib-devel openssl openssl-devel

创建nginx用户:

groupadd nginx
useradd nginx -g nginx -s /sbin/nologin -M

从官方下载nginx源码包并解压：

wget https://nginx.org/download/nginx-1.17.0.tar.gz
tar -zxvf nginx-1.17.0.tar.gz
cd nginx-1.17.0

配置nginx

./configure --prefix=/usr/local/nginx --conf-path=/usr/local/nginx/conf/nginx.conf --error-log-path=/var/log/nginx/error.log --modules-path=/usr/lib64/nginx/modules --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --user=nginx --group=nginx --with-http_ssl_module --with-http_v2_module --with-http_dav_module --with-http_stub_status_module --with-threads --with-file-aio --with-http_gzip_static_module

安装

make && make install

配置管理，这里是centos7:

vim /usr/lib/systemd/system/nginx.service

输入以下

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/local/nginx/sbin/nginx -t
ExecStart=/usr/local/nginx/sbin/nginx
ExecReload=/usr/local/nginx/sbin/nginx -s reload
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

启用nginx服务并设置为开机启动：

systemctl daemon-reload
systemctl start nginx.service
systemctl enable nginx.service

安装minio

直接下载minio的二进制包就可以直接使用：

cd /usr/local/bin
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio

为minio创建本地存储位置:

mkdir -p /storage

编辑minio服务器配置，其中9159是服务端口，MINIO_ACCESS_KEY是访问秘钥，MINIO_SECRET_KEY是加密秘钥：

cat <<EOT >> /etc/default/minio
\# miinio存储名
MINIO_REGION_NAME=xman
\# minio存储卷.
MINIO_VOLUMES=/storage
\# 自定义MinIo管理.
MINIO_OPTS="--address :9159"
\# 服务器Access Key.
MINIO_ACCESS_KEY=admin
\# 服务器Secret key.
MINIO_SECRET_KEY=123456789
EOT

创建minio管理：

cd /etc/systemd/system/
curl -O https://raw.githubusercontent.com/minio/minio-service/master/linux-systemd/distributed/minio.service

注意修改其中的用户及群组

启用minio服务并设置开机启动

systemctl daemon-reload
systemctl start minio.service
systemctl enable minio.service

安装imageproxy

安装go

imageproxy是go编写的一款图片缩放裁剪代理程序，所以要先安装golang环境：

下载go并解压

wget https://golang.google.cn/dl/go1.15.6.linux-amd64.tar.gz
tar -zxvf go1.15.6.linux-amd64.tar.gz

将go加入系统环境：

vim /etc/profile

在文件尾部输入:

#golang env config
export GO111MODULE=on
export GOROOT=/usr/local/go 
export GOPATH=/home/gopath
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

执行：

source /etc/profile

立即启用go

安装Aws cli
imageproxy需要 aws s3的支持，所以需要安装 aws cli

使用pip安装最新版本

yum -y install epel-release
yum -y install python-pip
pip install awscli

安装完成需要进行配置

aws configure

按照提示输入

AWS Access Key ID [None]: Q3AM3UQ867SPQQA43P2F  # 输入刚才设置的MINIO_ACCESS_KEY
AWS Secret Access Key [None]: zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG # 输入刚才设置的MINIO_SECRET_KEY
Default region name [None]: us-east-1  #输入这个就可以
Default output format [None]: 回车默认就介意
aws configure set default.s3.signature_version s3v4

配置成功后，使用aws创建存储桶以验证配置是否正确，也未下一步做准备：
创建存储桶:

aws --endpoint-url http://127.0.0.1:9159 s3 mb s3:/imageproxy

安装imageproxy
直接通过go安装:

go get willnorris.com/go/imageproxy/cmd/imageproxy

安装完成后配置管理

vim /etc/systemd/system/imageproxy.service

输入以下内容：

[Unit]
Description=ImageProxy
Documentation=https://github.com/willnorris/imageproxy
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio

[Service]
WorkingDirectory=/usr/local

User=root
Group=root

EnvironmentFile=-/etc/default/minio
ExecStartPre=/bin/bash -c "if [ -z \"${MINIO_ACCESS_KEY}\" ]; then echo \"Variable MINIO_ACCESS_KEY not set in /etc/default/minio\"; exit 1; fi"
ExecStartPre=/bin/bash -c "if [ -z \"${MINIO_SECRET_KEY}\" ]; then echo \"Variable MINIO_SECRET_KEY not set in /etc/default/minio\"; exit 1; fi"

ExecStart=/home/gopath/imageproxy  -cache "s3://us-east-1/imageproxy/thumbnail?endpoint=127.0.0.1:9159&disableSSL=1&s3ForcePathStyle=1" -addr 0.0.0.0:8001

# Let systemd restart this service always
Restart=always

# Specifies the maximum file descriptor number that can be opened by this process
LimitNOFILE=65536

# Disable timeout logic and wait until process is stopped
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target

# Built for ${project.name}-${project.version} (${project.name})

启用imageproxy并设置开机启动：

systemctl daemon-reload
systemctl start imageproxy.service
systemctl enable imageproxy.service

配置nginx反代

imageproxy和minio都提供对外的web服务，但要将二者结合就最好使用nginx反代。

服务器配置如下

server {
    listen 80;

    server_name youdomian.com;

    location ~ /thumb/ {
        rewrite ^/(?i)thumb(.*) $1 break;
        add_header Access-Control-Allow-Origin *;
        add_header Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS";
        proxy_set_header Host $proxy_host;
        proxy_set_header X-Forwarded-For  $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001;
    }

    location ~ /ImageView/ {
        rewrite ^(.*)/(?i)ImageView/(.*) /$2/http://127.0.0.1:9159$1 break;
        add_header Access-Control-Allow-Origin *;
        add_header Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS";
        proxy_set_header Host $proxy_host;
        proxy_set_header X-Forwarded-For  $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001;
    }

    location / {
        proxy_set_header Host $http_host;
        proxy_pass http://127.0.0.1:9159;
    }
}

使用

访问
http://youdomain.com/test/2.jpeg
这是直接反代到minio的

访问
http://youdomian.com/test/2.jpeg/ImageView/100
这是先反代到imageproxy， 再缩略缓存至minio的方式

访问
http://youdomian.com/thumb/100/http://youdomain.com/test/2.jpeg
这是先反代到imageproxy， 再缩略缓存至minio的方式， 和上面的方式的区别在于这是imageproxy原反代方式， 而且可以反代非minio外部站点的url

• 存储服务
• Key-Value键值对存储
• 文件系统
• 数据库
• Database Drivers

存储

• minio - Minio是一个与Amazon S3接口兼容的开源对象存储服务器。
• rclone - "云存储异步存储" - Google Drive, Amazon Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Cloudfile…
• perkeep - Perkeep是一款个人存储系统：存储、同步、共享、建模和备份个人内容。
• s3git - 云存储Git,可用于数据的分布式版本控制。
• storj - 分散的云对象存储，价格合理、易于使用、私有且安全。
• rook - 开放、云本机和通用分布式存储。
• longhorn - Longhorn是一个通过容器交付的开源持久块存储服务器。

Key-Value键值对存储

• Bitcask - Bitcask是一个可嵌入的、持久的、快速的键值（KV）数据库，使用纯Go编写，具有可预测的读/写性能、低延迟和高吞吐量，这得益于Bitcask磁盘布局（LSM+WAL）。
• Bitraft - Bitraft是一种基于raft的分布式密钥/值存储，具有与Redis兼容的协议。 它使用了 Bitcask 实现高性能/吞吐量和低延迟。
• BadgerDB - BadgerDB是一个可嵌入的、持久的、简单快速的键值（KV）数据库，用纯Go编写。它的目的是成为RocksDB等基于Go的键值存储的性能替代品。
• biscuit - Biscuit是一个多区域HA键值存储库，用于存储AWS基础设施机密。
• consul - 用于服务发现和配置的分布式一致复制键值存储。
• diskv - 磁盘备份的键值存储。
• etcd - 分布式系统中最关键数据的分布式可靠键值存储。
• go-cache - 记忆中的记忆键：值存储/缓存（类似于Memcached）library for Go，适合单机应用。
• nutsdb - Nutsdb是一个用纯Go编写的简单、快速、可嵌入、持久的键/值存储。它支持完全可序列化的事务和许多数据结构，如列表、集合、排序集。

文件系统

• afero - GO编写的文件抽象系统。
• fsnotify - Go的跨平台文件系统通知。
• gcsfuse - 与Google云存储交互的用户空间文件系统。
• git-lfs - 用于控制大文件版本的Git扩展。
• go-systemd - Go绑定到systemd套接字激活、日志、D-Bus和单元文件
• goofys - 用Go编写的高性能POSIX-ish Amazon s3文件系统。
• minikeyvalue - 1000行分布式键值存储。
• seaweedfs - SeaweedFS是一个简单且高度可扩展的分布式文件系统，适用于小文件。
• svfs - 基于fuse的Openstack Swift虚拟文件系统。

数据库

• BigCache - 针对千兆字节数据的高效键/值缓存。
• bolt - 低级键/值数据库。
• buntdb - 一个快速的、可嵌入的、内存中的键/值数据库，支持自定义索引和空间。
• cache2go - 支持时间超时自动失效的内存key/value的数据库。
• cockroach - 可扩展的地理数据存储。
• couchcache - 基于Couchbase服务器的Restful缓存微服务。
• CovenantSQL - 具有区块链功能的SQL数据库。
• dgraph - 可扩展、分布式、低延迟、高吞吐量的图形数据库。
• diskv - 自制的磁盘备份键值存储。
• eliasdb - 无依赖关系的事务性图形数据库，带有RESTAPI、短语搜索和类似SQL的查询语言。
• emitter - 可扩展、低延迟、分布式和安全的发布/子数据库，具有时间序列消息存储，适用于物联网、游戏、应用程序和实时web。
• forestdb - ForestDB的绑定。
• GCache - 缓存库，支持过期缓存、LFU、LRU和ARC。
• geocache - 适用于基于地理位置的应用程序的内存缓存。
• go-cache - 存储于内存的健/值对存储数据库(类似于memcached),适用于单机。
• goleveldb - [LevelDB] (https://github.com/google/leveldb) 健/值对数据库扩展。
• groupcache -
  Groupcache是一个缓存和缓存填充库，在许多情况下可以替代memcached。
• influxdb - 用于度量、事件和实时分析的可扩展数据存储。
• ledisdb - Ledisdb是一个基于LevelDB的高性能NoSQL类Redis。
• levigo - Levigo是LevelDB的Go包装器。
• moss - Moss是一个用100%Go编写的简单LSM键值存储引擎。
• noms - 版本化的、可分叉的、可同步的数据库。
• nutsdb - Nutsdb是一个用纯Go编写的简单、快速、可嵌入、持久的键/值存储。它支持完全可序列化的事务和许多数据结构，如列表、集合、排序集。
• piladb - 基于栈数据结构的轻量级RESTful数据库引擎。
• pREST - 提供来自任何PostgreSQL数据库的restfulapi。
• prometheus - 监控系统和时间序列数据库。
• rqlite - 基于SQLite的轻量级分布式关系数据库。
• scribble - 一个小的平面文件JSON存储。
• tidb - TiDB是一个分布式SQL数据库。灵感来自谷歌F1的设计。
• tiedot - GO写的NOSQL数据库。
• Tile38 - 具有空间索引和实时地理围栏的地理位置数据库。

数据库迁移工具

• darwin - Go数据库模式演化库
• goose - 数据库迁移工具。您可以通过创建增量SQL或Go脚本来管理数据库的发展。
• gormigrate - Gorm ORM的数据库架构迁移帮助程序。
• migrate - Database migration handling in Golang support MySQL, PostgreSQL, Cassandra, and SQLite.
• pravasan - Simple Migration tool - currently for MySQL but planning to support soon for Postgres, SQLite, MongoDB, etc.,
• soda - Database migration, creation, ORM, etc... for MySQL, PostgreSQL, and SQLite.
• sql-migrate - Database migration tool. Allows embedding migrations into the application using go-bindata.

Database tools.

• go-mysql - A go toolset to handle MySQL protocol and replication.
• go-mysql-elasticsearch - Sync your MySQL data into Elasticsearch automatically.
• kingshard - kingshard is a high performance proxy for MySQL powered by Golang.
• myreplication - MySql binary log replication listener. Support statement and row based replication.
• orchestrator - MySQL replication topology manager & visualizer
• pgweb - A web-based PostgreSQL database browser
• vitess - vitess provides servers and tools which facilitate scaling of MySQL databases for large scale web services.
• usql - universal command-line interface for SQL databases

SQL query builder, libraries for building and using SQL.

• buildsqlx - Go Database query builder library
• dat - Go Postgres Data Access Toolkit
• Dotsql - Go library that helps you keep sql files in one place and use it with ease.
• goqu - An idiomatic SQL builder and query library.
• grimoire - Grimoire is a database access layer and validation for golang. (Support: MySQL, PostgreSQL and SQLite3).
• igor - Abstraction layer for PostgreSQL that supports advanced functionality and uses gorm-like syntax.
• ozzo-dbx - Powerful data retrieval methods as well as DB-agnostic query building capabilities.
• SQLBoiler - a tool to generate a Go ORM tailored to your database schema. It is a "database-first" ORM as opposed to "code-first", and you must first create your database.
• sqrl - SQL query builder, fork of Squirrel with improved performance.
• Squirrel - Go library that helps you build SQL queries.
• xo - Generate idiomatic Go code for databases based on existing schema definitions or custom queries supporting PostgreSQL, MySQL, SQLite, Oracle, and Microsoft SQL Server.

Database Drivers

Libraries for connecting and operating databases.

• Relational Databases

  • bgc - Datastore Connectivity for BigQuery for go.
  • firebirdsql - Firebird RDBMS SQL driver for Go
  • go-adodb - Microsoft ActiveX Object DataBase driver for go that using database/sql.
  • go-bqstreamer - BigQuery fast and concurrent stream insert.
  • go-mssqldb - Microsoft MSSQL driver in go language.
  • go-oci8 - Oracle driver for go that using database/sql.
  • go-sql-driver/mysql - MySQL driver for Go.
  • go-sqlite3 - SQLite3 driver for go that using database/sql.
  • gofreetds Microsoft MSSQL driver. Go wrapper over FreeTDS.
  • pgx - PostgreSQL driver supporting features beyond those exposed by database/sql.
  • pq - Pure Go Postgres driver for database/sql.

• NoSQL Databases

  • aerospike-client-go - Aerospike client in Go language.
  • arangolite - Lightweight golang driver for ArangoDB.
  • asc - Datastore Connectivity for Aerospike for go.
  • cayley - A graph database with support for multiple backends.
  • dsc - Datastore connectivity for SQL, NoSQL, structured files.
  • dynago - Dynago is a principle of least surprise client for DynamoDB
  • go-couchbase - Couchbase client in Go
  • go-couchdb - Yet another CouchDB HTTP API wrapper for Go
  • gocb - Official Couchbase Go SDK
  • gocql - A Go language driver for Apache Cassandra.
  • gomemcache - memcache client library for the Go programming language.
  • gorethink - Go language driver for RethinkDB
  • goriak - Go language driver for Riak KV
  • mongo-go-driver - The Go driver for MongoDB
  • neo4j - Neo4j Rest API Bindings for Golang
  • Neo4j-GO - Neo4j REST Client in golang.
  • neoism - Neo4j client for Golang
  • redigo - Redigo is a Go client for the Redis database.
  • redis - Redis client for Golang
  • redis - A simple, powerful Redis client for Go.
  • redis - Redis-protocol compatible TCP servers/services.

• Search and Analytic Databases

  • bleve - A modern text indexing library for go.
  • elastic - Elasticsearch client for Go.
  • elastigo - A Elasticsearch client library.
  • skizze - A probabilistic data-structures service and storage.

• Multiple Backends

  • gokv - A simple key-value store interface and many implementations for Go (Redis, Consul, etcd, bbolt, BadgerDB, LevelDB, Memcached, DynamoDB, S3, PostgreSQL, MongoDB, CockroachDB and many more)

放个连接备用

为什么要使用MQ

1. 解耦，系统与系统之间的耦合。
2. 异步，非必要的业务逻辑可以以异步方式运行，加快响应速度
3. 消峰，减少并发

对比Redis消息队列

1. 消息消费的可靠性
   Redis没有相应的机制保证消息的消费，当消费者消费失败的时候，消息体丢失，需要手动处理, 例如用数据库、File等进行存储，以保证队列可以重新处理；

MQ一般都有消费确认机制，即使消费失败，也会自动使得消息体返回原队列，同时可全程持久化，保证消息体被正确消费；

2. 发布的可靠性
   Redis不提供发布确认，需要自行实现，而MQ通常都有发布确认功能，保证消息被发布到服务器；

3. 高可用
   Redis故障转移方案不够完美，而MQ集群通常采用磁盘、内存节点，任意单带那故障都不会影响整个队列的操作；

4. 持久化
   Redis是数据持久化到磁盘，并不是单独针对消息队列。MQ通常队列、消息都可以单独选择是否持久化到磁盘。

5. 消费者负载均衡
   Redis不提供，需要自行实现，MQ通常根据消费者情况，进行消息的均衡分发；

6. 队列监控
   Redis不提供，需要自行实现，,Q可以兼容某个队列的所有信息（内存、磁盘、消费者、生产者、速率等）。

7. 流量控制
   不提供，需要自行实现，MQ通常早服务器过载的情况下，对生产者速率进行限制，保证服务可靠性

8. 出入对性能
   高并发下，MQ的入队性能通常高于Redis。

2 RabbitMQ中Broker指什么，cluster又是指什么？

broker是指一个或多个erlong node的逻辑分组，且node导航运行着rabbitma的应用程序。

cluster是再broker基础之上，增加node之间共享元数据的约束；

3 RabbitMQ的消息基于什么传输?

由于TCP连接的创建和小会开销较大，且并发数受系统资源限制，会造成性能瓶颈，RabbitMQ使用信道的方式来传输数据。信道是建立在真实的TCP内的虚拟连接，且每条TCP连接上的信道数量没有限制；

4 RabbitMQ的消息时如何分发的？

如果队列至少有一个消费者订阅，消息将以循环的方式发送给消费者。每条消息只会分发给一个订阅的消费者（前提是消费者能够正常处理消息并进行确认）；

5 消息怎么路由？

消息理由有三部分：交换器、路由、绑定。生产者把消息发布到交换器上，绑定决定了消息如何从路由器器路由到特定的队列；消息最终到达队列，并被消费者接收；

消息发布到交换器时，消息将用于一个路由键，在消息创建时设定。

通过队列路由键，可以把队列绑定到交换器上。

消息到达交换器后，RabbitMQ会将消息的路由键与队列的路由键进行匹配，如果能够匹配到队列，则消息会投递到相应的队列中； 如果不能匹配到任何队列，消息将进入黑洞。

常用交换器有三种：

• direct：如果路由键完全匹配，消息就诶投递到相应的队列；
• fanout: 如果交换器收到消息，将会广播到所有绑定的队列上；
• topic 可以使来自不同源头的消息能够匹配到达同一个队列。

6 如何确保消息正确地发送至RabbitMQ

Rabiitmq使用发送确认模式，确保消息正确地发送到RabbitMQ.
发送确认模式：将信道设置成confirm模式（发送方确认模式），则所有在信道上发布的消息都会被指派一个唯一ID。一旦消息被投递到目的队列后，或者消息被写入磁盘后，信道会发送一个确认给生产者（包含消息唯一ID）。如果RabbitMQ内部错误从而导致消息丢失，会发送一跳未确认消息。发送方确认模式是异步的，生产者应用程序在等待确认的同事，可以继续发送消息。当确认消息到达生产者应用程序，生产者应用程序的回调方法就会被处罚来处理确认消息。

7 如何保证消息接收方消费了消息？

消费者接受每一条消息后都必须进行确认（消息接收和消息确认是两个不同操作）。只有消费者确认了消息，RabbitMQ才能安全第把消息从队列中删除。这里并没用用到超时机制，RabbitMQ仅通过Consumer的链接中断来确认会否需要重新发送消息。也就是说，只要链接不中断，Rabbitmq给了Consumer足够长的时间来处理消息。

特殊情况：

• 如果消费者接收到消息，在确认之前断开了连接或取消订阅，RabbitMQ会认为消息没有被分发，然后重新分发给下一个订阅的消费者；
• 吐过消费者接收到消息却没有确认消息，连接也未断开，则RabbitMQ认为该消费者繁忙，将不会给消费者分发更多的消息;

8 如何避免消息重复投递或重复消费？

在消息生产时，MQ内部针对每条生产者发送的消息生成一个inner-msg-id，做为去重和幂等的依据，避免重复的消息进入队列。在消息消费时，要求消息体重必须要有一个bizId做为去重和幂等的依据，避免同一消息被重复消费。

9 如何解决丢数据的问题？

生产者丢数据
开启transaction和confirm模式来保证生产者不丢消息。

transaction类似于数据库事务，发送过程中发送异常事务就会回滚。

confirm是确认机制，投递成功则发一条ACK给生产者，投递失败则发一条NACK给生产者，以便重试。

如果是rabbitmq断连，程序员异常，则需要进行异常处理，进行本地端记录，但由于无法保证全部异常都处理， 也可以将投递的消息全部存于本地后，投递成功则标记。

消息队列丢数据
开启持久化磁盘配置，配合comfirm机制，rabbitmq在持久话后，才会给生产者发送ACK。

消费者丢数据
启用手动确认模式

Redis是一个使用C语言编写，开源的高性能非关系型数据库。

Redis有5种数据存储类型，健的类型只能是字符串，值的类型可以是：字符串、列表、集合、散列表、有序集合。

Redis的数据存储在内存之中，所以读写速度非常快，每秒可以处理超过10万次数据读写操作。

优点

• 读写性能优异，读速度可达110000次/秒，写速度可达到81000次/秒；
• 支持数据持久化，支持AOF和RDB两种数据持久化；
• 支持事务，Redis所有操作都是原子性的，同时Redis还支持对几个操作合并后的原子性操作；
• 数据结构丰富，除了支持string外，还支持hash、set、zset、list等数据结构；
• 支持主从复制，主机会自动将数据同步到从机，可以进行读写分离；

缺点

• 易受物理内存限制，不能作为海量数据的高性能读写，因此适应场景主要局限在较小数据量的高性能操作和运算上；
• 不具备容错和恢复功能，主机从机的宕机都会导致前端部分读写请求失败，需要等待机器重启或手动切换前端IP才能恢复；
• 主机宕机，宕机前有部分数据未能及时同步到从机，切换IP后还会引发数据不一致问题，降低可用性；
• Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。为避免这一问题，运维人员在系统上线时必须确保有足够的空间，这会对资源造成很大的浪费；

2 Redis为什么会这么快？

1. 完全基于内存，绝大部分请求也是纯粹的内存操作，所以非常快速。数据在内存中，类似于HashMap，时间复杂度是O(1)
2. 数据结构简单，所以数据操作也简单，这些数据结构是专门设计的。
3. 采用单线程，这就避免了不必要的上下文切换和竞争条件，也不存在多进程或多线程导致的切换而消耗CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而出现的性能损耗；
4. 使用多路I/O复用模型，非阻塞型IO；
5. 使用底层模型不同，他们之间底层实现方式以及客户端之间通讯的应用协议不一样，Redis直接构建了自己的VM机制，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；

3 Redis有哪些数据类型，分别应用在什么场景?

string
可以存储字符串、整数、浮点数，适用于简单的健值对存储。
应用场景：

• 分布式锁
• 计数
• 序列化对象

hash
键值对集合，适用于存储结构化数据，例如对象。

list
列表，可以从两端插入和弹出，按照插入顺序排序。适用于存储消息队列，有序数据。

set
string无序集合，通过hash表实现。可执行交、并、差的操作，适用于例如粉丝列表等。

zset
有序集合。可去重，可排序。

4 Redis有哪些持久化方式？优缺点分别是什么？

持久化是将内存数据写到磁盘中去，防止宕机数据丢失。

Rds提供了两种持久化方式，RDB和AOF

RDB
快早持久化，默认持久化方式。Redis可以通过创建快照来获得存储在内存里面的数据在某个时间点上的副本，Redis创建快照后，可以对快照进行备份，可以将快照复制到其它服务器从而创建具有相同数据的服务器副本，还可以将快照留在原地以便重启服务器的时候使用。

redis.conf配置

save 900 10

在300秒之后，如果至少有10个KEY发生变化，REDIS就会自动触发BGSAVE命令创建快照。

AOF
AOF持久化实时性更好，是目前主流的持久化方案，开启AOF命令：

appendonly yes

开启AOF持久化后每执行一条会更改Redis中的数据的命令，Redis就会将该命令写入磁盘的AOF文件。AOF文件的保存位置和RDB文件的位置相同，都是通过DIR参数设置的，默认的文件名appendonly.aof

AOF可以配置三种不同的持久化方式

1. appednfsync always
   每次有数据修改发生时都会写入AOF文件，这种方式会严重降低Redis的速度

2. appendfsync everysec
   每秒钟同步一次，显式地将多个写命令同步到硬盘

3. appendfsync no
   让操作系统决定何时进行同步

为了兼顾数据和写入性能，用户可以考虑appendfsync everysec玄子昂，让redis美妙同步一次AOF文件，Redis性能几乎没有收到任何影响。而且这样即使出现系统奔溃，用户最多只会丢失疫苗之内产生的数据。当硬盘忙于执行写入操作的时候，Redis还会优雅的放慢自己的速度以便适应硬盘的的最大写入速度。

混合持久化
Redis4.0开始支持，AOF重写的时候就直接把RDB的内容写到AOF文件开头。这样做综合了RDB和AOF的有点，快速加载同时避免丢失过多的数据。缺点是，AOF里面的RDB部分是压缩格式不再是AOF格式，可读性差。

5 什么是缓存雪崩和缓存穿透，如何解决？

缓存雪崩

缓存同意时间大面积失效，后续请求落到数据库上，造成数据库短时间内承受大量请求而崩掉。

解决办法：

• 保证redis集群的高可用性，发现有机器宕机就尽快补上，选择合适的内存淘汰策略；
• 系统上线前，对缓存进行预热；
• 让缓存的过期时间合理均匀分布；
• 加排斥锁；
• 缓存过期标记+异步刷新

缓存穿透
黑客故意请求缓存中不存在的数据，导致所有请求都落到数据库上，造成数据库短时间内承受大量请求而崩掉。

解决办法：

• 最简单的办法就是将空结果进行缓存，但是不要太长时间；
• 复杂一点的办法就是使用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，不存在的数据肯定会被bitmap兰及诶啊哦。

6 如何解决Redis并发竞争Key问题？

多个系统同时对一个KEY进行操作，但是最后执行的顺序和我们期望的殊勋不同，这样就导致了结果的不同。

解决办法：
使用分布式锁。
基于zookeeper临时有序节点可以实现分布式锁，大致思想为:每个客户端对某个方法加锁时，在zookeeper上的域该方法对应的指定节点的目录下，生成一个唯一的瞬时有序节点。判断是否货物所的方式很简单，值需要判断有序节点中序号最小的一个。当锁释放的时候，只需要将这个瞬时节点删除即可。同时，其可以表面服务宕机导致的锁无法释放，而产生的死锁问题。完成业务流程后，删除对应的子节点释放锁。

7 Redis如何实现分布式锁？

1. 加锁
   NX操作，写入随机值，设置鬼泣时间，避免死锁。

2. 解锁
   解锁必须确保操作的原子性，所以需要借助LUA先判断随机值是否相等再解锁

8 详述Redis过期策略和内存淘汰机制？

定时删除

1. 设置键的过期时间时，创建一个Timer, 当过期时间到临时，立刻删除键；
2. 内存友好型策略，一旦键过期，就会被删除，并释放所占用的内存，CPU不友好，当一批数量比较多的键过期时，正好遇上CPU紧张的时段，这时候需要的事CPU处理能力，而不是内存。显然CPU时间用在删除过期键上，会对服务器的响应时间和吞吐量造成影响。另外当前Redis时间事件无法搞笑处理大量时间事件，所以定时删除并不是一种号的定时删除策略。

Redis默认每个100ms检查，随机抽取KEY进行检查，如果过期则删除，这种操作十分消耗CPU资源。

惰性删除
不管过期的键，在这种策略下，当键在空间中被取出时，首先检查取出的键是否过期，若过期删除该键，否则，返回该键；

定期删除
即内存淘汰策略：

• noeviction ： 当内存不足以容纳新写入数据时，新写入操作会报错；
• allkeys-lru ：当内存不足以容纳新写入数据时，在键空间红，移除最近最少使用的KEY；
• allkeys-random : 当内存布椅子容纳新写入数据时，在键空间中，随机移除某个KEY；
• volatile-lru ： 当内存不足以容纳写入数据时，在这是了过期时间的键空间中，移除最近最少使用的KEY。 这种情况一般是把Redis即当缓存，又做持久化存储的时候采用。
• volatile-random： 当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的KEY优先移除。

9 如何保证缓存与数据库双写时的数据一致性？

数据库和缓存双鞋，就必然会存在不一致的问题。有强一致性的场景，就不能做缓存。

做缓存则代表取最终一致性：

1. 采取正确的更新策略，先更新数据库，再删除缓存
2. 如果存在删除缓存失败，提供补偿措施，例如利用消息队列

10 Redis适合那些场景？

1. Sesion共享（单点登录）
2. 页面缓存
3. 消息队列
4. 分布式锁
5. 排行榜/计数器
6. 发布订阅