Analisis mendalam mengapa Redis begitu pantas?

Kita semua tahu bahawa Redis sangat pantas, dan QPSnya boleh mencapai 100,000 (permintaan sesaat). Mengapa Redis begitu pantas , artikel ini akan membolehkan anda belajar bersama. [Cadangan berkaitan: Tutorial video Redis]

Pelaksanaan berasaskan memori

Kita semua tahu bahawa membaca dan menulis memori lebih pantas daripada membaca dan menulis cakera Banyak. Redis ialah pangkalan data yang dilaksanakan berdasarkan storan memori Berbanding dengan pangkalan data di mana data disimpan pada cakera, penggunaan I/O cakera dihapuskan. Pangkalan data cakera seperti MySQL perlu mencipta indeks untuk mempercepatkan kecekapan pertanyaan, manakala data Redis disimpan dalam ingatan dan beroperasi terus pada memori, jadi ia sangat pantas.

Struktur data yang cekap

Kami tahu bahawa untuk meningkatkan kecekapan, indeks MySQL memilih struktur data B-tree. Malah, struktur data yang munasabah boleh menjadikan aplikasi/program anda lebih pantas. Mari kita lihat struktur data & gambar rajah pengekodan dalaman Redis:

rentetan dinamik ringkas SDS

struct sdshdr { //SDS简单动态字符串
    int len;    //记录buf中已使用的空间
    int free;   // buf中空闲空间长度
    char buf[]; //存储的实际内容
}

Pemprosesan panjang rentetan

Dalam bahasa C, untuk mendapatkan panjang rentetan 捡田螺的小男孩, anda perlu melintasinya dari awal, dan kerumitannya ialah O(n); Dalam Redis, sudah ada medan len untuk merekodkan panjang rentetan semasa Anda boleh mendapatkannya secara langsung dan kerumitan masa ialah O(1).

Kurangkan bilangan pengagihan semula memori

Dalam bahasa C, mengubah suai rentetan memerlukan pengagihan semula memori Semakin kerap pengubahsuaian, semakin kerap peruntukan memori dan memperuntukkan memori akan menjadi Penggunaan. prestasi. Dalam Redis, SDS menyediakan dua strategi pengoptimuman: pra-peruntukan ruang dan pelepasan ruang malas.

Pra-peruntukan ruang

Apabila pengubahsuaian rentetan dinamik mudah SDS dan pengembangan ruang, selain memperuntukkan ruang memori yang diperlukan, ruang tambahan yang tidak digunakan akan diperuntukkan. Peraturan peruntukan berwarna ungu:

• Selepas SDS diubah suai, jika panjang len kurang daripada 1M, maka ruang tambahan yang tidak digunakan sama panjang dengan len akan diperuntukkan. Contohnya, len=100, selepas pengagihan semula, panjang sebenar buf akan menjadi 100 (ruang terpakai) 100 (ruang tambahan) 1 (aksara nol) = 201.
• Selepas SDS diubah suai, panjang lensa lebih besar daripada 1M, maka program akan memperuntukkan 1M ruang yang tidak digunakan.

Lazy space release

Apabila SDS dipendekkan, bukannya menuntut semula ruang memori yang berlebihan, percuma digunakan untuk merekodkan lebihan ruang. Jika terdapat operasi pengubahsuaian seterusnya, ruang dalam percuma akan digunakan terus untuk mengurangkan peruntukan memori.

Hash

Redis ialah pangkalan data dalam memori K-V, yang menggunakan cincang global untuk menyimpan semua pasangan nilai kunci. Jadual cincang ini terdiri daripada berbilang baldi cincang. *key*value*key*value

HashMap di Jawa, yang membolehkan kami melakukannya dalam

Cari pasangan nilai kunci dengan cepat dengan kerumitan masa yang kurang. Mula-mula, hitung nilai cincang melalui kunci, cari lokasi baldi cincang yang sepadan, kemudian cari entri dan cari data yang sepadan dalam entri. Sesetengah rakan mungkin mempunyai soalan: apabila anda menulis sejumlah besar data ke dalam jadual cincang, tidakkah anda akan menghadapi masalah konflik cincang dan kecekapan akan berkurangan.

Konflik cincang:

Untuk menyelesaikan konflik cincang, Redis menggunakan pencincangan rantai

. Pencincangan berantai bermakna berbilang elemen dalam baldi cincang yang sama disimpan dalam senarai terpaut, dan ia disambungkan secara bergilir menggunakan penunjuk.

Untuk mengekalkan kecekapan, Redis akan melakukan

pada jadual cincang, yang bermaksud menambah baldi cincang dan mengurangkan konflik. Untuk menjadikan rehash lebih cekap, Redis juga menggunakan dua jadual cincang global secara lalai, satu untuk kegunaan semasa, dipanggil jadual cincang utama, dan satu untuk pengembangan, dipanggil jadual cincang sandaran.

跳跃表

跳跃表是Redis特有的数据结构，它其实就是在链表的基础上，增加多级索引，以提高查找效率。跳跃表的简单原理图如下:

• 每一层都有一条有序的链表，最底层的链表包含了所有的元素。
• 跳跃表支持平均 O（logN）,最坏 O（N）复杂度的节点查找，还可以通过顺序性操作批量处理节点。

压缩列表ziplist

压缩列表ziplist是列表键和字典键的的底层实现之一。它是由一系列特殊编码的内存块构成的列表， 一个ziplist可以包含多个entry， 每个entry可以保存一个长度受限的字符数组或者整数，如下：

• zlbytes ：记录整个压缩列表占用的内存字节数
• zltail: 尾节点至起始节点的偏移量
• zllen : 记录整个压缩列表包含的节点数量
• entryX: 压缩列表包含的各个节点
• zlend : 特殊值0xFF(十进制255)，用于标记压缩列表末端

由于内存是连续分配的，所以遍历速度很快。。

合理的数据编码

Redis支持多种数据基本类型，每种基本类型对应不同的数据结构，每种数据结构对应不一样的编码。为了提高性能，Redis设计者总结出，数据结构最适合的编码搭配。

Redis是使用对象（redisObject）来表示数据库中的键值，当我们在 Redis 中创建一个键值对时，至少创建两个对象，一个对象是用做键值对的键对象，另一个是键值对的值对象。

//关注公众号：捡田螺的小男孩
typedef struct redisObject{
    //类型
   unsigned type:4;
   //编码
   unsigned encoding:4;
   //指向底层数据结构的指针
   void *ptr;
    //...
 }robj;

redisObject中，type 对应的是对象类型，包含String对象、List对象、Hash对象、Set对象、zset对象。encoding 对应的是编码。

• String：如果存储数字的话，是用int类型的编码;如果存储非数字，小于等于39字节的字符串，是embstr；大于39个字节，则是raw编码。
• List：如果列表的元素个数小于512个，列表每个元素的值都小于64字节（默认），使用ziplist编码，否则使用linkedlist编码
• Hash：哈希类型元素个数小于512个，所有值小于64字节的话，使用ziplist编码,否则使用hashtable编码。
• Set：如果集合中的元素都是整数且元素个数小于512个，使用intset编码，否则使用hashtable编码。
• Zset：当有序集合的元素个数小于128个，每个元素的值小于64字节时，使用ziplist编码，否则使用skiplist（跳跃表）编码

合理的线程模型

单线程模型：避免了上下文切换

Redis是单线程的，其实是指Redis的网络IO和键值对读写是由一个线程来完成的。但Redis的其他功能，比如持久化、异步删除、集群数据同步等等，实际是由额外的线程执行的。

Redis的单线程模型，避免了CPU不必要的上下文切换和竞争锁的消耗。也正因为是单线程，如果某个命令执行过长（如hgetall命令），会造成阻塞。Redis是面向快速执行场景的内存数据库，所以要慎用如lrange和smembers、hgetall等命令。

什么是上下文切换？举个粟子：

• 比如你在看一本英文小说，你看到某一页，发现有个单词不会读，你加了个书签，然后去查字典。查完字典后，你回来从书签那里继续开始读，这个流程就很舒畅。
• 如果你一个人读这本书，肯定没啥问题。但是如果你去查字典的时候，别的小伙伴翻了一下你的书，然后溜了。你再回来看的时候，发现书不是你看的那一页了，你得花时间找到你的那一页。
• 一本书，你一个人怎么看怎么打标签都没事，但是人多了翻来翻去，这本书各种标记就很乱了。可能这个解释很粗糙，但是道理应该是一样的。

I/O 多路复用

什么是I/O多路复用？

• I/O: Rangkaian I/O
• Berbilang: berbilang sambungan rangkaian
• Multiplexing: menggunakan semula benang yang sama.
• Pemultipleksan IO sebenarnya ialah model IO segerak, yang melaksanakan urutan yang boleh memantau berbilang pemegang fail apabila pemegang fail sedia, ia boleh memberitahu aplikasi untuk melaksanakan operasi baca dan tulis yang sepadan; sudah siap, aplikasi akan disekat dan CPU akan diserahkan.

Teknologi pemultipleksan I/O berbilang membenarkan benang tunggal mengendalikan permintaan sambungan berbilang dengan cekap, dan Redis menggunakan epoll sebagai I/O Pelaksanaan teknologi pemultipleksan . Selain itu, model pemprosesan acara Redis sendiri menukar sambungan, membaca, menulis dan menutup dalam epoll kepada peristiwa, tanpa membuang terlalu banyak masa pada rangkaian I/O.

Mekanisme Memori Maya

Redis membina mekanisme VMnya sendiri secara langsung tidak memanggil fungsi sistem seperti sistem biasa dan membuang masa tertentu untuk bergerak dan meminta.

Apakah mekanisme ingatan maya Redis?

Mekanisme memori maya menukar sementara data yang jarang diakses (data sejuk) dari memori ke cakera, dengan itu membebaskan ruang memori yang berharga untuk data lain yang perlu diakses (data panas). ). Fungsi VM boleh merealisasikan pemisahan data panas dan sejuk, supaya data panas masih dalam ingatan dan data sejuk disimpan ke cakera. Ini boleh mengelakkan masalah kelajuan capaian perlahan yang disebabkan oleh memori yang tidak mencukupi.

Untuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati: Video Pengaturcaraan! !

Atas ialah kandungan terperinci Analisis mendalam mengapa Redis begitu pantas?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!