Why is Redis so fast?

Redis is a NoSQL database based on key-value pairs. Redis's Value can be composed of various data structures and algorithms such as String, hash, list, set, zset, Bitmaps, HyperLogLog, etc. Redis has many functions, such as key expiration, publish and subscribe, transactions, Lua scripts, sentinels, Cluster, etc.

According to official performance data, Redis can execute commands at a very fast speed, and its QPS can reach more than 100,000. So this article mainly introduces where Redis is fast, mainly including the following points:

1. Development language

Now we all use high-level languages ​​for programming, such as Java, python etc. You may think that C language is very old, but it is really useful. After all, the Unix system is implemented in C, so C language is a language that is very close to the operating system. Redis is developed in C language, so the execution will be faster.

One more thing, students should focus on learning C language because it helps to better understand the computer operating system. Don't think that after learning a high-level language, you don't have to pay attention to the bottom layer. The debt you owe will always have to be repaid. Here is a more difficult book to recommend, "In-depth Understanding of Computing Systems".

2. Pure memory access

Redis uses memory to store all data, so there is no need to read data from disk for non-data synchronization during normal operation, so The number of IOs is 0. The memory response time is about 100 nanoseconds, which is an important basis for the fast speed of Redis. Let’s first look at the speed of the CPU:

Take my computer as an example. Its main frequency is 3.1G, which means it can execute 3.1 billion instructions per second. The CPU's world view processing speed is very slow. In comparison, the memory is 100 times slower and the disk is 1,000,000 times slower. Do you think this is fast?

I borrowed a picture from "In-depth Understanding of Computer Systems", which shows a typical memory hierarchy. At the L0 layer, the CPU can access it in one clock cycle, and the SRAM-based cache is renewed. They can be accessed in a few CPU clock cycles, and then DRAM-based main memory, which can be accessed in tens to hundreds of clock cycles.

3. Single thread

Single thread can simplify the implementation of the algorithm, but it is not only difficult to implement concurrent data structures, but also difficult to test. Very troublesome. In server-side development, locks and thread switching are usually performance killers, and using a single thread can avoid the consumption they bring. Of course, single threading will also have its shortcomings, which is also Redis's nightmare: blocking. If the execution of a command is too long, it will cause other commands to be blocked, which is very fatal for Redis, so Redis is a database for fast execution scenarios.

In addition to Redis, Node.js is also single-threaded, and Nginx is also single-threaded, but they are both models of high-performance servers.

4. Non-blocking multi-channel I/O multiplexing mechanism

Before this, let’s talk about how traditional blocking I/O works: when using When read or write reads or writes a certain file descriptor (File Descriptor FD), if the data is not received, the thread will be suspended until the data is received.

Although the blocking model is easy to understand, it will not be used when multiple client tasks need to be processed.

#I/O multiplexing actually means that the management of multiple connections can be in the same process. Multi-channel refers to network connections, multiplexing is just the same thread. In network services, the role of I/O multiplexing is to notify the business code of multiple connection events at one time. The processing method is determined by the business code.

In the I/O multiplexing model, the most important function call is the I/O multiplexing function. This method can monitor the reading and writing of multiple file descriptors (fd) at the same time. When some of the fds are readable/writable, this method will return the number of readable/writable fds.

Redis uses epoll as the implementation of I/O multiplexing technology, and Redis's own event processing model converts epoll's read, write, close, etc. events without wasting too much time on network I/O. Realize monitoring of multiple FD reads and writes to improve performance.

Let’s give a vivid example. For example, a tcp server handles 20 client sockets.

A plan: Sequential processing. If the first socket is slow in reading data due to the network card, once it is blocked, the rest will be messed up.

Plan B: Create a clone sub-process for each socket request. Not to mention that each process consumes a large amount of system resources. The process switching alone is enough for the operating system to be tiring.

C scheme (I/O multiplexing model, epoll): Register the fd corresponding to the user socket into epoll (actually what is passed between the server and the operating system is not the fd of the socket but the data structure of fd_set), and then epoll Just tell which sockets need to be read/written, and only need to process those active and changing socket fds.

In this way, the entire process will only block when epoll is called, and sending and receiving customer messages will not block.

The above is the detailed content of Why is Redis so fast?. For more information, please follow other related articles on the PHP Chinese website!