The article explains how a binary‑encoding strategy lets you identify a single poisoned bottle out of 1000 using only ten mice by assigning each mouse to a bit position, sampling wines accordingly, and interpreting the death pattern as a 10‑bit address.
This article provides an in‑depth technical overview of Redis, covering its single‑threaded model, core data structures, persistence options, master‑slave replication, Sentinel and cluster architectures, eviction policies, progressive rehash, skiplist implementation, bitmap usage for massive active‑user counting, and strategies for handling MySQL‑Redis write‑through consistency.
The article explains how a bitmap‑driven high‑table design (SelectDB) overcomes wide‑table storage bloat and latency to enable millisecond‑level crowd selection for tens of millions of users with hundreds of tag dimensions, while supporting dynamic tag expansion.
This article walks through more than ten common Redis scenarios—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/fan relationships, and ranking—showing concrete command examples and code snippets for each.
This guide walks Java backend developers through Redis’s eight core scenarios—caching, distributed locks, rate limiting, session sharing, leaderboards, counters, message and delay queues, bitmap statistics, and geolocation—providing complete code, diagrams, and production‑grade best practices.
This article presents a comprehensive guide to 16 practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, product tagging, filtering, social graphs, and leaderboards—complete with command examples, code snippets, and visual illustrations to help developers implement these patterns efficiently.
This case study details how Vivo’s marketing automation platform evolved its data‑driven architecture—from a Presto‑based wide‑table design, through a Bitmap optimization, to a StarRocks migration—addressing performance bottlenecks, reducing resource costs, and enhancing data security.
The article dissects an Alibaba interview question on counting 100 million daily active users, showing why HyperLogLog’s error and lack of per‑user state make it unsuitable, and presents a detailed Bitmap‑based architecture—including sharding, pre‑computation, and ClickHouse integration—to achieve precise, high‑performance analytics.
This article walks through why using a Redis Set for 200 million daily active users consumes 6‑8 GB of memory, how switching to a sharded Bitmap reduces usage to about 24 MB, and how Roaring Bitmap and ClickHouse further optimize sparse data and analytical workloads.
This article explains how to determine whether a given unsigned integer belongs to a set of 4 billion distinct numbers within a 1 GB memory limit, comparing a bitmap approach with a Bloom filter, providing detailed implementation steps and C++ code examples for both methods.
This tutorial explains Redis bitmap fundamentals, showcases common BITSET, BITGET, and BITCOUNT commands, and provides a complete PHP example that records daily user sign‑ins and accurately counts them using Redis bit operations.
This article details how HuoLala built a high‑performance user profiling platform on Apache Doris, redesigning data models, leveraging bitmap storage, and applying query‑level optimizations to achieve up to 30‑fold speed gains, lower memory usage, and scalable real‑time analytics.
Learn four practical techniques—simple sorting, hashmap deduplication, external merge sort, and bitmap bit‑set optimization—to efficiently remove duplicate QQ numbers from a 40‑billion‑record file while staying within a strict 1 GB memory limit, even handling tighter 100 MB constraints.
This article explains how using a bitmap can reduce the memory needed to store billions of integers from about 15 GB to under 500 MB, describes the bitmap concept, introduces Bloom filters, outlines their principles, advantages, common use cases, and provides Java and Redis code examples for implementation.
This article explains how to implement a memory‑efficient sign‑in feature and continuous‑sign‑in statistics using Redis BitMap, covering basic commands, Spring Boot integration, key design, code examples, and advanced use cases such as cache‑penetration mitigation, providing step‑by‑step guidance for backend developers.
This article explains how using a bitmap reduces the storage of 4 billion unsigned integers from 14.9 GB to about 476 MB, introduces the concept and benefits of bitmaps, and then details Bloom filter principles, advantages, limitations, common use cases, and Java/Redis implementation examples.
Learn how to efficiently remove duplicates from 4 billion QQ numbers using a memory‑friendly Bitmap approach that fits within a 1 GB limit, including calculations, step‑by‑step implementation, Java code, and a discussion of its advantages and drawbacks.
This article explores multiple techniques—including bitmap indexing, Bloom filters, external sorting, Spark, Redis, and a hierarchical bitmap architecture—to efficiently deduplicate ten‑hundred‑million QQ numbers while balancing memory usage, accuracy, and processing speed.
This article explores multiple techniques for efficiently deduplicating ten‑hundred‑million QQ identifiers, covering single‑machine bitmap methods, Bloom filter trade‑offs, external sorting, Spark and Redis distributed solutions, and a layered bitmap index that balances memory usage, speed, and accuracy.
This article explores multiple techniques—including bitmap indexing, Bloom filters, external sorting, Spark, and layered bitmap structures—to efficiently remove duplicate QQ numbers from a dataset of up to one billion entries while keeping memory usage below a gigabyte and maintaining high accuracy.
This article breaks down the massive‑scale challenge of calculating mutual friends for hundreds of millions of users, analyzes data‑size, latency, and memory constraints, and presents three Redis‑based solutions—basic Set, bitmap, and a sharded architecture—complete with code snippets, performance numbers, and practical trade‑offs.
Redis bitmap commands enable efficient bit‑level storage and fast counting, and this article explains the core concepts, key commands like BITSET, BITGET, BITCOUNT, and provides a complete PHP example that tracks user sign‑ins and calculates daily totals using Predis.
This article explains how to efficiently remove duplicates from 4 billion QQ numbers within a 1 GB memory limit by replacing the naïve HashSet approach with a memory‑saving Bitmap data structure, complete with calculations, algorithm steps, Java code, and a discussion of its pros and cons.
This article explains three Redis-based methods—Hash, Bitmap, and HyperLogLog—for tracking website user visits, detailing how each structure works, their implementation steps, memory and accuracy trade‑offs, and guidance on choosing the best approach for different traffic scenarios.
The article explains why large keys, oversized values, massive key counts, and huge Bitmaps or Bloom filters degrade Redis performance and provides practical splitting techniques—using multiple keys, hashes, bucketed hashing, and bitmap partitioning—to reduce memory pressure and improve response times.
By integrating ClickHouse bitmap structures, a dictionary service for dense ID mapping, and Bit‑Slice Indexes, Bilibili’s Data Management Platform now supports flexible, multi‑dimensional audience selection and profiling over petabyte‑scale data with minute‑level latency, cutting storage by over twenty‑fold and query times from hours to seconds.
This article introduces Redis bitmap operations, explains key commands such as BITSET, BITGET, and BITCOUNT, and demonstrates with PHP code how to implement an efficient user sign‑in tracking and counting system using bitmaps for accurate statistics.
This article explains how ClickHouse’s columnar storage, bitmap functions, and distributed architecture can be leveraged to store billions of tag bitmaps, combine them efficiently, and support fast group calculations for customer data platforms, while addressing data‑warehouse integration, storage format, and performance challenges.
This article explains how ClickHouse’s columnar storage, compression, and bitmap functions enable fast, scalable processing of billions of user tags and groups in a CDP, covering data storage design, bitmap generation, and distributed query optimization.
This article explains the Linux kernel bitmap data structure, its definition, macro-based declarations, related assembly instructions, core bitmap APIs such as set_bit and test_bit, various bit‑operation functions, and practical applications ranging from PID allocation to device management and file‑system indexing.
This article explains why storing daily sign‑in data in a traditional database can cause performance issues at scale and demonstrates how Redis bitmap, a memory‑efficient bit‑level structure, can record and compute continuous user sign‑ins both by date and by user.
This article explains Redis bitmap data structures, introduces the main bitmap commands (BITSET, BITGET, BITCOUNT), and provides a complete PHP example that demonstrates how to record user sign‑ins and count them efficiently using Redis bit operations.
The article explains how to store and deduplicate billions of identifiers by using a bitmap to represent presence with a single bit per value, calculates memory requirements, shows Redis bitmap commands, and introduces Bloom filters as an extension with multiple hash functions for efficient large‑scale data handling.
This article explains the bitmap (BitVec) data structure, its memory efficiency for handling billions of integers, real‑world applications such as bloom filters and permission flags, and walks through Go’s internal BitVec implementation with concrete code examples and performance insights.
This article explains how Redis Bitmap stores binary states using bit arrays, details its commands and use cases, then introduces Bloom Filter's probabilistic set membership, compares their advantages, limitations, and typical scenarios such as cache penetration protection and blacklist filtering.
This article walks through the step‑by‑step design of a simple file system on a 1 TB disk, introducing logical blocks, block bitmaps, inode structures, directory handling, indirect indexing, superblocks, and hierarchical file organization, while comparing the design to the classic ext2 filesystem.
The article explains how to store and deduplicate billions of identifiers efficiently by using a bitmap backed by Redis and extending it with a Bloom filter implementation in Java, highlighting memory calculations, practical commands, and code examples.
To achieve sub‑second, multi‑dimensional analytics on Bilibili’s hundred‑million‑row datasets, the team built a ClickHouse‑based acceleration layer that combines grouping‑set pre‑aggregation, bitmap (RBM) distinct handling, and a dense dictionary encoding service, dramatically cutting CPU, memory and query latency versus traditional OLAP pipelines.
This article details how the WeChat team leverages ClickHouse at massive scale, introduces a suite of performance observation tools, describes lakehouse reading and bitmap optimizations, and explains the integration of AI workloads, demonstrating overall query speedups of up to tenfold across diverse scenarios.
This article explains Redis bitmap data structures, introduces common bitmap commands such as BITSET, BITGET, and BITCOUNT, and provides a complete PHP example that records user sign‑ins and calculates daily sign‑in counts using Redis bit operations.
The article examines performance bottlenecks in marketing systems when filtering blacklisted accounts, proposes multithreaded processing and bitmap-based set operations—including Java BitSet and RoaringBitmap—to dramatically reduce processing time from tens of minutes to milliseconds, and discusses implementation details, memory efficiency, and broader applications such as indexing and Redis.
This article introduces Redis's five extended data types—Stream, Geospatial, Bitmap, Bitfield, and HyperLogLog—explaining their concepts, common commands, and practical code examples, and highlights how they address specific internet‑scale scenarios more efficiently than traditional relational solutions.
This article examines how bitmap data structures and multithreading can dramatically accelerate blacklist filtering in large‑scale marketing systems, reducing processing time from tens of minutes to milliseconds while saving memory and improving overall system performance.
Discover ten practical Redis scenarios—from counting page visits and caching category trees to implementing distributed locks, leaderboards, rate limiting, bitmap analytics, message queues, and global ID generation—each illustrated with concise code snippets and best‑practice tips for robust backend development.
This article presents a comprehensive overview of a user profile platform, covering its value, typical functionalities, layered architecture with open‑source implementations, and detailed engineering optimization techniques such as wide‑table generation, crowd selection, bitmap usage, and task‑based processing to improve performance and scalability.
This article explores how to achieve fast, scalable data retrieval in million‑level high‑concurrency scenarios by replacing naïve full‑combination rule matching with column‑wise inverted indexes and bitmap operations, dramatically reducing time complexity and improving stability while leveraging RoaringBitmap compression for space efficiency.
This article explores ten practical Redis scenarios—from counting page visits and caching category trees to implementing distributed locks, leaderboards, rate limiting, bitmap statistics, cache acceleration, message queues, and global ID generation—providing code snippets and best‑practice tips for each use case.
This article presents a comprehensive overview of precise deduplication in Meituan's Doris database, detailing the underlying bitmap data structures, aggregation bottlenecks, and a series of optimizations—including memory management, fast union, orthogonal encoding, and vectorized engine integration—that together achieve significant performance gains in high‑cardinality scenarios.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and monthly statistics in a Spring Boot microservice, covering basic BitMap commands, key design, code implementation, testing procedures, and a cache‑penetration mitigation strategy.
This article explains how to implement a memory-efficient sign-in system and continuous-sign-in statistics using Redis BitMap, covering basic BitMap commands, Spring Boot integration, core source code, and a BitMap-based approach to mitigate cache-penetration attacks.
This article explains how to use a Bloom filter backed by Redis bitmap and Roaring Bitmap sharding to efficiently filter 800 million OpenID queries, covering memory planning, hash function selection, code implementation, and performance‑tuned batch write strategies.
This article explains how to use a bitmap to store 6 billion URLs within 1 GB of memory and introduces Bloom filters as a space‑efficient probabilistic structure for deduplication, providing memory calculations, usage scenarios, and Java code examples.
This article explains how to use Redis BitMap to build a memory‑efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, key design, core Java code, testing steps, and a bitmap‑based solution for cache‑penetration protection.
This article explains how Alibaba's user growth platform leveraged RoaringBitmap in Hologres to accelerate massive user profiling, reducing analysis time from several minutes to around ten seconds by redesigning bitmap storage, optimizing data pipelines, and employing efficient SQL and scheduling techniques.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, integration steps, core source code, and a cache‑penetration solution using BitMap hashing.
This article explains how to implement a user sign‑in feature and its statistical analysis using Redis BitMap within a Spring Boot backend, covering basic BitMap commands, integration steps, core source code, continuous sign‑in calculation, and a bitmap‑based solution for cache penetration.
This article explains how to leverage Redis Set, Sorted Set, Bitmap, and HyperLogLog data structures for various statistical scenarios such as user sign‑in tracking, friend recommendations, comment ranking, and UV counting, while addressing performance and memory considerations.
This article explains how the Promise time‑control system replaces a naïve exponential rule‑matching approach with a column‑wise inverted index and bitmap bitwise operations, reducing computational complexity from 2ⁿ to n while also addressing space efficiency through RoaringBitmap compression.
The article explains how to store and de‑duplicate 4 billion unsigned integers using a bitmap to reduce memory from 14.9 GB to under 500 MB, introduces the concept and benefits of bitmaps, describes Bloom filters, their principles, advantages, limitations, typical use cases, and provides Java and Redis implementation examples.
This article explains the Linux kernel's transition from bitmap‑based PID allocation to a radix‑tree (IDR) implementation, describes the underlying data structures and code changes, and presents benchmark results showing roughly a 50% performance improvement for common utilities.
This article explains how to use Redis sets, sorted sets, lists, bitmaps, and HyperLogLog to perform aggregation, ordered queries, binary state tracking, and cardinality estimation for large‑scale applications such as sign‑in systems, e‑commerce comments, and social‑network friend lists.
This article explains how the BitBooster suite accelerates ClickHouse bitmap (BitMap) queries by up to tenfold, covering background, performance bottlenecks, single‑node and read optimizations, layout and instruction‑set enhancements, encoding dictionaries, multi‑node scaling, and real‑world benchmark results.
This article provides a comprehensive overview of Android image compression, covering bitmap fundamentals, ARGB color model, size calculations, quality and dimension compression methods, the Luban algorithm, its implementation details, performance considerations, and related JPEG Huffman coding techniques.
Learn how to efficiently store and query massive binary state data—such as user login status and daily sign‑in records—using Redis Bitmap, covering underlying structures, memory advantages, key design, and practical commands like SETBIT, GETBIT, BITCOUNT, BITPOS, and BITOP for real‑world analytics.
This article analyzes the performance bottlenecks of A/B experiment report queries on Apache Doris at Xiaomi, presents data-driven insights on query latency, field usage, and experiment ID matching, and details a series of optimizations—including pre‑aggregation, materialized views, bitmap deduplication, and schema redesign—that reduced query times by up to 60× and lowered cluster load.
This article explains how to handle Redis scenarios with oversized keys, massive collections, billions of keys, and large bitmaps or Bloom filters by partitioning data into multiple keys or hashes, using bucketization, multi‑get, and careful bitmap splitting to improve performance and lower memory consumption.
The article explains cardinality counting in Presto, comparing exact set‑based methods with memory‑efficient bitmap, Linear Count, and HyperLogLog approximations, detailing their algorithms, implementation in Presto’s query engine, and offering best‑practice recommendations for choosing the appropriate technique in business workloads.
This article explains Android image compression fundamentals—including ARGB, bitmap memory, bit‑depth vs. colour‑depth, quality and sampling compression methods—then details the Luban algorithm, its shortcomings, proposed improvements, and the underlying Skia/Huffman/JPEG native implementation with code examples.
This article explains the principles, Java implementation, and performance benefits of Bitmap and RoaringBitmap, demonstrating how they dramatically reduce storage costs, enable fast deduplication and set operations, and optimize large‑scale data warehouse queries in real‑world scenarios.
This guide explains how to use Redis Bitmap to efficiently store and query massive binary state data—such as user login status and daily sign‑ins—by leveraging GETBIT, SETBIT, BITCOUNT, BITPOS, and BITOP commands, dramatically reducing memory usage for millions of users.
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.
This article explains JD's design of a billion‑scale vehicle‑part matching cache, detailing the data model, bitmap storage structure, SDS pre‑allocation, key‑value compression, cluster routing, and Lua‑based high‑performance search interface that achieves sub‑13 ms latency.
This article explains how Redis stores key‑value pairs, dives into the underlying dict, dictEntry and redisObject structures, and presents seven practical memory‑saving tricks—including key shortening, encoding tweaks, object sharing, bitmap usage, hash consolidation, fragmentation cleanup, and 32‑bit deployment—to dramatically reduce RAM consumption while preserving performance.
By representing pre‑and post‑refresh SPU sets as RoaringBitmaps and diffing them, the system avoids full‑insert writes, cuts memory usage by orders of magnitude, speeds refreshes by over 50 % and reduces write volume nearly 87 %, solving large‑scale tag‑based product refresh challenges.
This article explains how to efficiently count daily visits and online users in a Laravel application by leveraging Redis bitmap, detailing its memory‑saving advantages, providing complete PHP code for setting, counting, and checking online status, and comparing alternative methods such as tables, sorted sets, and HyperLogLog.
This article explains Doris database enhancements including Rollup indexes, Broadcast/Shuffle/Colocation joins, dynamic partition management, bitmap aggregation, and materialized view creation, providing syntax examples and operational principles for each feature.
The article analyzes the memory inefficiency of storing per‑user read/unread lists for group chat messages, proposes a bitmap‑based solution with user‑to‑map ID mapping, discusses handling of member exits, and evaluates the storage savings and scalability of the new design.
The article narrates how a developer diagnosed and resolved an Android OOM crash caused by a memory leak in the Coil image loading library, using Android Studio Profiler to trace native bitmap allocations and applying a library fix to prevent view‑detach related leaks.
The article explains how to locate all missing 32‑bit unsigned integers in a 4 billion‑entry file by first partitioning the range into intervals, counting entries per interval with a tiny int[64] array, and then applying a bitmap method only to under‑filled intervals, achieving a memory footprint of just a few hundred bytes.
This article explains Redis bitmap (bit) operations, covering command syntax for SETBIT, GETBIT, BITCOUNT, and BITOP, analyzing the underlying SDS data structure, detailing time‑complexity and storage calculations, and presenting practical application scenarios such as user sign‑in tracking and online status monitoring.
The article analyzes the memory overhead of naïvely storing per‑user read/unread lists for group chat messages and proposes a bitmap‑based scheme with user‑to‑map ID mapping, quit flags, and compact storage that can reduce per‑message space by over 95 percent.
This article explains how to select Redis data structures such as Bitmap, HyperLogLog, Set, List, Sorted Set, and Hash to efficiently handle massive statistical scenarios like user login status, UV counting, ranking, and set aggregation, while providing concrete command examples and best‑practice recommendations.
The article explains the theoretical minimum and maximum of Tencent QQ numbers, why the lower bound starts at 10001, what would happen if all IDs were exhausted, and how a bitmap can efficiently represent and deduplicate billions of QQ IDs using simple C++ code.
The article examines how to efficiently store read/unread status for group chat messages by replacing per‑user lists with compact bitmap structures, discusses handling member exits, presents C++‑style struct definitions, and quantifies storage savings compared to the naïve 8‑byte per‑user approach.
This article examines how to model read/unread status for group chat messages using bitmap techniques, evaluates memory costs of naive approaches, and presents a compact storage schema that handles member joins, exits, and scalability while drastically reducing per‑message overhead.
This article explains the theoretical and practical range of Tencent QQ numbers, why the lower limit is set to 10001, how unused accounts are reclaimed, and demonstrates how bitmap techniques can efficiently deduplicate billions of QQ IDs using simple C++ code.
This article walks through four approaches—sorting, hashmap, file splitting, and a bitmap technique—to deduplicate 4 billion QQ numbers within a 1 GB memory limit, explains why the first three fail, and shows how a bitmap solves the problem efficiently.
This article explains several algorithmic strategies—including sorting, hash maps, file splitting, and bitmap techniques—to remove duplicates from a file containing 4 billion QQ numbers while staying within a 1 GB memory limit, and it provides extension exercises for sorting, median, top‑K, and duplicate detection.
This article explains four practical methods—sorting, hash map, file splitting, and bitmap—to deduplicate 4 billion QQ numbers within a 1 GB memory limit, and provides extended exercises on sorting, finding the median, top‑K, and duplicate detection for massive datasets.
This article walks through four practical techniques—sorting, hashmap, file splitting, and bitmap—to remove duplicate QQ numbers from a 4‑billion‑record file within a 1 GB memory limit, and provides extended exercises for sorting, median, top‑K, and duplicate detection.
This article explains the 12306 train ticket reservation algorithm, showing how bitmaps combined with bitwise OR operations can model seat availability across multiple stations, using a simplified example of four seats and three segments to illustrate ticket allocation, conflict detection, and remaining‑ticket calculation.
Git 2.34 introduces a sparse index for large monorepo repositories, multi‑package reachability bitmaps, the default "ort" merge strategy, OpenSSH‑based tag signing, interactive autocorrect prompts, performance improvements for fetch and push, and various submodule enhancements.
The article explains how to quickly determine whether an integer exists among ten million numbers by comparing hash tables, boolean arrays, bitmaps, and Bloom filters, and shows practical Java and Redis implementations with code examples and memory‑usage analysis.
This article explains how to use Redis Bitmap to efficiently store and query massive binary‑state data such as user login status and daily sign‑in records, covering underlying memory structures, command usage, and practical examples for counting, checking, and aggregating large‑scale user activity.
This article explains the principles of BitMap, BitSet, and Bloom Filter data structures, illustrating how they use bits to efficiently store, add, delete, and query large sets of integers, and discusses their practical applications such as fast sorting, deduplication, and membership testing.
The article analyzes the memory inefficiency of storing per‑message read/unread user lists in large group chats and proposes a bitmap‑based solution that maps users to sequential IDs, uses compact bitmaps for read status and handles member exits, achieving over 95% storage reduction.
This article presents sixteen practical Redis use‑cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow models, and ranking—explaining their data types, commands, and sample code.
This article explores how to leverage Redis for a wide range of backend functionalities—including caching, distributed data sharing, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow relationships, and leaderboards—providing practical code examples and usage patterns.
The article presents a high‑efficiency Android bitmap‑reuse strategy that combines the inBitmap API with atomic reference counting and a three‑layer LRU cache (active, LruCache, InBitmapPool), dramatically lowering garbage‑collection pauses and achieving over 80 % reuse on pre‑Android 8 devices.
This article outlines a variety of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/recommendation models, and ranking—demonstrating how Redis can support diverse backend functionalities.
