# doocs/advanced-java

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/doocs-advanced-java).**

78,987 stars · 19,207 forks · Java · CC-BY-SA-4.0

## Links

- GitHub: https://github.com/doocs/advanced-java
- Homepage: https://java.doocs.org
- awesome-repositories: https://awesome-repositories.com/repository/doocs-advanced-java.md

## Topics

`advanced-java` `distributed-search-engine` `distributed-systems` `doocs` `dubbo` `elasticsearch` `eureka` `feign` `high-availability` `high-concurrency` `hystrix` `java` `message-queue` `microservices-architecture` `redis` `ribbon` `rpc` `spring-cloud` `springcloud-config` `zookeeper`

## Description

This project is a comprehensive Java backend engineering guide and technical reference focused on high-concurrency design, distributed systems, and microservices architecture. It provides detailed strategies for decomposing monolithic applications, managing service discovery, and implementing the architectural patterns required for scalable backend environments.

The repository distinguishes itself through an extensive collection of big data algorithmic references and database scaling strategies. It covers memory-efficient techniques for analyzing massive datasets, such as Top-K element extraction and frequency counting, alongside advanced data management patterns including horizontal sharding, read-write splitting, and high-availability clustering.

The project's capability surface extends across distributed coordination, fault tolerance engineering, and reliable messaging. It details the implementation of distributed locks, transactions, and consistency patterns, while offering mechanisms to prevent cascading failures through circuit breaking, rate limiting, and resource isolation. It also covers distributed search and indexing primitives, caching optimization, and the orchestration of inter-service communication via RPC and REST.

## Tags

### Data & Databases

- [Memory-Efficient Big Data Algorithms](https://awesome-repositories.com/f/data-databases/memory-efficient-big-data-algorithms.md) — Provides a comprehensive reference for memory-efficient algorithms to solve large-scale data problems like frequency counting and rank extraction.
- [Inverted Index Engines](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/specialized-storage-engines/inverted-index-engines.md) — Implements inverted index engines to map keywords to document identifiers for rapid distributed full-text search.
- [Service-Private Data Stores](https://awesome-repositories.com/f/data-databases/data-management/service-private-data-stores.md) — The system assigns each service its own private database or data store to avoid tight coupling. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/microservices-introduction.md))
- [Unique Identifier Generators](https://awesome-repositories.com/f/data-databases/data-management/unique-identifier-generators.md) — The system creates unique identifiers across distributed databases using database sequences, Snowflake algorithms, or UUIDs. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard-global-id-generate.md))
- [Data Replication](https://awesome-repositories.com/f/data-databases/data-replication.md) — The system creates redundant replicas of data shards across multiple servers to prevent data loss during hardware failures. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-introduction.md))
- [Database Partitioning and Sharding](https://awesome-repositories.com/f/data-databases/database-partitioning-and-sharding.md) — The system distributes data across multiple databases and tables to reduce data set size and improve query performance. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/high-concurrency-design.md))
- [Database Scaling Strategies](https://awesome-repositories.com/f/data-databases/database-scaling-strategies.md) — Provides a comprehensive set of strategies for distributing data and workloads across nodes to enhance throughput. ([source](https://github.com/doocs/advanced-java#readme))
- [Database Sharding](https://awesome-repositories.com/f/data-databases/database-sharding.md) — Implements architectural patterns for partitioning large datasets across multiple database nodes to handle high volumes. ([source](https://github.com/doocs/advanced-java/blob/main/README.md))
- [Distributed Cache Architectures](https://awesome-repositories.com/f/data-databases/distributed-cache-architectures.md) — The system configures a distributed architecture with master and slave instances to enable high availability and automatic failover. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-production-environment.md))
- [Distributed Search Engines](https://awesome-repositories.com/f/data-databases/distributed-search-engines.md) — Executes full-text searches and data analysis across distributed indices with near real-time latency. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-introduction.md))
- [Primary-Replica Replication](https://awesome-repositories.com/f/data-databases/primary-replica-replication.md) — The system distributes load by directing write operations to a primary database and read requests to multiple replicas. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mysql-read-write-separation.md))
- [Single-Leader Replication](https://awesome-repositories.com/f/data-databases/primary-replica-replication/single-leader-replication.md) — Maintains high availability through single-leader replication, synchronizing data from a primary node to standby replicas.
- [Read Replicas](https://awesome-repositories.com/f/data-databases/read-replicas.md) — Implements read-write splitting by distributing read queries across slave replicas and writes to a master. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-master-slave.md))
- [Asynchronous Write Buffering](https://awesome-repositories.com/f/data-databases/asynchronous-write-buffering.md) — Provides patterns for buffering high-frequency write requests in queues to prevent database saturation. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/high-concurrency-design.md))
- [Bitmap-Based Cardinality Counting](https://awesome-repositories.com/f/data-databases/bitmap-based-cardinality-counting.md) — Implements unique element counting using bitmaps for analyzing massive datasets. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/count-different-phone-numbers.md))
- [Bitmap-Based Membership Tracking](https://awesome-repositories.com/f/data-databases/bitmap-based-membership-tracking.md) — Provides an architectural implementation for tracking unique element presence using memory-efficient bitmaps.
- [Bitmap-Based Membership Verification](https://awesome-repositories.com/f/data-databases/bitmap-based-membership-verification.md) — Provides implementations for tracking integer existence using memory-efficient bitmaps. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-a-number-if-exists.md))
- [Bitmap-Based Top-K Extraction](https://awesome-repositories.com/f/data-databases/bitmap-based-top-k-extraction.md) — Implements memory-efficient bitmap techniques to extract top values from massive, bounded datasets. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/topk-problems-and-solutions.md))
- [Cache Avalanche Prevention](https://awesome-repositories.com/f/data-databases/cache-avalanche-prevention.md) — Protects databases from crashing during total cache failure using high-availability clusters and request throttling. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-caching-avalanche-and-caching-penetration.md))
- [Cache Breakdown Mitigation](https://awesome-repositories.com/f/data-databases/cache-breakdown-mitigation.md) — Prevents database spikes during hot key expiration via permanent TTLs, distributed locks, or proactive refreshes. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-caching-avalanche-and-caching-penetration.md))
- [Cache Eviction Policies](https://awesome-repositories.com/f/data-databases/cache-eviction-policies.md) — Reclaims memory by implementing LRU, random sampling, or TTL-based data eviction strategies. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-expiration-policies-and-lru.md))
- [Cache Management Policies](https://awesome-repositories.com/f/data-databases/cache-management-policies.md) — Manages distributed in-memory stores focusing on consistency, eviction policies, and cache stampede prevention. ([source](https://github.com/doocs/advanced-java/blob/main/README.md))
- [Cache Stability Protections](https://awesome-repositories.com/f/data-databases/cache-stability-protections.md) — The system prevents systemic risks like cache penetration and avalanche to ensure stability during high traffic spikes. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/why-cache.md))
- [Caching Strategies](https://awesome-repositories.com/f/data-databases/caching-strategies.md) — Optimizes caching through specific data types, eviction policies, and high-availability patterns for consistency. ([source](https://github.com/doocs/advanced-java#readme))
- [Cache Consistency Managers](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching-strategies/query-result-caching/cache-consistency-managers.md) — Synchronizes data between caches and databases using Cache Aside and delayed double deletion patterns. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-consistence.md))
- [Data Persistence Management](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/data-persistence-management.md) — The system uses a transaction log to record operations and a flush mechanism to commit buffers to disk. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-write-query-search.md))
- [Distributed Document Stores](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/data-storage/specialized-database-engines/distributed-document-stores.md) — The system stores large-scale data across a distributed cluster of nodes using a JSON-based document structure. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-introduction.md))
- [Near Real-Time Storage](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/near-real-time-storage.md) — The system writes documents to a memory buffer and transaction log to ensure data becomes searchable almost immediately. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-write-query-search.md))
- [Persistence & Durability](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/persistence-durability.md) — The system utilizes sequential disk writes to persist data and prevent loss while minimizing seek overhead. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mq-design.md))
- [Stream Median Calculators](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/stream-processing-systems/stream-processing/stream-median-calculators.md) — Provides algorithms for calculating the median of massive numeric sets and continuous streams. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-mid-value-in-500-millions.md))
- [Data Replication Strategies](https://awesome-repositories.com/f/data-databases/data-replication-strategies.md) — Implements methods for copying data across multiple nodes to ensure high availability and fault tolerance in message brokers. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-ensure-the-reliable-transmission-of-messages.md))
- [State Resumption Mechanisms](https://awesome-repositories.com/f/data-databases/data-replication/state-resumption-mechanisms.md) — The system continues data synchronization from the last known offset using a memory backlog after network disconnection. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-master-slave.md))
- [Write Acknowledgement Strategies](https://awesome-repositories.com/f/data-databases/data-replication/write-acknowledgement-strategies.md) — The system ensures at least one replica has acknowledged receipt of data before a write is marked complete. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mysql-read-write-separation.md))
- [Data Sharding](https://awesome-repositories.com/f/data-databases/data-sharding.md) — Distributes data across multiple master nodes using hash slots to ensure balanced storage and scalability. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-cluster.md))
- [Distributed Sharding Architectures](https://awesome-repositories.com/f/data-databases/database-management-systems/database-architectures/distributed-sharding-architectures.md) — Implements data sharding to distribute search indices across multiple nodes for horizontal scaling and parallel execution. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-architecture.md))
- [Atomic Event Publishing](https://awesome-repositories.com/f/data-databases/database-management-systems/database-systems-management/connection-transaction-management/atomic-transactions/atomic-event-publishing.md) — Provides strategies for using transaction tables to guarantee that events are published only if the local state change succeeds. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/event-driven-data-management-for-microservices.md))
- [Zero-Downtime Migrations](https://awesome-repositories.com/f/data-databases/database-migration-management/zero-downtime-migrations.md) — Implements dual-writes and background synchronization to transfer data to sharded environments without downtime. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard-method.md))
- [Database Performance Optimizers](https://awesome-repositories.com/f/data-databases/database-performance-optimizers.md) — Reduces latency by storing complex database query results in memory to bypass repetitive computations. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/why-cache.md))
- [Lazy Expiration](https://awesome-repositories.com/f/data-databases/database-record-management/expired-record-purging/lazy-expiration.md) — Balances CPU and memory usage by cleaning up expired data via random periodic sampling and on-access checks. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-expiration-policies-and-lru.md))
- [Dynamic Scaling](https://awesome-repositories.com/f/data-databases/database-sharding-strategies/dynamic-scaling.md) — Implements a scalable data distribution strategy using high-capacity multipliers to support seamless growth. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard-dynamic-expand.md))
- [Row-Based Sharding](https://awesome-repositories.com/f/data-databases/database-sharding/row-based-sharding.md) — Implements horizontal scaling by distributing table rows across multiple databases using range or hash-based routing. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard.md))
- [Shard Routing Logic](https://awesome-repositories.com/f/data-databases/database-sharding/shard-routing-logic.md) — Implements logic to direct SQL requests to the correct database shard based on specific routing fields. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard.md))
- [Probabilistic Duplicate Detection](https://awesome-repositories.com/f/data-databases/duplicate-detection-tools/probabilistic-duplicate-detection.md) — Uses probabilistic hashing and bitsets to identify duplicate strings and URLs across massive datasets. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-common-urls.md))
- [Frequent Element Extraction](https://awesome-repositories.com/f/data-databases/frequent-element-extraction.md) — Implements data partitioning and hashing techniques to extract the most frequent elements from large datasets. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-top-100-words.md))
- [Full Text Search](https://awesome-repositories.com/f/data-databases/full-text-search.md) — Implements a two-phase query and fetch process using inverted indices for distributed full-text search execution. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-write-query-search.md))
- [Data Structure Operations](https://awesome-repositories.com/f/data-databases/hash-data-structures/data-structure-operations.md) — The system caches complex object structures beyond simple key-value pairs using diverse data types and rich operations. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-single-thread-model.md))
- [Resource Migration](https://awesome-repositories.com/f/data-databases/horizontal-database-scaling/resource-migration.md) — Provides strategies for increasing write throughput and storage by migrating logical databases to new physical servers. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard-dynamic-expand.md))
- [Traffic Scaling Strategies](https://awesome-repositories.com/f/data-databases/horizontal-database-scaling/resource-scaling-strategies/traffic-scaling-strategies.md) — Provides strategies for scaling read throughput by offloading database traffic to memory-based stores. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/why-cache.md))
- [In-Memory Caches](https://awesome-repositories.com/f/data-databases/in-memory-caches.md) — Accelerates response times for high-volume requests by storing frequently accessed data in memory. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/high-concurrency-design.md))
- [Penetration Preventions](https://awesome-repositories.com/f/data-databases/in-memory-caches/penetration-preventions.md) — The system blocks requests for non-existent data from hitting the database by storing null values or using Bloom filters. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-caching-avalanche-and-caching-penetration.md))
- [Snapshotting and Command Logging](https://awesome-repositories.com/f/data-databases/in-memory-caches/persistence-managers/snapshotting-and-command-logging.md) — The system saves in-memory data to non-volatile storage using periodic snapshots or append-only command logs. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-persistence.md))
- [Service Call Caches](https://awesome-repositories.com/f/data-databases/in-memory-caches/request-scoped-caching/service-call-caches.md) — The system stores the output of a service call to return the same value on subsequent identical requests. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-process.md))
- [Topology Caching](https://awesome-repositories.com/f/data-databases/in-memory-caches/topology-caching.md) — The system maintains a fixed-size cache that automatically discards the oldest accessed items to prioritize hot data. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-expiration-policies-and-lru.md))
- [Key-Value Pair Managers](https://awesome-repositories.com/f/data-databases/key-value-pair-managers.md) — Caches simple strings and structured objects as key-value pairs for fast retrieval and updates. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-data-types.md))
- [Log-Based Visitor Analysis](https://awesome-repositories.com/f/data-databases/log-based-visitor-analysis.md) — Provides techniques for partitioning log data to identify the most frequent visitor IP addresses. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-top-1-ip.md))
- [Materialized Views](https://awesome-repositories.com/f/data-databases/materialized-views.md) — Constructs read-optimized data projections by aggregating events from multiple services into materialized views. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/event-driven-data-management-for-microservices.md))
- [Multi-level Caching](https://awesome-repositories.com/f/data-databases/multi-level-caching.md) — Coordinates local server caches and distributed stores via message queues to minimize backend load during updates. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/e-commerce-website-detail-page-architecture.md))
- [Ordered Collection Management](https://awesome-repositories.com/f/data-databases/ordered-collection-management.md) — The system stores sequential lists of elements to implement activity feeds or high-performance paginated queries. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-data-types.md))
- [Write Consistency Guards](https://awesome-repositories.com/f/data-databases/partitioned-data-scanners/write-consistency-guards.md) — The system restricts write requests to the master if a minimum number of slaves are not synchronized. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-sentinel.md))
- [Lag Reduction Strategies](https://awesome-repositories.com/f/data-databases/primary-replica-replication/lag-reduction-strategies.md) — The system decrease the delay between primary and replica updates by using parallel threads to replay logs simultaneously. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mysql-read-write-separation.md))
- [Search & Indexing Engines](https://awesome-repositories.com/f/data-databases/search-indexing-engines.md) — Analyzes distributed principles, indexing mechanisms, and query optimization for large-scale search engine architectures. ([source](https://github.com/doocs/advanced-java#readme))
- [External Indexing Offloaders](https://awesome-repositories.com/f/data-databases/search-indexing-technologies/search-indexing/search-and-indexing/external-indexing-offloaders.md) — Implements architectural strategies for offloading complex full-text search queries to dedicated distributed search engines. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/high-concurrency-design.md))
- [Elasticsearch Clusters](https://awesome-repositories.com/f/data-databases/search-indexing-technologies/search-indexing/search-information-retrieval/search-engine-platforms/elasticsearch-clusters.md) — Provides detailed strategies for determining node and shard counts to ensure Elasticsearch cluster stability. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-production-cluster.md))
- [Document Schema Flattening](https://awesome-repositories.com/f/data-databases/search-indexing/document-schema-flattening.md) — Provides strategies for flattening data schemas to optimize search performance and avoid expensive nested queries. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-optimizing-query-performance.md))
- [Sentinel Management](https://awesome-repositories.com/f/data-databases/sentinel-management.md) — The system uses a publish/subscribe mechanism to discover other sentinel instances and synchronize monitoring configurations. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-sentinel.md))
- [Storage Scaling](https://awesome-repositories.com/f/data-databases/storage-scaling.md) — The system clusters multiple instances to increase total storage volume and support higher read and write concurrency. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-ensure-high-concurrency-and-high-availability-of-redis.md))
- [String-Based Top-K Filtering](https://awesome-repositories.com/f/data-databases/string-based-top-k-filtering.md) — Implements string-based Top-K filtering using prefix and length hashing to isolate candidate elements. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/topk-problems-and-solutions.md))
- [Tiered Storage Strategies](https://awesome-repositories.com/f/data-databases/tiered-storage-strategies.md) — Isolates frequently accessed data from rarely used data into separate indices to optimize memory usage. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-optimizing-query-performance.md))
- [Top-K Element Extraction](https://awesome-repositories.com/f/data-databases/top-k-element-extraction.md) — Provides priority-queue based logic to extract the largest set of numbers from multiple sorted arrays. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-rank-top-500-numbers.md))
- [Top-K Element Identification](https://awesome-repositories.com/f/data-databases/top-k-element-identification.md) — Implements heap sorting and quickselect strategies to identify the k largest or smallest elements. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/topk-problems-and-solutions.md))
- [Two-Phase Commit](https://awesome-repositories.com/f/data-databases/transfer-state-persistence/two-phase-commit.md) — Details the implementation of two-phase commit protocols to coordinate atomic updates across multiple distributed database participants. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-transaction.md))
- [Trie-Based Top-K Querying](https://awesome-repositories.com/f/data-databases/trie-based-top-k-querying.md) — Implements prefix tree structures for the efficient retrieval of lexicographically largest strings. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/topk-problems-and-solutions.md))
- [Unique Integer Identification](https://awesome-repositories.com/f/data-databases/unique-integer-identification.md) — Implements divide-and-conquer partitioning and bitmasking to find unique integers in massive datasets. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-no-repeat-number.md))
- [Unordered Unique Collection Management](https://awesome-repositories.com/f/data-databases/unordered-unique-collection-management.md) — The system maintains unordered sets of unique elements across multiple distributed nodes to ensure data uniqueness. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-data-types.md))
- [Vertical Partitioning](https://awesome-repositories.com/f/data-databases/vertical-partitioning.md) — Provides strategies for dividing tables with many columns into smaller tables by separating frequently accessed fields. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/database-shard.md))
- [Write-Ahead Logging](https://awesome-repositories.com/f/data-databases/write-ahead-logging.md) — Provides mechanisms to record state-changing operations to a sequential disk log for durability and recovery.

### Software Engineering & Architecture

- [Backend Mastery Guides](https://awesome-repositories.com/f/software-engineering-architecture/backend-engineering/backend-mastery-guides.md) — Provides a comprehensive knowledge base for experienced developers on high-concurrency and distributed Java backend engineering.
- [Asynchronous Task Processing](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-task-processing.md) — Implements architectural patterns for offloading time-consuming tasks to background queues to minimize request latency. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/why-mq.md))
- [Centralized Configuration Systems](https://awesome-repositories.com/f/software-engineering-architecture/centralized-configuration-systems.md) — The system organizes and distributes settings across multiple services to ensure consistency and simplify updates. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-service-governance.md))
- [Concurrency Patterns](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-patterns.md) — Provides design patterns for optimizing throughput via caching, rate limiting, and message queuing.
- [Database-per-Service Patterns](https://awesome-repositories.com/f/software-engineering-architecture/database-per-service-patterns.md) — The system assigns a dedicated database to each microservice to ensure loose coupling and optimized database types. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/advantages-and-disadvantages-of-microservice.md))
- [Distributed Coordination Systems](https://awesome-repositories.com/f/software-engineering-architecture/distributed-coordination-systems.md) — Implements a coordination layer using distributed locks, transactions, and sessions to maintain cluster-wide consistency. ([source](https://github.com/doocs/advanced-java/blob/main/README.md))
- [Distributed Service Architectures](https://awesome-repositories.com/f/software-engineering-architecture/distributed-service-architectures.md) — Designs the architecture for distributed communication, incorporating service registration, load balancing, and network transport. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-rpc-design.md))
- [Module-to-Service Extractions](https://awesome-repositories.com/f/software-engineering-architecture/distributed-service-architectures/module-to-service-extractions.md) — Provides strategies for converting internal modules into independent services by defining APIs and implementing inter-process communication. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/migrating-from-a-monolithic-architecture-to-a-microservices-architecture.md))
- [Distributed Data Management](https://awesome-repositories.com/f/software-engineering-architecture/distributed-systems/distributed-data-management.md) — Provides strategies for scaling data storage using horizontal sharding, read-write splitting, and consistent replication patterns.
- [Consistent Hashing](https://awesome-repositories.com/f/software-engineering-architecture/distributed-systems/distributed-data-management/consistent-hashing.md) — Uses consistent hashing and virtual nodes to distribute data and requests across a cluster with minimal redistribution.
- [Distributed Storage Clusters](https://awesome-repositories.com/f/software-engineering-architecture/distributed-systems/distributed-data-management/distributed-storage-clusters.md) — The system distributes data across multiple nodes using a built-in cluster mode without relying on client-side sharding. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-single-thread-model.md))
- [Distributed Transaction Coordinators](https://awesome-repositories.com/f/software-engineering-architecture/distributed-transaction-coordinators.md) — Implements coordination mechanisms like TCC and XA patterns to maintain data consistency across multiple distributed services. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-system-interview.md))
- [Distributed Transaction Managers](https://awesome-repositories.com/f/software-engineering-architecture/distributed-transaction-managers.md) — Implements the Saga pattern to manage long-running distributed transactions using sequences of local transactions and compensating actions. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-transaction.md))
- [Event-Driven Architectures](https://awesome-repositories.com/f/software-engineering-architecture/event-driven-architectures.md) — Coordinates data consistency across microservices through event publishing and subscription to trigger business logic. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/event-driven-data-management-for-microservices.md))
- [Fault Tolerance](https://awesome-repositories.com/f/software-engineering-architecture/fault-tolerance.md) — Details fault tolerance engineering using circuit breakers and rate limiting to prevent cascading failures in distributed environments.
- [Fault Tolerance Implementation](https://awesome-repositories.com/f/software-engineering-architecture/fault-tolerance-strategies/fault-tolerance-implementation.md) — Implements design patterns to isolate remote service calls and ensure system continuity during dependency failures. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-service-governance.md))
- [Graceful Degradation](https://awesome-repositories.com/f/software-engineering-architecture/graceful-degradation.md) — Executes fallback logic and mock responses to maintain partial functionality during service outages. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-service-management.md))
- [Messaging Architectures](https://awesome-repositories.com/f/software-engineering-architecture/messaging-architectures.md) — Outlines distributed architectures using brokers, topics, and partitions for horizontal scalability and throughput. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mq-design.md))
- [Microservice Architectures](https://awesome-repositories.com/f/software-engineering-architecture/microservice-architectures.md) — Implements a strategy of developing new functionality as independent services to prevent monolithic growth. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/migrating-from-a-monolithic-architecture-to-a-microservices-architecture.md))
- [Microservices Architectures](https://awesome-repositories.com/f/software-engineering-architecture/microservices-architectures.md) — Provides detailed strategies for breaking large monolithic applications into small, loosely coupled business services. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/advantages-and-disadvantages-of-microservice.md))
- [Monolith Decompositions](https://awesome-repositories.com/f/software-engineering-architecture/monolithic-architectures/monolith-decompositions.md) — Details the process of dividing large codebases into independent services to reduce conflicts and accelerate deployment. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-system-interview.md))
- [Non-blocking IO Architectures](https://awesome-repositories.com/f/software-engineering-architecture/non-blocking-io-architectures.md) — Uses non-blocking IO multiplexing to process multiple sockets sequentially and avoid lock contention. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-single-thread-model.md))
- [Rate Limiting](https://awesome-repositories.com/f/software-engineering-architecture/request-throttling/rate-limiting.md) — Implements request frequency capping using token bucket and sliding window algorithms. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-limit-current.md))
- [Service Discovery Registries](https://awesome-repositories.com/f/software-engineering-architecture/service-discovery-registries.md) — Maintains a dynamic registry of available service nodes to facilitate discovery and communication between microservices. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-services-technology-stack.md))
- [Automatic Service Registrations](https://awesome-repositories.com/f/software-engineering-architecture/service-instance-managers/automatic-service-registrations.md) — Implements automated recording of service instance details in a central registry with synchronization across peer nodes. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/how-eureka-enable-service-discovery-and-service-registration.md))
- [Service Request Routing](https://awesome-repositories.com/f/software-engineering-architecture/service-request-routing.md) — Details mechanisms for distributing inter-service requests across multiple providers to ensure scalable and balanced system load. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-operating-principle.md))
- [Concurrent Task Limiters](https://awesome-repositories.com/f/software-engineering-architecture/concurrent-task-runners/concurrent-task-limiters.md) — Controls concurrent resource access using semaphores and thread pools to prevent system exhaustion. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-semphore-isolation.md))
- [Service Call Fallbacks](https://awesome-repositories.com/f/software-engineering-architecture/default-configuration-values/fallback-value-logic/service-call-fallbacks.md) — Provides predefined default responses and alternative behaviors when primary service calls fail. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-circuit-breaker.md))
- [Concurrency-Based Dependency Isolation](https://awesome-repositories.com/f/software-engineering-architecture/dependency-isolation-strategies/concurrency-based-dependency-isolation.md) — Implements semaphore-based limits on concurrent requests to protect downstream dependencies. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-execution-isolation.md))
- [Task Coordinations](https://awesome-repositories.com/f/software-engineering-architecture/distributed-coordination-systems/task-coordinations.md) — Uses node listeners to notify systems of state changes to synchronize workflows and track completion. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/zookeeper-application-scenarios.md))
- [Dynamic Configuration Systems](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-configuration-systems.md) — The system modifies system properties and settings in real-time without requiring a restart to accelerate recovery. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-introduction.md))
- [Event Sourcing](https://awesome-repositories.com/f/software-engineering-architecture/event-sourcing.md) — Implements event sourcing to rebuild entity status by replaying a full history of state-changing events. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/event-driven-data-management-for-microservices.md))
- [Failure Handling Policies](https://awesome-repositories.com/f/software-engineering-architecture/failure-handling-policies.md) — Defines policies for managing remote provider failures, including retry mechanisms, fail-fast strategies, and non-critical error ignoring. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-load-balancing.md))
- [Idempotency Mechanisms](https://awesome-repositories.com/f/software-engineering-architecture/idempotency-mechanisms.md) — Implements state tracking and unique identifiers to ensure distributed operations are processed exactly once without duplicate side effects. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-system-idempotency.md))
- [Reliability Fallbacks](https://awesome-repositories.com/f/software-engineering-architecture/implementation-fallbacks/reliability-fallbacks.md) — Provides mechanisms to return cached data or default values when service dependencies are unavailable. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-process.md))
- [Message Queuing Architectures](https://awesome-repositories.com/f/software-engineering-architecture/message-queuing-architectures.md) — Implements reliable asynchronous communication patterns with guaranteed delivery, idempotency, and message ordering via brokers.
- [Performance Analysis](https://awesome-repositories.com/f/software-engineering-architecture/performance-analysis.md) — Analyzes call counts and latency percentiles across request chains to evaluate system throughput and responsiveness. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-service-management.md))
- [Automated Retry Strategies](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/reliability-patterns/automated-retry-strategies.md) — Implements automated retry logic and local caching to recover from transient network or processing errors. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-ensure-the-reliable-transmission-of-messages.md))
- [Request Sequence Assurances](https://awesome-repositories.com/f/software-engineering-architecture/request-sequence-assurances.md) — Maintains the execution order of service calls by routing identifiers to the same machine via hashing. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-system-request-sequence.md))
- [Frequency-Based Ranking](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/counting-sorts/frequency-based-ranking.md) — Implements popularity ranking for search terms using external sorting and frequency counting. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/sort-the-query-strings-by-counts.md))
- [Traffic Control Patterns](https://awesome-repositories.com/f/software-engineering-architecture/traffic-control-patterns.md) — Applies architectural patterns to limit request volumes and maintain stability under high stress. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-service-governance.md))
- [Transactional Outbox Patterns](https://awesome-repositories.com/f/software-engineering-architecture/transactional-outbox-patterns.md) — Implements local message tables to achieve eventual consistency by decoupling database commits from message queue delivery. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-transaction.md))

### DevOps & Infrastructure

- [Distributed Locks](https://awesome-repositories.com/f/devops-infrastructure/distributed-locks.md) — Implements distributed locks to prevent concurrent resource access by requiring processes to create unique nodes. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/zookeeper-application-scenarios.md))
- [Concurrency Control Strategies](https://awesome-repositories.com/f/devops-infrastructure/distributed-locks/concurrency-control-strategies.md) — The system uses distributed locks or timestamp comparisons to ensure multiple system instances do not overwrite newer data. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-cas.md))
- [High Availability Systems](https://awesome-repositories.com/f/devops-infrastructure/high-availability-systems.md) — Integrates rate limiting, circuit breaking, and degradation strategies to ensure overall system high availability. ([source](https://github.com/doocs/advanced-java#readme))
- [Service Discovery](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/cluster-service-orchestration/service-discovery.md) — Coordinates provider registration and consumer subscription to enable dynamic service discovery in distributed environments. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-operating-principle.md))
- [Service Health Monitoring](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/operational-observability-access/service-health-monitoring.md) — Tracks real-time statistics and triggers alerts on dependency failures to accelerate system recovery. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-service-management.md))
- [Request Retries](https://awesome-repositories.com/f/devops-infrastructure/api-service-management/api-resilience/request-retries.md) — Implements automated retry logic for failed or timed-out service calls to increase reliability. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-service-management.md))
- [Configuration Management Systems](https://awesome-repositories.com/f/devops-infrastructure/configuration-management-systems.md) — The system stores and organizes configuration settings and registry information for distributed services to ensure consistent parameters. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/zookeeper-application-scenarios.md))
- [Resource Protection Rules](https://awesome-repositories.com/f/devops-infrastructure/configuration-management/configuration-resolution-engines/project-configuration-managers/dynamic-rule-management/resource-protection-rules.md) — The system configures protection logic and fallback functions via annotations or dynamic external data sources in real-time. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/sentinel-vs-hystrix.md))
- [Decoupled Frontend and Backend Deployments](https://awesome-repositories.com/f/devops-infrastructure/decoupled-frontend-and-backend-deployments.md) — Separates the presentation layer from business logic to enable independent deployment and scaling of the UI. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/migrating-from-a-monolithic-architecture-to-a-microservices-architecture.md))
- [Capacity Planning](https://awesome-repositories.com/f/devops-infrastructure/devops/operational-reliability/capacity-planning.md) — Forecasts hardware resource requirements by analyzing call volumes and response times. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-service-governance.md))
- [Distributed Configuration Management](https://awesome-repositories.com/f/devops-infrastructure/distributed-configuration-management.md) — The system centralizes application settings across different environments and clusters with support for real-time updates. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-services-technology-stack.md))
- [Master Node Promotions](https://awesome-repositories.com/f/devops-infrastructure/distribution-packaging/application-update-managers/stability-management/node-promotion-stability/master-node-promotions.md) — Details the election and promotion process for transitioning slave nodes to master status. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-cluster.md))
- [Queue High Availability](https://awesome-repositories.com/f/devops-infrastructure/high-availability-systems/queue-high-availability.md) — Implements redundancy through leader-follower replication and consensus algorithms to ensure queue uptime and durability. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-ensure-high-availability-of-message-queues.md))
- [Replica Suitability Validations](https://awesome-repositories.com/f/devops-infrastructure/high-availability-systems/replica-suitability-validations.md) — Implements ranking logic for slave candidates based on priority and replication offset. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-sentinel.md))
- [Load Shedding Systems](https://awesome-repositories.com/f/devops-infrastructure/load-shedding-systems.md) — Protects system stability by dynamically dropping traffic based on current node load. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/sentinel-vs-hystrix.md))
- [Message Queues](https://awesome-repositories.com/f/devops-infrastructure/message-queues.md) — Optimizes message queuing systems through the implementation of high availability, idempotency, and reliability patterns. ([source](https://github.com/doocs/advanced-java#readme))
- [Consumer Scaling and Distribution](https://awesome-repositories.com/f/devops-infrastructure/message-queues/consumer-scaling-and-distribution.md) — Clears accumulated messages by scaling consumer instances or implementing temporary distribution queues. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mq-time-delay-and-expired-failure.md))
- [Automated Master Failovers](https://awesome-repositories.com/f/devops-infrastructure/remote-cluster-access/cluster-failover-managers/automated-master-failovers.md) — Provides strategies for automated master election and cluster reconfiguration during node failures. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-sentinel.md))
- [Resource Isolation](https://awesome-repositories.com/f/devops-infrastructure/resource-isolation.md) — Allocates specific CPU and memory boundaries to prevent a single service from exhausting shared host resources. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-service-governance.md))

### Education & Learning Resources

- [Big Data Algorithmic References](https://awesome-repositories.com/f/education-learning-resources/big-data-algorithmic-references.md) — Provides a comprehensive technical reference for processing massive datasets using TopK and Bloom filters.
- [Distributed Systems Study Guides](https://awesome-repositories.com/f/education-learning-resources/distributed-systems-study-guides.md) — Serves as a technical reference for implementing distributed locks, transactions, and consistency patterns.
- [Leaderboards](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/data-structure-implementations/data-structures/leaderboards.md) — The system stores unique elements associated with a numeric score to automatically keep data sorted for ranking. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-data-types.md))

### Networking & Communication

- [Inter-Process Communication Frameworks](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/inter-process-communication/inter-process-communication-frameworks.md) — Enables independent service units to exchange data using REST, RPC, or asynchronous message brokers. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/what's-microservice-how-to-communicate.md))
- [Cluster State Coordinators](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/consensus-coordination-systems/cluster-state-coordinators.md) — Implements master node election to maintain index metadata and coordinate shard assignments across a cluster. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/es-architecture.md))
- [Node Failure Detection](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-systems-coordination/distributed-systems-configuration/heartbeat-and-timeout-configurations/node-failure-detection.md) — Implements consensus-based failure detection logic to identify unresponsive nodes in a distributed cluster. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-cluster.md))
- [Pub-Sub Messaging](https://awesome-repositories.com/f/networking-communication/pub-sub-messaging.md) — Implements pub-sub architectures to decouple message producers and consumers using topics and channels. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/why-mq.md))
- [Remote Procedure Calls](https://awesome-repositories.com/f/networking-communication/remote-procedure-calls.md) — Handles the full lifecycle of RPC requests, including serialization, transport, and asynchronous pattern conversion. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-operating-principle.md))
- [Remote Service Clients](https://awesome-repositories.com/f/networking-communication/remote-service-clients.md) — Automates load balancing, service discovery, and retries for inter-service calls using an RPC framework. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/why-dubbo.md))
- [Circuit Breakers](https://awesome-repositories.com/f/networking-communication/traffic-management-gateways/circuit-breakers.md) — Implements circuit breakers to block requests to failing downstream services and prevent cascading system failures.
- [Traffic Distribution](https://awesome-repositories.com/f/networking-communication/traffic-shaping/scaling/traffic-distribution.md) — Routes requests to backend instances using random weighted selection, round-robin, or consistent hashing. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-load-balancing.md))
- [Messaging Reliability](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-reliability.md) — Coordinates distributed transactions by verifying local commit status before triggering downstream actions via a message queue. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-transaction.md))
- [Backpressure and Backlog Management](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-reliability/backpressure-and-backlog-management.md) — Handles system backpressure and clears large queued message backlogs when consumption falls behind. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mq-interview.md))
- [Message Brokers](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/message-brokers.md) — Configures brokers with redundancy and failover mechanisms to maintain operational stability during node failures. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mq-interview.md))
- [Broker Disk Persistence](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/message-brokers/broker-disk-persistence.md) — Prevents data loss during broker crashes by configuring durable queues and synchronous disk flushing. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-ensure-the-reliable-transmission-of-messages.md))
- [Communication Protocols](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/communication-protocols.md) — Provides guidance on selecting network transport methods, such as long-lived NIO connections, for high concurrency. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-serialization-protocol.md))
- [Request Timeout Management](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/communication-protocols/request-timeout-management.md) — Enforces request deadlines and triggers fallbacks to prevent resource exhaustion during failures. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-process.md))
- [Load Balancers](https://awesome-repositories.com/f/networking-communication/load-balancers.md) — Implements client-side load balancing to distribute requests across multiple backend instances for high availability. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-services-technology-stack.md))
- [Message Delivery Guarantees](https://awesome-repositories.com/f/networking-communication/message-delivery-guarantees.md) — Uses synchronous transactions and confirmation callbacks to guarantee messages reach their destination without loss. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/how-to-ensure-the-reliable-transmission-of-messages.md))
- [Network Optimization](https://awesome-repositories.com/f/networking-communication/network-optimization.md) — Optimizes throughput by offloading protocol parsing to multiple threads while maintaining a single-threaded command core. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/redis-single-thread-model.md))
- [Message Ordering Guarantees](https://awesome-repositories.com/f/networking-communication/network-reliability-diagnostics/reliability-scaling/message-ordering-guarantees.md) — Guarantees that messages are processed in the exact sequence they were produced to preserve consistency. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/mq-interview.md))
- [Network Traffic Routing](https://awesome-repositories.com/f/networking-communication/network-traffic-routing.md) — Acts as a reverse proxy to manage dynamic routing and security at the network edge. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-services-technology-stack.md))
- [Traffic Shaping](https://awesome-repositories.com/f/networking-communication/traffic-shaping.md) — Uses message queues to buffer traffic spikes and protect downstream databases from overloading. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-concurrency/why-mq.md))

### System Administration & Monitoring

- [Service Dependency Mapping](https://awesome-repositories.com/f/system-administration-monitoring/service-dependency-mapping.md) — Automatically records and visualizes request flows and dependency relationships between multiple microservices. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-service-management.md))
- [Performance Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/performance-monitoring.md) — Tracks the frequency and duration of remote procedure calls to analyze system health and performance. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-operating-principle.md))
- [Real-Time Monitoring Systems](https://awesome-repositories.com/f/system-administration-monitoring/real-time-monitoring-systems.md) — Provides real-time observability of resource performance and call chains using sliding window metrics. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/sentinel-vs-hystrix.md))
- [Request Timeouts](https://awesome-repositories.com/f/system-administration-monitoring/request-timeouts.md) — Sets maximum durations for requests to prevent thread blocking during service degradation. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-thread-pool-current-limiting.md))
- [Try-Confirm-Cancel Patterns](https://awesome-repositories.com/f/system-administration-monitoring/system-activity-monitoring/session-activity-monitors/workflow-cancellation-handlers/remote-task-cancellation/cancellation-handlers/try-confirm-cancel-patterns.md) — Provides a detailed implementation of the Try-Confirm-Cancel pattern to ensure strict consistency in financial distributed operations. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-transaction.md))

### Part of an Awesome List

- [API Gateways](https://awesome-repositories.com/f/awesome-lists/devops/api-gateways.md) — Details the use of edge gateways for centralized routing, load balancing, and access control. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/advantages-and-disadvantages-of-microservice.md))
- [More to explore](https://awesome-repositories.com/f/awesome-lists/more/more-to-explore.md) — Interview questions for Java developers.

### Development Tools & Productivity

- [Anti-Corruption Layers](https://awesome-repositories.com/f/development-tools-productivity/modular-architecture/translation-layers/anti-corruption-layers.md) — Details the construction of translation layers between new microservices and legacy monoliths to protect domain models. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/migrating-from-a-monolithic-architecture-to-a-microservices-architecture.md))

### Programming Languages & Runtimes

- [Command-Based Pool Isolation](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/task-orchestration-frameworks/thread-pools/custom-thread-pool-configurations/command-based-pool-isolation.md) — Maps specific command keys to individual thread pools to provide strict resource isolation. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-execution-isolation.md))
- [Dependency-Isolated](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/task-orchestration-frameworks/thread-pools/dependency-isolated.md) — Provides dedicated thread pools for downstream service calls to prevent systemic thread exhaustion. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-execution-isolation.md))

### Scientific & Mathematical Computing

- [Frequent String Identification](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/frequent-string-identification.md) — Uses divide-and-conquer and prefix trees to identify the most frequent strings in large-scale data. ([source](https://github.com/doocs/advanced-java/blob/main/docs/big-data/find-hotest-query-string.md))

### Security & Cryptography

- [Application Access Controls](https://awesome-repositories.com/f/security-cryptography/application-access-controls.md) — Handles user authentication, authorization, and session management to secure application access. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-services-technology-stack.md))
- [Distributed Session Storage](https://awesome-repositories.com/f/security-cryptography/identity-access-management/session-management/server-side-session-stores/distributed-session-storage.md) — Provides mechanisms to share user session state across a cluster of servers for a consistent user experience. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/distributed-system-interview.md))
- [Sensitive Data Access Controls](https://awesome-repositories.com/f/security-cryptography/sensitive-data-access-controls.md) — Protects sensitive information and service access through granular identity and access management frameworks. ([source](https://github.com/doocs/advanced-java/blob/main/docs/micro-services/micro-service-governance.md))

### Web Development

- [Cache Invalidation Utilities](https://awesome-repositories.com/f/web-development/data-fetching-caching/cache-invalidation-utilities.md) — The system removes specific cached entries manually to ensure subsequent requests fetch the most recent data after an update. ([source](https://github.com/doocs/advanced-java/blob/main/docs/high-availability/hystrix-request-cache.md))
- [Dynamic Proxies](https://awesome-repositories.com/f/web-development/dynamic-proxies.md) — Generates proxy classes via bytecode manipulation or SPI extensions to handle inter-service communication. ([source](https://github.com/doocs/advanced-java/blob/main/docs/distributed-system/dubbo-load-balancing.md))