- Kendalian kelompok (talian paip) tidak disokong.
- Data disalin secara tak segerak, konsistensi data yang kukuh tidak dijamin.
- Sokongan operasi transaksi adalah terhad, dan hanya menyokong operasi transaksi berbilang
key pada nod yang sama Fungsi transaksi tidak boleh digunakan apabila berbilang key diedarkan pada berbeza nod. key, sebagai butiran minimum pembahagian data, tidak boleh memetakan objek nilai kunci yang besar seperti hash, list, dsb. ke nod yang berbeza. - Tidak menyokong berbilang ruang pangkalan data Redis dalam mod bersendirian boleh menyokong sehingga 16 pangkalan data, tetapi hanya 1 ruang pangkalan data boleh digunakan dalam mod kluster.
Strategi pemadaman untuk kunci tamat tempoh?
1. Pemadaman pasif (malas) . Apabila mengakses kunci, jika didapati bahawa kunci telah tamat tempoh, kunci akan dipadamkan.
2. Padam secara aktif (secara kerap) . Kekunci bersih dengan kerap. Setiap pembersihan akan melintasi semua DB dalam urutan, mengeluarkan 20 kekunci secara rawak dari db, dan memadamnya jika ia tamat tempoh, kemudian teruskan membersihkan db ini, jika tidak, mula membersihkan db seterusnya.
3. Bersihkan apabila ingatan tidak mencukupi. Redis mempunyai had memori maksimum Memori maksimum boleh ditetapkan melalui parameter maxmemory Apabila memori yang digunakan melebihi memori maksimum yang ditetapkan, memori mesti dikeluarkan Apabila memori dilepaskan, memori akan dibersihkan mengikut strategi penghapusan yang dikonfigurasikan.
Apakah strategi penghapusan ingatan?
Apabila memori Redis melebihi memori maksimum yang dibenarkan, Redis akan mencetuskan strategi penghapusan memori dan memadamkan beberapa data yang jarang digunakan untuk memastikan operasi normal pelayan Redis.
Redisv4.0 menyediakan 6 strategi penghapusan data :
- volatile-lru: LRU (
Least Recently Used), digunakan baru-baru ini. Gunakan algoritma LRU untuk mengalih keluar kunci dengan masa tamat tempoh ditetapkan - allkeys-lru: Apabila memori tidak mencukupi untuk menampung data yang baru ditulis, keluarkan kunci yang paling kurang digunakan daripada set data
- volatile-ttl: Pilih data yang akan tamat tempoh daripada set data dengan set masa tamat dan hapuskannya
- volatile-random: Pilih data daripada set data dengan set masa tamat tempoh Pilih data secara rawak untuk dihapuskan daripada set data
- allkeys-random: Pilih data untuk dihapuskan sewenang-wenangnya daripada set data
- tiada pengusiran: Larang pemadaman data apabila Apabila memori tidak mencukupi untuk menampung data yang baru ditulis, operasi tulis baharu akan melaporkan ralat
Selepas Redisv4.0, dua jenis berikut telah ditambahkan:
- volatile-lfu: LFU, Least Frequently Used, least used, memilih data yang paling kurang kerap digunakan daripada set data dengan masa tamat dan menghapuskannya.
- allkeys-lfu: Apabila memori tidak mencukupi untuk menampung data yang baru ditulis, alih keluar kekunci yang paling kurang kerap digunakan daripada set data.
Strategi penghapusan memori boleh diubah suai melalui fail konfigurasi Item konfigurasi yang sepadan ialah maxmemory-policy dan konfigurasi lalai ialah noeviction.
Bagaimana untuk memastikan konsistensi data semasa penulisan dua kali antara cache dan pangkalan data?
1. Padamkan cache dahulu dan kemudian kemas kini pangkalan data
Apabila melakukan operasi kemas kini, padamkan cache dahulu dan kemudian kemas kini pangkalan data apabila permintaan berikutnya dibaca semula , data akan dibaca daripada pangkalan data Selepas membaca, data baharu dikemas kini ke cache.
Masalah sedia ada: Selepas memadamkan data cache dan sebelum mengemas kini pangkalan data, jika terdapat permintaan baca baharu dalam tempoh masa ini, data lama akan dibaca daripada pangkalan data dan ditulis semula ke dalam cache, menyebabkan ketidakkonsistenan lagi. Dan semua bacaan seterusnya adalah data lama.
2. Kemas kini pangkalan data dahulu dan kemudian padamkan cache
Apabila melakukan operasi kemas kini, kemas kini MySQL dahulu Selepas berjaya, padamkan cache, dan kemudian tambah data baharu kepada permintaan baca seterusnya.
Masalah sedia ada: Dalam tempoh antara mengemas kini MySQL dan memadam cache, permintaan membaca data cache lama Walau bagaimanapun, apabila kemas kini pangkalan data selesai, ia akan menjadi konsisten dan kesannya akan agak kecil.
3. Cache kemas kini tak segerak
Selepas operasi kemas kini pangkalan data selesai, cache tidak dikendalikan secara langsung, tetapi arahan operasi dirangkumkan ke dalam mesej dan dibuang ke dalam baris gilir mesej, dan kemudian Redis sendiri menggunakan dan mengemas kini data, dan baris gilir mesej boleh memastikan konsistensi urutan operasi data dan memastikan bahawa data dalam sistem cache adalah normal.
Penembusan cache, avalanche cache, pecahan cache [penjelasan terperinci] Pecahan cache Redis, penembusan, konsep dan penyelesaian avalanche
Penembusan cache
Penembusan cache merujuk kepada pertanyaan data yang tidak wujud Memandangkan cache ditulis secara pasif apabila terdapat kesilapan, jika data tidak ditemui daripada DB, ia tidak akan ditulis kepada. cache. Ini akan menyebabkan data yang tidak wujud akan ditanya dalam DB setiap kali ia diminta, kehilangan makna caching. Apabila trafik sesak, DB mungkin tergantung.
布隆过滤器的原理：当一个元素被加入集合时，通过K个散列函数将这个元素映射成一个位数组中的K个点，把它们置为1。查询时，将元素通过散列函数映射之后会得到k个点，如果这些点有任何一个0，则被检元素一定不在，直接返回；如果都是1，则查询元素很可能存在，就会去查询Redis和数据库。
缓存雪崩
缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重挂掉。
解决方法：在原有的失效时间基础上增加一个随机值，使得过期时间分散一些。
缓存击穿
缓存击穿：大量的请求同时查询一个 key 时，此时这个 key 正好失效了，就会导致大量的请求都落到数据库。缓存击穿是查询缓存中失效的 key，而缓存穿透是查询不存在的 key。
解决方法：加分布式锁，第一个请求的线程可以拿到锁，拿到锁的线程查询到了数据之后设置缓存，其他的线程获取锁失败会等待50ms然后重新到缓存取数据，这样便可以避免大量的请求落到数据库。
public String get(String key) {
String value = redis.get(key);
if (value == null) {
//缓存值过期
String unique_key = systemId + ":" + key;
//设置30s的超时
if (redis.set(unique_key, 1, 'NX', 'PX', 30000) == 1) { //设置成功
value = db.get(key);
redis.set(key, value, expire_secs);
redis.del(unique_key);
} else {
//其他线程已经到数据库取值并回写到缓存了，可以重试获取缓存值
sleep(50);
get(key); //重试
}
} else {
return value;
}
}Salin selepas log masuk
pipeline的作用？
redis客户端执行一条命令分4个过程：发送命令、命令排队、命令执行、返回结果。使用pipeline可以批量请求，批量返回结果，执行速度比逐条执行要快。
使用pipeline组装的命令个数不能太多，不然数据量过大，增加客户端的等待时间，还可能造成网络阻塞，可以将大量命令的拆分多个小的pipeline命令完成。
原生批命令（mset和mget）与pipeline对比：
LUA脚本
Redis 通过 LUA 脚本创建具有原子性的命令：当lua脚本命令正在运行的时候，不会有其他脚本或 Redis 命令被执行，实现组合命令的原子操作。
在Redis中执行Lua脚本有两种方法：eval和evalsha。eval命令使用内置的 Lua 解释器，对 Lua 脚本进行求值。
//第一个参数是lua脚本，第二个参数是键名参数个数，剩下的是键名参数和附加参数
> eval "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second
1) "key1"
2) "key2"
3) "first"
4) "second"Salin selepas log masuk
lua脚本作用
1、Lua脚本在Redis中是原子执行的，执行过程中间不会插入其他命令。
2、Lua脚本可以将多条命令一次性打包，有效地减少网络开销。
应用场景
举例：限制接口访问频率。
在Redis维护一个接口访问次数的键值对，key是接口名称，value是访问次数。每次访问接口时，会执行以下操作：
- 通过
aop拦截接口的请求，对接口请求进行计数，每次进来一个请求，相应的接口访问次数count加1，存入redis。 - 如果是第一次请求，则会设置
count=1，并设置过期时间。因为这里set()和expire()组合操作不是原子操作，所以引入lua脚本，实现原子操作，避免并发访问问题。 - 如果给定时间范围内超过最大访问次数，则会抛出异常。
private String buildLuaScript() {
return "local c" +
"\nc = redis.call('get',KEYS[1])" +
"\nif c and tonumber(c) > tonumber(ARGV[1]) then" +
"\nreturn c;" +
"\nend" +
"\nc = redis.call('incr',KEYS[1])" +
"\nif tonumber(c) == 1 then" +
"\nredis.call('expire',KEYS[1],ARGV[2])" +
"\nend" +
"\nreturn c;";
}
String luaScript = buildLuaScript();
RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.class);
Number count = redisTemplate.execute(redisScript, keys, limit.count(), limit.period());Salin selepas log masuk
PS：这种接口限流的实现方式比较简单，问题也比较多，一般不会使用，接口限流用的比较多的是令牌桶算法和漏桶算法。
更多编程相关知识，请访问：编程入门！！
Atas ialah kandungan terperinci 20 soalan yang mesti dikuasai dalam Redis, datang dan kumpulkan! !. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
