Glossary of Terms
Using a third-party Valkey & Redis Java client like Redisson will require you to know some important terminology. For the benefit of our users, we've provided this glossary of terms related to Java, Redis, Valkey and Redisson.
A
ACID: The set of four properties that guarantee database transactions are processed reliably.
ACID vs BASE: Сompares two database models - ACID's strict transactional guarantees against BASE's high availability and eventual consistency.
B
Bloom Filter: A probabilistic data structure that tests set membership using a compact bit array, answering "possibly present" or "definitely not present."
C
Cache Eviction: The process of removing existing entries from a full cache to make room for new ones, governed by a policy such as LRU or LFU.
Cache Invalidation: The process of removing outdated or irrelevant data from a cache, ensuring that it only contains current and valid information.
Cache Memory: A type of computer memory for temporarily storing information that is important or frequently accessed.
Cache Miss: An event where an application or system is unable to find information in cache memory, and must look for it in the slower main database.
CAP theorem: A theorem describes that a distributed data system can guarantee at most two of three properties at once: consistency, availability, and partition tolerance.
Consistent hashing: A data partitioning technique that maps keys and nodes onto a hash ring so that adding or removing a node relocates only a fraction of keys.
D
Data Grid: An interconnected network of computers that share data and resources across the grid in pursuit of a common, highly complex goal.
Data Pipeline: A set of automated steps that move data from one or more sources to a destination, processing and transforming it along the way.
Data optimization: The practice of improving database speed, efficiency, and scalability through indexing, query tuning, schema design, and caching.
Deserialization: A process of reconstructing an object from a stream of bytes, reversing serialization so an application can use it as a native structure.
Distributed caching: A caching technique in which the cache is distributed across multiple servers or machines in order to improve scalability and availability.
Distributed database: A database in which data is stored across multiple servers or machines.
Distributed lock: A lock which is used by multimple servers or microservices in distributed application.
Distributed transaction: A single unit of work that spans multiple independent systems, committing or rolling back across all of them together.
E
Event-Driven Architecture: An architectural style in which services communicate by producing and reacting to events rather than by calling each other directly.
G
Geospatial Data: Data that describes the geography of the Earth, including geographical features, coordinates, events, and weather and climate.
H
Hibernate second-level cache: A secondary cache implemented in the Hibernate object-relational mapping framework for the Java programming language.
HyperLogLog: An algorithm and related data structure for estimating the number of distinct elements in a very large set.
I
Idempotency: The property of an operation that produces the same result whether it runs once or many times, which is what makes retrying a failed request safe.
In-Memory Database: A database that keeps its primary data set in RAM and serves every read and write from there, using disk only for durability rather than on the query path.
J
Java BitSet: A highly space-efficient data structure in the Java programming language that consists of a vector holding bit (boolean) values.
Java CompletableFuture: A class in the Java programming language for composing asynchronous tasks, allowing them to be chained and combined without blocking a thread.
Java ConcurrentHashMap: A thread-safe map implementation in the Java programming language that locks individual bins rather than the whole map, allowing concurrent reads and writes without a global lock.
Java CountDownLatch: A synchronization tool in the Java programming language that requires a given number of threads to wait for all threads to finish their work before proceeding.
Java Deque: An implementation of the deque (double-ended queue) data structure, in which elements can be inserted and removed at either end, for the Java programming language.
Java Distributed Lock: A lock mechanism in the Java programming language that is capable of working with multiple threads running on different machines in a distributed system.
Java ExecutorService: An interface in the Java programming language for running tasks on a managed thread pool, decoupling task submission from the details of how each task runs.
Java FencedLock: Distributed implementation of Lock object with improved fault-tolerance properties.
Java LinkedList: A doubly linked implementation of the List and Deque interfaces in the Java programming language, in which each element is held in its own node linked to its neighbours.
Java List: A data structure in the Java programming language that contains a countable number of elements in a sequential order.
Java LRU cache: A cache using the LRU (Least Recently Used) cache policy implemented in the Java programming language.
Java Lock: A synchronization tool that lets only one thread at a time enter a critical section, protecting shared data from concurrent access.
Java Map: An implementation of the map abstract data type, which associates unique keys with values, in the Java programming language.
Java multimap: A Java data structure introduced in Google's Guava library that allows multiple values to be associated with a single key.
Java Priority Queue: A data structure in the Java programming language that stores elements according to their priority.
Java Queue: An implementation of the queue data structure, which stores items in the order they arrived, for the Java programming language.
Java ReadWriteLock: An interface in the Java programming language that implements the concept of a read-write lock, in which multiple threads can read from a resource simultaneously but only one can write to it.
Java Semaphore: A synchronization tool in the Java programming language that controls the number of processes or threads that can access a given resources simultaneously.
Java Set: A data structure in the Java programming language that is a collection of countable, unordered, unique elements.
Java SortedSet: A data structure in the Java programming language that stores unique elements in a predefined order (e.g. smallest to largest for integers).
Java Stack: An implementation of the stack data structure, which stores elements in LIFO (last in, first out) order, for the Java programming language.
JCache: The standard caching API (application programming interface) for the Java programming language.
JMS: The standard Java API for sending and receiving messages between distributed applications, now known as Jakarta Messaging.
K
Key-Value Store: A non-relational database that consists of key-value pairs; each unique key is associated with a (possibly non-unique) value.
L
Latency vs. Throughput: Latency is how long a single request takes, while throughput is how many requests a system completes per unit of time. Learn how the two differ and relate.
M
MapReduce: A programming model and software framework for using distributed computing to efficiently handle very large data sets.
Message Broker: A message broker routes messages between services so they communicate asynchronously.
Microservices: A software architectural style in which a larger application is composed of multiple smaller, loosely coupled, modular services.
MyBatis Second-Level Cache: A secondary cache implemented in the MyBatis object-relational mapping framework.
N
NoSQL Database: A database which stores and retrieves data through means other than the tables and SQL of relational systems, favoring flexible schemas and horizontal scaling.
O
Optimistic Locking: A concurrency strategy that allows work to proceed without locking and detects conflicting writes at commit time, rather than preventing them with a lock up front.
P
Pub/sub: A software messaging pattern for asynchronous communication in serverless and microservices architectures that allows senders and recipients to operate independently.
R
Rate Limiting: Capping how many requests a client may make in a period of time. Covers the algorithms, rate limiting vs throttling, and rate limiters in Java.
Rate Limiting Algorithms: Fixed window, sliding window, token bucket, leaky bucket and GCRA compared — how each counts requests, and when to use it.
Race Condition: Occurs when a program's correctness depends on the timing of concurrent operations on shared data, producing results that differ from run to run.
Redis: An open-source, third-party data structure store used to implement NoSQL key-value databases, caches, and message brokers.
Redis Architecture: Redis architecture spans a single node's in-memory storage and event loop up to deployment topologies like Standalone, Replication, Sentinel, and Cluster.
Redis Caching: The caching policies and strategies that are employed by Redis users.
Redis Client-Side Caching: The caching implemented on Redis Client side.
Redis Cluster: A distributed implementation of Redis that automatically partitions data across multiple nodes in order to improve scalability and availability.
Redis Data Types: Data types provided by Redis.
Redis Hash: A fundamental Redis data structure that implements the hash table abstract data type, in which unique keys correspond to (possibly non-unique) values.
Redis Java Client: A Redis Java client is a software library that translates Java method calls into RESP commands and allowing Java applications read and write data on a Redis server.
Redis JSON: A native Redis data type that stores a JSON document under a single key, allowing individual fields to be read and updated by path without rewriting the whole document.
Redis Lock: A lock mechanism implemented on Redis that is capable of working with multiple threads running on different machines in a distributed system.
Redis List: A fundamental Redis data structure that implements the list abstract data type, in which elements are kept in insertion order.
Redis Lua Scripting: Running a block of Lua on the Redis server as a single atomic unit, so a read-decide-write sequence completes without any other client's commands interleaving.
Redis Persistence: The mechanisms that write the in-memory dataset to disk so it survives a restart, through RDB point-in-time snapshots, the AOF command log, or both.
Redis Pub/Sub: A messaging pattern implemented on Redis for asynchronous communication that allows senders and recipients to operate independently.
Redis Queue: A fundamental Redis data structure that implements the queue abstract data type, in which elements are kept in insertion order.
Redis Replication (Master-Slave): Copies of a Valkey or Redis dataset kept on separate nodes, with a single master accepting writes and streaming every change to its replicas.
Redis Search: A search mechanism implemented on Redis that is capable to search indexed data.
Redis Sentinel: A high-availability solution for Redis that performs monitoring and error handling in distributed environments.
Redis Sentinel vs Redis Cluster: Redis Sentinel adds automatic failover to one dataset; Redis Cluster shards across many. Compare sharding, scaling, failover, and client setup.
Redis Session: Session data stored in Redis or Valkey instead of local server memory.
Redis Set: An unordered collection of unique strings that never stores duplicates and supports constant-time membership checks.
Redis SETNX: a Redis command that sets a key to a value only if that key does not already exist, leaving it unchanged if it does.
Redis Sorted Set: A collection of unique members, each paired with a numeric score that keeps the members permanently ordered.
Redis Streams: A Redis data structure that consists of an append-only list for logging and sending messages.
Redis Transaction: Groups commands into a single isolated step. Learn how MULTI/EXEC works and how Redisson adds true rollback.
Redis TTL: An expiration timer attached to a key that makes Redis delete it automatically once the deadline passes.
Redis Vector Database: Using Redis to store embeddings and retrieve records by semantic similarity, through either vector sets or vector fields in the Query Engine.
Redlock Algorithm: The algorithm coordinates a distributed lock across several independent Redis nodes.
Ring Buffer: An abstract data type that consists of a circular buffer, in which the last element is connected to the first.
S
Saga Pattern: A technique that keeps data consistent across microservices using local transactions and compensating actions instead of a distributed transaction..
Serialization: A process of converting an object into a stream of bytes so its state can be stored, cached, or transmitted across a network.
Sharding: A technique for improving database scalability and availability that splits a single large database into multiple smaller tables.
Spring Cache: A cache implemented using the Spring framework for Java to improve application speed and performance.
Spring Session: A component of the Spring framework for Java that helps developers manage user session information.
Stream Processing: Handling data continuously, computing a result on each event as it arrives rather than in scheduled batches.
T
Thundering Herd Problem: Many requests released at the same moment overwhelm a single resource. In caching it appears as a cache stampede, where an expired hot key sends every request to the database at once.
Time Series Database: A database that has been designed to store time series data, i.e. data that has been tagged with timestamps.
Tomcat web session replication: The replication of web session data across multiple nodes in an Apache Tomcat cluster, in order to improve availability and scalability.
Transaction Management: Coordinates a transaction's lifecycle — begin, commit, and rollback — so a unit of work either completes fully or not at all.
Two-Phase Commit: A protocol that coordinates a distributed transaction across multiple resources so they all commit or all roll back together.
V
Valkey: Valkey is an open-source in-memory data structure store that is commonly used to implement non-relational key-value databases and caches.
Valkey Java Client: A Valkey Java client lets Java applications connect to Valkey by translating method calls into RESP commands.
W
Web Session: A session during which a user browses a given website, including the corresponding activities and the data generated.
Write-through and write-behind caching: Two different caching strategies that determine when changes to the cache are propagated to the database.
X
XA Transaction: Coordinates a distributed transaction across multiple resources using the X/Open XA standard and two-phase commit.