Why does Redis use single thread?
Overhead of multi-threading
If there is no good system design, using multi-threading will usually lead to the results shown on the right (note the ordinate). When you first increase the number of threads, the system throughput rate will increase. When you further increase the number of threads, the system throughput rate will increase slowly or even decrease.
The key bottleneck is: There are usually shared resources in the system that are accessed by multiple threads at the same time. In order to ensure the correctness of shared resources, additional mechanisms are needed to ensure that threads Security, such as locking, comes with additional overhead.
For example, take the most commonly used List
type. Assume that Redis adopts a multi-thread design, and there are two threads A and B doing on
List respectively. For LPUSH
and LPUSH
operations, in order to achieve the same result every time they are executed, that is, [B thread takes out the data put by A thread], these two processes need to be executed serially. This is the concurrent access control problem of shared resources faced by the multi-threaded programming model.
Concurrency access control has always been a difficult issue in multi-threaded development: if you simply use a mutex, even if threads are added, most threads will It is also waiting to acquire the mutex lock, and the parallel becomes serial. The system throughput rate does not increase with the increase of threads.
At the same time, adding concurrent access control will also reduce the readability and maintainability of the system code, so Redis simply adopts single-threaded mode.
Why is Redis so fast using single thread?
The reason why single thread is used is the result of many aspects of Redis designers' evaluation.
Most operations of Redis are completed in memory
-
Using efficient data structures, such as hash tables and skip tables
Adopts a multiplexing mechanism so that it can handle a large number of client requests concurrently in network IO operations and achieve high throughput
Since Redis uses a single thread for IO. If the thread is blocked, it cannot be multiplexed. So it is not difficult to imagine that Redis must have been designed for potential blocking points in network and IO operations.
Potential blocking points of network and IO operations
In network communication, in order to process a Get request, the server needs to listen to the client request (bind/listen
), and The client establishes a connection (accept
), reads the request from the socket (recv
), parses the request sent by the client (parse
), and finally returns it to the client Result(send
).
The most basic single-threaded implementation is to perform the above operations in sequence.
The accept and recv operations marked in red above are potential blocking points:
When Redis monitors a connection request, But when the connection cannot be successfully established, it will be blocked in the
accept()
function, and other clients cannot establish a connection with Redis at this timeWhen When Redis reads data from a client through
recv()
, if the data has not arrived, it will always block
High performance based on multiplexing IO model
In order to solve the blocking problem in IO, Redis adopts the Linux IO multiplexing mechanism, which allows multiple listening sockets and connected sockets to exist simultaneously in the kernel (select/epoll
).
The kernel will always listen for connections or data requests on these sockets. Redis will process incoming requests, thereby achieving the effect of one thread processing multiple IO streams.
At this time, the Redis thread will not be blocked on a specific client request processing, so it can connect to multiple clients at the same time and process requests.
Callback mechanism
select/epoll Once it detects that a request arrives on FD, the corresponding event will be triggered and put into a queue. The Redis thread will continuously process the event queue. So event-based callbacks are implemented.
For example, Redis will register the accept
and get
callback functions for Accept and Read events. When the Linux kernel monitors a connection request or a read data request, it will trigger the Accept event and Read event. At this time, the kernel will call back the corresponding accept
and get
functions of Redis. deal with.
Performance bottlenecks of Redis
After the above analysis, although multiple client requests can be monitored at the same time through the multiplexing mechanism, Redis still has some performance bottlenecks, which is why we A situation that needs to be avoided in daily programming.
1. Time-consuming operations
If any request takes a long time in Redis, it will have an impact on the performance of the entire server. Subsequent requests must wait for the previous time-consuming request to be processed before they can be processed.
We need to avoid this when designing business scenarios; Redis's lazy-free
mechanism also puts the time-consuming operation of releasing memory in an asynchronous thread for execution.
2. High concurrency scenario
When the amount of concurrency is very large, there is a performance bottleneck in single-threaded reading and writing of client IO data. Although the IO multiplexing mechanism is used, it can still only be single-threaded. Reading the client's data in sequence cannot utilize multiple CPU cores.
Redis in 6.0 can use CPU multi-core and multi-threading to read and write client data, but only the reading and writing for the client are parallel, and the actual operation of each command is still single-threaded.
Other interesting questions related to Redis
Take this opportunity to also ask a few interesting questions related to redis.
Why use Redis? Isn’t it bad to directly access the memory?
This one is actually not very clearly defined. For some data that does not change frequently, it can be placed directly in the memory. It does not have to be placed in Redis. It can be placed in the memory. . There may be consistency issues when updating data, that is, the data on only one server may be modified, so the data only exists in local memory. Accessing the Redis server can solve the consistency problem, using Redis.
What should I do if there is too much data that cannot be stored in the memory? For example, if I want to cache 100G of data, what should I do?
There is also an advertisement here. Tair is Taobao's open source distributed KV cache system. It inherits rich operations from Redis. Theoretically, the total data volume is unlimited. It is aimed at usability and resiliency. The scalability and reliability have also been upgraded. Interested friends can find out~
The above is the detailed content of Why is Redis so fast using single thread?. For more information, please follow other related articles on the PHP Chinese website!

The main difference between Redis and SQL databases is that Redis is an in-memory database, suitable for high performance and flexibility requirements; SQL database is a relational database, suitable for complex queries and data consistency requirements. Specifically, 1) Redis provides high-speed data access and caching services, supports multiple data types, suitable for caching and real-time data processing; 2) SQL database manages data through a table structure, supports complex queries and transaction processing, and is suitable for scenarios such as e-commerce and financial systems that require data consistency.

Redisactsasbothadatastoreandaservice.1)Asadatastore,itusesin-memorystorageforfastoperations,supportingvariousdatastructureslikekey-valuepairsandsortedsets.2)Asaservice,itprovidesfunctionalitieslikepub/submessagingandLuascriptingforcomplexoperationsan

Compared with other databases, Redis has the following unique advantages: 1) extremely fast speed, and read and write operations are usually at the microsecond level; 2) supports rich data structures and operations; 3) flexible usage scenarios such as caches, counters and publish subscriptions. When choosing Redis or other databases, it depends on the specific needs and scenarios. Redis performs well in high-performance and low-latency applications.

Redis plays a key role in data storage and management, and has become the core of modern applications through its multiple data structures and persistence mechanisms. 1) Redis supports data structures such as strings, lists, collections, ordered collections and hash tables, and is suitable for cache and complex business logic. 2) Through two persistence methods, RDB and AOF, Redis ensures reliable storage and rapid recovery of data.

Redis is a NoSQL database suitable for efficient storage and access of large-scale data. 1.Redis is an open source memory data structure storage system that supports multiple data structures. 2. It provides extremely fast read and write speeds, suitable for caching, session management, etc. 3.Redis supports persistence and ensures data security through RDB and AOF. 4. Usage examples include basic key-value pair operations and advanced collection deduplication functions. 5. Common errors include connection problems, data type mismatch and memory overflow, so you need to pay attention to debugging. 6. Performance optimization suggestions include selecting the appropriate data structure and setting up memory elimination strategies.

The applications of Redis in the real world include: 1. As a cache system, accelerate database query, 2. To store the session data of web applications, 3. To implement real-time rankings, 4. To simplify message delivery as a message queue. Redis's versatility and high performance make it shine in these scenarios.

Redis stands out because of its high speed, versatility and rich data structure. 1) Redis supports data structures such as strings, lists, collections, hashs and ordered collections. 2) It stores data through memory and supports RDB and AOF persistence. 3) Starting from Redis 6.0, multi-threaded I/O operations have been introduced, which has improved performance in high concurrency scenarios.

RedisisclassifiedasaNoSQLdatabasebecauseitusesakey-valuedatamodelinsteadofthetraditionalrelationaldatabasemodel.Itoffersspeedandflexibility,makingitidealforreal-timeapplicationsandcaching,butitmaynotbesuitableforscenariosrequiringstrictdataintegrityo


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

MinGW - Minimalist GNU for Windows
This project is in the process of being migrated to osdn.net/projects/mingw, you can continue to follow us there. MinGW: A native Windows port of the GNU Compiler Collection (GCC), freely distributable import libraries and header files for building native Windows applications; includes extensions to the MSVC runtime to support C99 functionality. All MinGW software can run on 64-bit Windows platforms.

ZendStudio 13.5.1 Mac
Powerful PHP integrated development environment

VSCode Windows 64-bit Download
A free and powerful IDE editor launched by Microsoft

SAP NetWeaver Server Adapter for Eclipse
Integrate Eclipse with SAP NetWeaver application server.

PhpStorm Mac version
The latest (2018.2.1) professional PHP integrated development tool
