What resources does redis mainly consume?

Redis in-process consumption mainly includes: own memory, object memory, buffer memory, and memory fragmentation.

Memory. Because redis data is stored in memory. Compared with general relational databases, in-memory databases have faster reading speeds, but consume more memory resources.

Object memory(Recommended learning: Redis video tutorial)

Object memory is the largest piece of Redis memory and stores users All data. All data in Redis adopts key-value data type. Every time a key-value pair is created, at least two type objects are created: key object and value object. Memory consumption can be simply understood as sizeof(keys) sizeof(values). Key objects are all strings. When using Redis, it is easy to ignore the impact of keys on memory consumption. You should avoid using keys that are too long. The value object is more complex and mainly includes 5 basic data types: string, list, hash, set, and ordered set. Each value object type occupies different memory depending on the scale of use. When using it, you must reasonably estimate and monitor the value object occupancy to avoid memory overflow.

Buffer memory

Buffer memory mainly includes: client buffer, copy backlog buffer, and AOF buffer.

Client buffering refers to the input and output buffering of all TCP connections to the Redis server. The input and output buffer cannot be controlled. The maximum space is 1G. If it exceeds, the connection will be disconnected. Input buffering is controlled by the parameter client-output-buffer-limit:

1. Ordinary clients: For all connections except replicated and subscribed clients, the default configuration of Redis is: client-output-buffer- limit normal 0 0 0, Redis does not limit the output buffer of ordinary clients. Generally, the memory consumption of ordinary clients can be ignored, but when a large number of slow connection clients are connected, this part of the memory consumption cannot be ignored. Set maxclients to limit. Be careful not to just use commands that output a large amount of data and the data cannot be pushed to the client in time, such as the monitor command, which can easily cause the memory of the Redis server to suddenly surge.

Slave client: The master node will establish a separate connection for each slave node for command replication. The default configuration is: client-output-buffer-limit slave 256mb 64mb 60. When the network delay between the master and slave nodes is high or the master node mounts a large number of slave nodes, this part of the memory consumption will occupy a large part. It is recommended that the master node mount no more than 2 slave nodes, and the master and slave nodes should not be deployed in poor locations. In a certain network environment, such as across different computer rooms, prevent overflow caused by slow replication client connections.

Subscription client: When using the publish and subscribe function, the connection client uses a separate output buffer. The default configuration is: client-output-buffer-limit pubsub 32mb 8mb 60. When the message production of the subscription service is fast At the consumption speed, the output buffer will generate a backlog and cause the output buffer space to overflow.

Replication backlog buffer: Redis provides a reusable fixed-size buffer after version 2.8 to implement partial replication functions. It is controlled according to the repl-backlog-size parameter, and the default is 1MB. There is only one copy backlog buffer for the entire master node, and all slave nodes share this buffer, so a larger buffer space can be set, such as 100MB.

AOF buffer: This part of the space is used to save recent write commands during Redis rewriting.

3. Memory fragmentation

Redis’ default memory allocator uses jemalloc, and optional allocators include: glibc and tcmalloc. In order to better manage and reuse memory, the memory allocator generally uses a fixed range of memory blocks to allocate memory.

The following scenarios are prone to high memory fragmentation problems:

Frequent update operations, such as frequently performing append, setrange and other update operations on existing keys.

A large number of expired keys are deleted. After the key objects are expired and deleted, the released space cannot be fully utilized, resulting in an increase in the fragmentation rate.

For more Redis-related technical articles, please visit the Introduction to Using Redis Database Tutorial column to learn!

The above is the detailed content of What resources does redis mainly consume?. For more information, please follow other related articles on the PHP Chinese website!