blog:
Blog Park:/emanjusaka
Official account: emanjusaka's programming stack
by emanjusaka from /archives/redis-performance-fast
This article is an original article, and may update knowledge points and correct some errors in the text. Please retain the original address when reprinting the full text to avoid misleading caused by not being corrected immediately.
Redis is a high-performance memory key-value database with a single thread architecture. In the official test report, stand-alone can support it10wQPS on the left and right.
Why is single-threaded Redis designed so high-performance?
Let's discuss the reasons.
I summarize the reasons into four aspects:
-
Single threaded architecture
-
Efficient data structure
-
Data is stored in memory
-
Event-driven model
Let’s analyze each aspect in detail below.
Single threaded architecture
In a multi-threaded environment, the operating system needs to frequently perform thread switching to allow different threads to obtain CPU time slices to perform tasks. Thread switching involves operations such as saving the state of the current thread, restoring the state of another thread, etc. These operations will consume a certain amount of time and system resources.
Single-threaded Redis completely avoids the overhead brought by thread switching, so that it can use CPU resources more efficiently to focus on handling client requests.
Note that when we emphasize single threading, we are referring to using a thread to handle network I/O and key-value pair read and write (file event scheduler).
That is to say, a thread handles all network requests, but other functions of Redis, such as persistence, asynchronous deletion, cluster data synchronization, etc. are actually executed by additional threads.
Efficient data structure
Redis's data structures such as strings (SDS), dictionaries (hash table implementation), linked lists, etc. are designed to take into account efficient operations in a single-threaded environment.
For example, SDS reduces the number of memory allocation and freeing through pre-allocated and lazy space release strategies, allowing string operations to be more efficient in a single-threaded environment.
The hash table implementation of the dictionary adopts a progressive rehash strategy, which avoids rehashing of a large amount of data at one time. It can smoothly expand and shrink the hash table under a single thread, and will not cause complex synchronization problems due to competition from multiple threads.
Redis has 5 data types:String 、 List 、 Hash 、 SetandSortedSet 。
Different data types are supported by one or more data structures at the bottom, with the goal of achieving faster speeds.
Data is stored in memory
Redis is entirely based on memory and data is stored in memory. Most requests are pure memory operations and are extremely fast.
Compared to traditional disk file data storage, Redis avoids the overhead of reading data from disk into memory through disk I/O.
Event-driven model
Using a threading model based on network I/O multiplexing (non-blocking I/O) can handle concurrent connections, helping to alleviate the problem of slow network I/O.
Redis uses efficient event-driven models such as epoll, kqueue, etc. to handle network I/O and time events.
When there is a client connection request or data is readable and writable, the event-driven model will notify Redis to process accordingly.
Redis 6.0 multi-threading
Redis uses a single threaded approach to achieve high maintainability. While multithreading may perform well in some ways, it introduces uncertainty in the order of program execution, leading to a series of problems with concurrent read and write. This increases the complexity of the system and can result in performance losses due to thread switching, locking and unlocking, and even deadlocking.
Redis 6.0 introduces multithreading because its bottleneck lies not in memory, but in network I/O modules, which consume CPU time. Therefore, multithreading is introduced to process network I/O, making full use of CPU resources, and reducing the performance losses caused by network I/O blocking.
Is there a thread concurrency problem in multithreaded mode?
In Redis' multithreaded mode, the receiving, sending, and parsing commands can be configured to be executed in multiple threads because they are the main time-consuming points we determine. However, command execution involving memory operations is still running in a single thread.
Therefore, the multi-threaded part of Redis is only used to handle network data read and write and protocol resolution. Command execution is still executed sequentially in a single thread, so there is no concurrency security issue.
Learn humbly in your heart, take all things in your valley, think quietly and move forward, and build a journey of harvest together!
Original address:/archives/redis-performance-fast