OntoL demonstrates that the world's largest knowledge graphs — billions of nodes and edges — fit comfortably in a single-machine in-memory graph database (Memgraph), eliminating distributed sharding overhead and enabling nanosecond multi-hop traversals by co-locating the reasoning layer with storage.
This article walks through Redis fundamentals, explaining its definition, internal modules, the full processing path of a SET command, essential commands, and how Redis differs from Memcached and MySQL, while also covering common connection and performance pitfalls.
Valkey 9.1.0 replaces Redis 7.2 with multi‑threaded networking, redesigned hash tables, and AI‑focused features, delivering up to 230% higher throughput, 20%+ memory savings, open BSD‑3‑Clause governance, and seamless compatibility with existing Redis ecosystems for high‑concurrency and AI workloads.
The article explains how Redis achieves more than 100,000 queries per second by leveraging in‑memory storage, highly optimized data structures, a single‑threaded core with epoll‑based I/O multiplexing, optional I/O multithreading, and performance tricks such as pipelining and careful key sizing.
Redis can sustain over 100,000 queries per second thanks to four key factors: pure in‑memory storage, highly optimized data structures such as SDS and ziplist, a single‑threaded event loop with epoll‑based I/O multiplexing, and optional multi‑threaded network handling introduced in Redis 6.0.
The article explains how Redis attains up to 500,000 queries per second on a single node by leveraging ultra‑fast in‑memory access, a single‑threaded core for data operations, and epoll‑based I/O multiplexing that eliminates per‑connection thread overhead.
Engula is a Redis‑compatible, high‑performance in‑memory database that cuts memory usage by up to 50% through compression and metadata optimization, while incurring only about 10% performance overhead, and its architecture, testing methodology, and benchmark results are detailed in this article.
Redis delivers millisecond‑level response and millions of operations per second by storing data entirely in memory, using a single‑threaded event‑driven model, efficient I/O multiplexing with epoll, and highly optimized data structures such as strings, hashes, lists, sets and sorted sets.
This article explains why Redis can handle massive concurrent traffic by storing all data in RAM, using a single‑threaded event loop, leveraging Linux epoll for I/O multiplexing, and employing highly optimized in‑memory data structures that keep latency in the microsecond range.
This article explains what Redis is, why it delivers microsecond‑level performance through in‑memory storage, single‑threaded event handling, and highly optimized C code, and it covers its persistence options, memory management techniques, and practical use cases such as caching and real‑time leaderboards.
This article provides a comprehensive overview of Redis, covering its core concepts, features, data types, caching patterns in Spring Boot, common cache pitfalls and solutions, performance reasons, eviction policies, persistence options, replication, and Sentinel high‑availability mechanisms.
Redis achieves million‑level concurrency by storing all data in memory, leveraging ultra‑fast read/write speeds, employing optimized data structures such as strings, hashes, lists, sets and sorted sets, using I/O multiplexing to handle many connections in a single thread, and scaling through master‑slave replication for high availability.
This article explains how Redis, an open‑source in‑memory key‑value store, processes a client command from network reception through its event‑driven engine, command parsing, execution, and reply transmission, revealing the internal mechanisms behind its high performance and scalability.
This article explains Redis' deployment models, core components, and the event‑driven engine that powers command processing, detailing the flow from client connection through the reactor loop, command parsing, execution, and response delivery with code examples and diagrams.
In this interview-style article, the interviewer probes a candidate on why Redis is exceptionally fast, covering its in‑memory storage, single‑threaded design, I/O multiplexing, optimized data structures, memory management tricks, and practical performance‑tuning strategies.
Redis achieves remarkable speed through in‑memory storage, I/O multiplexing, optimized data structures such as SDS strings, linked lists, ziplists, skip‑lists, and hash tables, a single‑threaded event loop, and intelligent data encoding, all of which eliminate disk I/O and reduce overhead.
Redis stores data directly in memory rather than on disk, leveraging microsecond‑level access, a single‑threaded Reactor event loop with I/O multiplexing, optimized data structures like strings, hashes, lists, sets, and a simple text protocol, all of which combine to deliver exceptionally high performance for high‑frequency read/write workloads.
Redis achieves millisecond‑level latency by storing all data in memory, using specially optimized data structures such as SDS, incremental‑rehash hash tables, and ziplists, employing a single‑threaded event‑driven model with epoll‑based I/O multiplexing, and streamlining network communication through the compact RESP protocol, compression, and batching, while also offering flexible eviction and persistence strategies.
This article introduces the new Redis book "Redis Mastery", explains core Redis concepts such as SDS strings, RDB/AOF persistence, master‑slave replication and Sentinel high‑availability, and also announces a limited‑time discount and giveaway for community members.
This article introduces the Redis in‑memory database, highlights the new "Redis Mastery" book that blends theory with practical examples, and explains core concepts such as SDS string structures, RDB/AOF persistence, master‑slave replication, and Sentinel high‑availability mechanisms.
Redis, an open-source in-memory NoSQL database, is explored in depth covering its high-performance features, typical use cases, evolution, architecture, data types and commands, followed by an overview of Tencent Cloud Redis services and a brief advertisement for a DevOps certification program.
Redis is a high‑performance, in‑memory NoSQL key‑value store offering persistence, rich data types, advanced structures, and robust commands, supporting caching, session storage, pub/sub, and leaderboards, while evolving through replication, Sentinel, clustering, and multithreaded proxies, with Tencent Cloud providing scalable, highly available managed Redis services.
This article examines the growing challenges faced by traditional databases, explains the fundamentals and advantages of in‑memory databases, and details a practical evaluation of the Chinese HaiGuang CPU’s suitability for such workloads, highlighting performance, security, and reliability aspects across various application scenarios.
CPU performanceHaiGuang processordatabase scalability
Rudis is a Rust‑implemented, Redis‑compatible in‑memory database that offers high performance, safety, and reliability, and this guide covers its overview, quick start commands, configurable startup parameters, a comprehensive list of supported Redis commands with examples, and basic performance test results.
This article compares Memcached, Redis, and Aerospike across persistence, replication, performance, memory management, and use‑case scenarios to help you select the most suitable in‑memory database for high‑throughput, low‑latency applications.
This article explores why Redis delivers ultra‑high performance by examining its in‑memory design, single‑threaded event loop, efficient data structures such as hash tables, SDS strings, ziplist, quicklist, and skiplist, as well as its encoding strategies and I/O multiplexing model.
This guide explains why an in‑memory SQLite database is ideal for PHP unit testing, outlines its key benefits such as isolation, speed, and resource efficiency, and provides step‑by‑step code examples for setup, data handling, cleanup, exception handling, schema verification, data providers, and transaction testing.
Redis achieves its remarkable speed through in‑memory storage, an efficient hash table design, single‑threaded execution that eliminates context switches, epoll‑based I/O multiplexing, progressive rehashing, and cached timestamps, all of which together enable near O(1) operations and minimal latency.
This article explains why Redis achieves exceptional speed by leveraging in‑memory storage, an efficient hash‑table data structure, a single‑threaded event loop, epoll I/O multiplexing, incremental rehashing, and cached timestamps, providing a comprehensive view of its performance optimizations.
Redis is widely known as a high‑performance cache, but its rich data structures, persistence options, and distributed features enable it to serve as a primary storage engine for many internet services, from user profiles and leaderboards to rate limiting, messaging, and geo‑location, while presenting scalability and reliability challenges.
This article provides a comprehensive overview of Redis, covering its core concepts, deployment architectures—including single instance, high‑availability, Sentinel, and cluster setups—its replication mechanisms, gossip protocol, and the various persistence options such as RDB, AOF, and fork‑based snapshots.
This article introduces Redis as an in‑memory key‑value data‑structure server, explains its primary use cases, walks through deployment options such as single instances, high‑availability, Sentinel and Cluster, and details its persistence mechanisms including RDB, AOF and forking.
This article introduces Redis fundamentals and demonstrates how to integrate Redis into PHP web applications for caching, session management, database caching, and queue operations, providing code examples that illustrate connecting to Redis, setting and retrieving data, and configuring expiration to boost performance and stability.
Redis is an open‑source, in‑memory NoSQL database that provides ultra‑fast key‑value storage, rich data structures, persistence, clustering and extensible modules, making it the preferred distributed cache over Memcached, which lacks these features and is now rarely chosen for new projects.
This article introduces Redis, explains its key advantages as an in‑memory data store, provides step‑by‑step installation instructions for CentOS including required packages, and demonstrates basic commands to start the server and interact with the database.
This article walks through the third part of an eleven‑article series that implements a functional Redis‑compatible in‑memory database in Go, detailing how the PING, AUTH, SELECT, SET and GET commands are parsed, routed and executed with concrete code examples.
This article introduces Dragonfly, an open‑source in‑memory database compatible with Redis and Memcached APIs, explains its architectural innovations, presents benchmark code comparing it with Redis, and discusses real‑world performance results and future development plans.
This guide walks through installing Apache Ignite via Docker, configuring it alongside MySQL in a Spring Boot project, setting up data sources and MyBatis, and performing benchmark tests to illustrate Ignite’s superior in‑memory SQL performance compared to traditional MySQL setups.
This article explores five common Redis applications—caching, session storage, distributed locking, rate limiting, and leaderboards—explaining how each leverages Redis’s in‑memory speed, atomic commands, and data structures to improve performance, scalability, and reliability of modern web services.
This article introduces Redis as a high‑performance in‑memory NoSQL database, explains its rich data structures, core design that makes it fast, key advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples.
This article introduces Redis as an open‑source, high‑performance in‑memory key‑value store, explains its rich data structures, underlying implementations, performance advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples for Ubuntu systems.
Redis is a high-performance, open-source in-memory key-value database offering rich data structures, persistence options, and advanced features like replication, clustering, and pub/sub, making it ideal for caching, counters, message queues, leaderboards, and session storage in demanding, high-concurrency applications.
This article introduces Redis as an open‑source in‑memory key‑value store, explains its data‑structure server nature, outlines common deployment options—including single instance, high‑availability, Sentinel, and Cluster—describes replication mechanisms, and details persistence models such as RDB, AOF, and hybrid approaches.
This comprehensive guide explains Redis fundamentals, its rich data types, differences from Memcached, thread model, persistence mechanisms (AOF, RDB, hybrid), memory eviction policies, clustering for high availability, cache design patterns, distributed locking, Redlock algorithm, and practical techniques for identifying and safely deleting big keys.
This article explains Redis as an in‑memory key‑value NoSQL database, outlines its data types and high‑availability features, and details common cache problems such as avalanche, penetration and breakdown along with practical mitigation strategies, followed by interview commentary on how to discuss Redis effectively.
Redis is an open‑source, in‑memory key‑value store written in C that uses hash tables, various data structures, and a single‑threaded event loop to achieve high performance, and this article explains its basic types, persistence mechanisms (AOF and RDB), replication, sentinel failover, and cluster sharding.
The article examines the newly released open‑source memory cache Dragonfly, compares its performance and architecture against Redis through detailed benchmark tests, discusses Redis's response and design principles, and concludes with insights on future directions for in‑memory data stores.
Redis is an open‑source, in‑memory key‑value data‑structure server that serves as a fast cache and primary database, offering various deployment options—including single instances, high‑availability setups, Sentinel, and clustering—along with flexible persistence mechanisms such as RDB snapshots and AOF logging.
This article explains Redis’s primary roles as a high‑speed cache, in‑memory database, and analytics engine, compares it with relational databases, details its data structures, single‑threaded performance, persistence options, expiration and eviction policies, distributed lock implementation, and strategies for cache penetration, breakdown, and avalanche.
This article explains Redis's rapid growth from its 2009 inception, outlines its version history and popularity, and details the architectural choices—memory‑first design, efficient data structures, smart encoding, and a single‑threaded I/O multiplexing model—that together give Redis its exceptional performance.
This article provides a comprehensive overview of Redis, covering its role as an in‑memory data‑structure server, various deployment topologies such as single instances, high‑availability, Sentinel, replication, and clustering, as well as its persistence mechanisms including RDB, AOF, and fork‑based snapshots.
Dragonfly DB is a high‑performance, Memcached‑ and Redis‑compatible in‑memory database that reportedly delivers up to 25× Redis throughput, with a shared‑nothing, multithreaded architecture; this guide shows quick Docker deployment on Linux/macOS, client access methods, Spring cache integration, and key usage notes.
Redis achieves remarkable speed by operating as an in‑memory database, leveraging specialized data structures like SDS, linked lists, hash tables, skip lists, and ziplists, while using a single‑threaded event loop with I/O multiplexing, incremental rehashing, and optimized memory management to minimize latency.
This article explains Redis's superior performance by detailing its six underlying data structures—Simple Dynamic Strings, hash tables, ziplist, quicklist, skiplist, and integer sets—covering their implementations, memory optimizations, collision handling, and lookup complexities, with code examples and diagrams.
This article examines the open‑source memory cache Dragonfly, its performance claims against Redis, presents reproduced benchmark results, discusses architectural differences, and outlines Redis’s design principles and testing methodology.
Redis achieves high performance by storing all data in memory, using compact data structures like SDS, linked lists, hash tables, skip lists and integer sets, running a single‑threaded event loop, and handling thousands of client connections with efficient I/O multiplexing.
This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.
Redis is an open‑source in‑memory key‑value data‑structure server that serves as a cache, primary database, and messaging system; this article explains its core concepts, deployment options (single instance, HA, Sentinel, Cluster), and persistence mechanisms (RDB, AOF, and hybrid approaches).
Redis is an open‑source, in‑memory key‑value store that functions as a data‑structure server, offering caching, replication, high‑availability, clustering, and various persistence options such as RDB snapshots and AOF logs, with detailed deployment models including single instances, Sentinel, and cluster architectures.
While Kafka dominates large‑scale messaging, this article shows how Redis Streams—an in‑memory, low‑cost alternative—can handle peak‑shaving, buffering, decoupling, redundancy, and robustness, offering simpler commands and higher speed for projects where deploying a full Kafka stack is overkill.
This article explains why Redis’s single‑threaded design achieves high performance, details its five fundamental data types—string, list, set, hash, and sorted set—their internal implementations, and introduces advanced structures such as Geo, Bitmap, and HyperLogLog with practical command examples.
Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, ziplist and skiplist, running a single‑threaded event loop with lock‑free execution, and employing efficient I/O multiplexing and incremental rehash techniques to minimize latency and maximize throughput.
Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, hash tables, skip‑lists and zip‑lists, running a single‑threaded event loop with I/O multiplexing, and applying optimisations like lazy‑free, progressive rehashing and optional multi‑threaded I/O for network traffic.
Redis is an open‑source, in‑memory data store that supports various data types, persistence, replication, Sentinel, clustering, Lua scripting, pipelines, and distributed locks, and the article walks through its evolution from simple caching to a high‑availability, horizontally scalable database solution.
This article explains how Redis achieves high‑performance queries by leveraging in‑memory storage, specialized data structures such as SDS, hash tables, skip‑lists and zip‑lists, a single‑threaded event loop with I/O multiplexing, and progressive rehashing techniques.
This article provides a comprehensive introduction to Redis, covering its core features, supported data types, common caching problems and solutions, performance characteristics, eviction policies, persistence mechanisms, master‑slave replication, and Sentinel high‑availability architecture.
This article provides a comprehensive overview of Redis, covering its core characteristics, supported data types, common caching challenges such as consistency, avalanche, penetration and breakdown, as well as its high performance mechanisms, eviction policies, persistence options, master‑slave replication, and Sentinel high‑availability architecture.
This article provides a comprehensive introduction to Redis, covering its core characteristics, supported data structures, common caching use‑cases and associated challenges such as consistency, cache avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence options, master‑slave replication, and Sentinel high‑availability mechanisms.
This article provides a comprehensive introduction to Redis, covering its core features, supported data structures, common caching patterns, typical cache‑related problems and mitigation techniques, performance characteristics, eviction policies, persistence options, replication mechanisms, and Sentinel high‑availability architecture.
This article provides a detailed overview of Redis, covering its core concepts, high‑performance features, common use cases, installation steps, memory‑management policies, supported data structures, persistence mechanisms, transaction model, and best practices for cache consistency and failure handling.
This article provides a comprehensive overview of Redis, covering its definition, data structures, performance characteristics, persistence mechanisms, expiration strategies, memory eviction policies, hot key handling, cache pitfalls, deployment modes, Sentinel and Cluster features, and replication details, all framed as interview questions.
This article explains why Redis achieves high query performance by leveraging in‑memory storage, specialized data structures such as SDS, linked lists, dictionaries, ziplists and skiplists, a single‑threaded event loop with I/O multiplexing, and various optimization techniques that avoid common bottlenecks.
This article provides a thorough introduction to Redis, covering its core data structures and common commands, persistence options (RDB and AOF), memory‑management and eviction policies, pipelining, transactions and Lua scripting, performance optimization techniques, replication, Sentinel high‑availability, cluster sharding, and a comparison of popular Java clients.
This article explains why Redis achieves extremely high performance by being an in‑memory key‑value store, using compact data structures, a single‑threaded command model with epoll‑based I/O multiplexing, efficient hash tables, progressive rehashing, various persistence options, master‑slave replication, Sentinel monitoring and a sharded Cluster architecture.
Redis, an open‑source in‑memory data store, serves as a database, cache, and message broker, offering rich data types, persistence, replication, Sentinel, and clustering; this article walks through its evolution from simple caching to high‑availability, distributed architectures, and advanced client features.
This whitepaper explains the concept, history, core attributes, typical industry use cases, major products, and selection guidelines for in‑memory databases, highlighting their performance advantages, technical challenges, and future trends driven by evolving memory technologies.
This whitepaper explains the concept of in‑memory databases, traces their historical development, outlines core attributes and typical use cases in e‑commerce, live streaming and telecom, compares leading products, and provides technical and management recommendations for hardware and product selection as well as future trends.
Redis achieves its remarkable speed through a combination of in‑memory data storage, optimized data structures like SDS, ziplist, quicklist and skiplist, a single‑threaded command model, efficient I/O multiplexing, and sophisticated persistence, replication, Sentinel and Cluster mechanisms that together ensure high performance and reliability.
This article explains why Redis achieves exceptionally high performance by combining pure in‑memory operations, a global hash table with O(1) lookups, efficient data structures such as SDS, ziplist, quicklist and skiplist, a single‑threaded event loop with non‑blocking I/O multiplexing, and adaptive encoding strategies.
This article explains why Redis achieves exceptional speed by examining its memory‑only architecture, single‑threaded event loop, and the specialized data structures—global hash tables, SDS strings, ziplist, quicklist, skiplist, and intset—that provide O(1) or O(log N) operations, along with non‑blocking I/O multiplexing.
This article explains why Redis is exceptionally fast by detailing its in‑memory design, global hash table with O(1) lookups, incremental rehashing, specialized data structures such as SDS, ziplist, quicklist, skiplist and intset, as well as its single‑threaded event loop and epoll‑based I/O multiplexing.
This article compares Redis and Memcached across thread model, data structures, eviction policies, pipelining, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific performance and feature requirements.
This article explains that Redis stores all data primarily in memory, describes its seven core data types (String, Hash, List, Set, Sorted Set, Pub/Sub, Transactions), shows how each type is implemented internally, and provides practical examples such as caching, ranking, queues, and real‑time analytics.
This article provides a thorough overview of Redis, covering its core data structures, common commands, persistence options, memory management, pipelining, transactions, performance optimization, replication, clustering, and Java client choices for developers and architects.
This article explains how Redis achieves high performance by using an in‑memory architecture, specialized data structures such as SDS, doubly linked lists, ziplists and skip‑lists, efficient encoding strategies, and a single‑threaded I/O multiplexing model that eliminates costly context switches.
This article explains how Redis achieves high performance by storing data in memory, using optimized data structures like SDS, linked lists, ziplists, hash tables, and skip lists, and employing an I/O multiplexing single‑threaded reactor model to minimize latency and overhead.
This article walks through Redis’s role as an in‑memory data store, explains how simple HTTP caching evolves into server‑side memory caching, and details the progression to high‑availability and distributed architectures with persistence, Sentinel, replication, clustering, and advanced features like transactions, Lua scripting, pipelining, and distributed locks.
This article systematically compares Redis and Memcached across thread models, supported data structures, eviction strategies, pipelining, transactions, persistence, high‑availability mechanisms, and clustering, helping developers choose the most suitable in‑memory database for their specific workload requirements.
This article compares Redis and Memcached across thread models, data structures, eviction policies, pipelines, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific workload and performance requirements.
This article systematically compares Redis and Memcached across thread models, data structures, eviction policies, pipelining and transactions, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific business requirements.
This article provides an in‑depth guide to Redis, covering its core data types, internal data structures, common usage scenarios, differences from Memcached, key expiration, eviction policies, persistence mechanisms, transactions, event handling, replication, Sentinel, sharding, and a practical forum system example.
This comprehensive guide explains Redis’s architecture, performance advantages, data types, common use cases, persistence options, and scaling strategies, helping developers decide when and how to leverage this high‑speed in‑memory database for caching, session management, and more.
This comprehensive guide explains what Redis is, its advantages and drawbacks, why it excels as a high‑performance cache, the supported data structures, persistence mechanisms, memory eviction policies, threading model, transaction handling, clustering and sharding options, distributed locking, common cache pitfalls, and useful tooling for Java developers.
This article introduces Redis as an open‑source in‑memory data‑structure store, explains its role as a NoSQL database, covers fundamental data types, common commands, expiration handling, and advanced features like pipelines and transactions, providing a comprehensive guide for developers.
This article explores Redis, a high‑performance in‑memory key‑value store, detailing its core data types—String, List, Hash, Set, ZSet—the underlying structures such as SDS, quicklist, hashtable, and intset, and demonstrates practical usage patterns like caching, rate limiting, and inventory control.
data structuresin-memory databasememory management
This article explains what Redis is, how it is used for caching in projects, the performance and concurrency advantages of caching, common cache pitfalls, key differences between Redis and Memcached, and the internal single‑threaded event‑driven architecture that enables high‑throughput operations.
This article explains what Redis is, how it is used for caching in projects, the advantages of caching, common cache issues, key differences between Redis and Memcached, and why Redis's single‑threaded design can still support high concurrency.
Redis, the in‑memory data store, uses a simple RESP text protocol, offers limited ACID‑style transactions without rollback, employs optimistic locking via WATCH, provides multiple persistence options (RDB, AOF, hybrid), optimizes memory with ziplist and quicklist structures, and implements sophisticated replication and expiration strategies to balance performance and resource usage.
The article explains the concept of in‑memory (main‑memory) databases, traces the maturation and cost reduction of memory technology, discusses their performance benefits and volatility challenges, and outlines current bottlenecks, persistent‑memory breakthroughs, and future development stages.
This article explains why Redis delivers exceptional performance by examining its pure in‑memory operations, single‑threaded design, efficient data structures such as SDS, dictionaries, skip‑lists, zip‑lists, and the encoding and rehash strategies that keep latency low even under heavy load.