BestHub
Sign in
Tagged articles
517 articles
Page 6 of 6
Qunar Tech Salon
Qunar Tech Salon
Aug 3, 2016 · Backend Development

Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies

The article analyzes write‑mostly, read‑light cache scenarios such as driver location updates and counter increments, discusses lock bottlenecks, proposes horizontal sharding and per‑record locking, explores lock‑free approaches with data‑integrity signatures, and summarizes practical optimization techniques for high‑concurrency back‑end systems.

Cacheconcurrencylock optimization
0 likes · 8 min read
Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies
Efficient Ops
Efficient Ops
Jul 5, 2016 · Operations

Mastering Web Cache: A Complete Layered Knowledge System

This article presents a systematic overview of web caching, detailing a seven‑layer cache hierarchy, clarifying the differences between buffer and cache, and explaining key cache metrics and design considerations for modern web architectures.

Cachebufferweb cache
0 likes · 11 min read
Mastering Web Cache: A Complete Layered Knowledge System
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 19, 2016 · Backend Development

How to Tackle Common Cache Problems in Distributed Systems

This article explores typical cache challenges in distributed systems—including data consistency, high availability, cache avalanche, and cache penetration—explaining their causes, real‑world scenarios, and practical mitigation strategies to ensure reliable and efficient caching.

CacheData ConsistencyDistributed Systems
0 likes · 9 min read
How to Tackle Common Cache Problems in Distributed Systems
Meituan Technology Team
Meituan Technology Team
Jun 17, 2016 · Operations

How to Prevent and Recover from Cache‑Induced Service Overload

Service overload caused by cache failures can cripple dependent systems, but by adopting smart cache get patterns, proactive client‑side checks, traffic throttling, service degradation, and dynamic scaling, developers can both prevent overload and recover gracefully when it occurs.

BackendCacheOperations
0 likes · 22 min read
How to Prevent and Recover from Cache‑Induced Service Overload
MaGe Linux Operations
MaGe Linux Operations
Jun 4, 2016 · Fundamentals

Why Linux’s Buffer/Cache Isn’t Always Free Memory – A Deep Dive

This article explains how the Linux free command reports memory usage, clarifies the roles of buffer and page cache, shows how to manually drop caches, and reveals scenarios—such as tmpfs, shared memory, and mmap—where cached memory cannot be reclaimed, helping readers achieve a deeper understanding of system memory behavior.

Buffer CacheCachepage cache
0 likes · 14 min read
Why Linux’s Buffer/Cache Isn’t Always Free Memory – A Deep Dive
DevOps
DevOps
Apr 17, 2016 · Fundamentals

CPU “Ah Gan” Explains the Boot Process, Memory Hierarchy, Cache, and Pipelining

Through a whimsical first‑person narrative, the article walks readers through a CPU’s start‑up sequence, BIOS interrupt handling, loading the boot sector, memory access patterns, the principle of locality, cache usage, and the introduction of pipelining to illustrate fundamental computer architecture concepts.

Boot ProcessCPUCache
0 likes · 11 min read
CPU “Ah Gan” Explains the Boot Process, Memory Hierarchy, Cache, and Pipelining
21CTO
21CTO
Apr 16, 2016 · Backend Development

How WeChat Scaled Red Packets for 80 Billion Transactions: Architecture Secrets

This article explains how WeChat redesigned its red‑packet system for the 2016 Chinese New Year, detailing north‑south data separation, multi‑layer caching, asynchronous settlement, high‑concurrency controls, sharding strategies and graceful degradation to handle billions of red‑packet requests.

CacheWeChatbackend scaling
0 likes · 13 min read
How WeChat Scaled Red Packets for 80 Billion Transactions: Architecture Secrets
dbaplus Community
dbaplus Community
Mar 28, 2016 · Backend Development

How to Keep Cache and Database Consistent: Invalidate First, Serialize Access

This article explains why cache and database can become inconsistent in distributed systems, why the "invalidate‑cache‑then‑write‑DB" rule is preferred, and presents practical serialization techniques—modifying DB and service connection pools—to guarantee per‑key sequential execution while maintaining availability and load balance.

Backend ArchitectureCacheConnection Pool
0 likes · 11 min read
How to Keep Cache and Database Consistent: Invalidate First, Serialize Access
Java High-Performance Architecture
Java High-Performance Architecture
Mar 8, 2016 · Databases

Understanding Redis Memory Eviction: 6 Policies Explained

When Redis reaches its maxmemory limit, it can use one of six eviction policies—volatile‑lru, allkeys‑lru, volatile‑random, allkeys‑random, volatile‑ttl, or noeviction—to decide which keys to remove, with defaults and configurable sampling influencing performance and accuracy.

Cachedatabasesmemory eviction
0 likes · 2 min read
Understanding Redis Memory Eviction: 6 Policies Explained
21CTO
21CTO
Mar 1, 2016 · Backend Development

Mastering Cache Algorithms: From LRU to LFU with Java Implementations

This article explains the fundamentals of caching, why caches are needed, describes common replacement policies such as LRU, LFU, FIFO, ARC, and provides Java code examples for each algorithm, helping developers choose and implement the right cache strategy for their applications.

BackendCacheJava
0 likes · 19 min read
Mastering Cache Algorithms: From LRU to LFU with Java Implementations
21CTO
21CTO
Jan 9, 2016 · Backend Development

Building a High‑Concurrency, Scalable Proxy for Weibo Recommendation Engine

This article details the design and implementation of a high‑concurrency, easily extensible proxy built in Go for Weibo's recommendation system, covering background, challenges with twemproxy, technical research, architecture, configuration, logging, monitoring, module breakdown, business logic, performance testing, and future improvements.

CacheGolangProxy
0 likes · 20 min read
Building a High‑Concurrency, Scalable Proxy for Weibo Recommendation Engine
Architect
Architect
Nov 22, 2015 · Backend Development

Implementing Rails Fragment Cache with Redis and Session Storage

This article explains how to enable Rails fragment caching, use HTML fragment cache helpers, understand cache digests, observe read/write fragment logs, and migrate the cache store from file system to Redis by adding redis-namespace and redis-rails gems, configuring cache_store, and handling cache invalidation on data changes.

CacheFragmentCacheRails
0 likes · 9 min read
Implementing Rails Fragment Cache with Redis and Session Storage
21CTO
21CTO
Nov 14, 2015 · Backend Development

How WeChat’s Red Packet System Handles Millions of Claims in Real Time

This article explains the backend architecture behind WeChat’s red‑packet feature, detailing how the system stores packet data, uses cache‑level atomic operations for grabbing, separates claim and settlement steps, and ensures high‑throughput, fault‑tolerant processing during peak usage.

BackendCacheDistributed Systems
0 likes · 6 min read
How WeChat’s Red Packet System Handles Millions of Claims in Real Time
Java High-Performance Architecture
Java High-Performance Architecture
Oct 15, 2015 · Databases

Master MySQL Cache Settings: Key Buffers, Table Cache, and More

This guide explains the essential MySQL cache parameters—including key_buffer_size, table_cache, sort_buffer_size, read_buffer_size, join_buffer_size, thread_cache_size, query_cache_size, and tmp_table_size—detailing their impact on performance and providing recommended values based on server memory to help DBAs optimize MyISAM and InnoDB workloads.

CacheConfigurationDatabase Tuning
0 likes · 4 min read
Master MySQL Cache Settings: Key Buffers, Table Cache, and More
Architect
Architect
Jul 30, 2015 · Backend Development

Redis‑Backed Timeline Implementation with MongoDB for a Subscription Feed

This article explains how to implement a scalable timeline for a subscription feed by combining MongoDB storage with a Redis list cache, detailing the data model, query challenges, Redis operations for pushing and trimming statuses, rebuilding strategies, and handling data integrity trade‑offs.

CacheMongoDBQueue
0 likes · 7 min read
Redis‑Backed Timeline Implementation with MongoDB for a Subscription Feed