Yaien Blog Technical Notes

website·Indexed 31 days ago

https://yanggl.cn

A collection of technical tutorials and notes covering Java concurrency (ThreadLocal, StampedLock, BlockingQueue), Spring and SpringMVC frameworks, MySQL database basics and indexing, Docker installation and deployment, CentOS 8 Linux firewall commands, and Domain-Driven Design (DDD).

Tokens
75.9K
Snippets
256
Records
471
Agent score
50%

What's inside Yaien Blog

  1. Overview of Domain-Driven Design (DDD) Principles

    Domain-Driven Design (DDD), introduced by Eric Evans, is a software modeling approach used to manage complexity in large-scale systems. The core process involves collaboration between development teams and domain experts using a 'Ubiquitous Language' to understand and digest domain knowledge. This knowledge is then used to partition the system into sub-domains—categorized as Core, Generic, and Supporting sub-domains—where specific models are built and iteratively refined to align with the actual business domain.
  2. Introduction to Apache Dubbo

    Apache Dubbo is an RPC service development framework designed to solve service governance and communication issues in microservices architectures. It provides SDKs for multiple languages, including Java and Golang. Key capabilities include native remote address discovery, communication, and service governance features such as service discovery, load balancing, and traffic scheduling. Dubbo is highly extensible, allowing users to implement custom traffic interception and address selection logic. Recent evolutions include Dubbo3 and Proxyless Mesh, focusing on usability, large-scale microservices, cloud-native infrastructure adaptation, and security.
  3. Overview of AbstractQueuedSynchronizer (AQS)

    AbstractQueuedSynchronizer (AQS) is a framework class in Java's concurrency package used to build synchronizers such as locks and semaphores. It manages thread competition and waiting states using a FIFO double-linked list (wait queue) and atomic state transitions via CAS (Compare and Swap) operations. Key features include state management, thread blocking/unblocking, support for both exclusive and shared modes, reentrancy, and condition variable support via Condition objects.
  4. Overview of the Java Util Concurrent (JUC) package

    Java Util Concurrent (JUC), located in the java.util.concurrent package, is a comprehensive toolkit provided by Java for concurrent programming. It provides a set of high-level utilities and classes designed to simplify the development of multi-threaded applications, improve performance, and enhance scalability.
  5. Overview of MySQL Transaction Concurrency Mechanisms

    To handle concurrency issues arising from multiple simultaneous transactions, MySQL implements a comprehensive suite of mechanisms: Transaction Isolation levels, Locking mechanisms, Multi-Version Concurrency Control (MVCC), and Logging mechanisms.
  6. Overview of MySQL Transaction Concurrency Mechanisms

    To handle concurrency issues arising from multiple simultaneous transactions, MySQL employs a comprehensive set of mechanisms: Transaction Isolation levels, Locking mechanisms, Multi-Version Concurrency Control (MVCC), and Logging mechanisms.
  7. Overview of Apache Dubbo RPC Framework

    Apache Dubbo is an RPC service development framework designed to handle service governance and communication within microservices architectures. It provides SDKs for multiple languages, including Java and Golang. Key capabilities include native remote address discovery, communication, load balancing, and traffic scheduling. The framework is highly extensible, allowing developers to implement custom logic for traffic interception and service addressing. Modern iterations (Dubbo3, Proxyless Mesh) focus on cloud-native infrastructure adaptation, security, and scalability for large-scale microservices.
  8. Overview of Apache Dubbo RPC Framework

    Apache Dubbo is an RPC service development framework designed to handle service governance and communication within microservices architectures. It provides SDKs for multiple languages, including Java and Golang. Key capabilities include native remote address discovery, communication, service discovery, load balancing, and traffic scheduling. The framework is highly extensible, allowing developers to implement custom logic for traffic interception and address selection. Modern iterations include Dubbo3 and Proxyless Mesh, focusing on cloud-native infrastructure adaptation, security, and large-scale microservice practices.
  9. Overview of Skip List data structure

    A Skip List is a randomized data structure used for fast searching in an ordered sequence of elements. It is essentially an ordered linked list with multiple levels of indices that allow it to mimic binary search efficiency. By maintaining multiple layers of pointers, it can skip large portions of the list, achieving search, insertion, and deletion performance comparable to Red-Black Trees or AVL trees, but with a simpler implementation. In an ideal skip list, each higher level contains approximately 1/2 the number of nodes of the level below it.
  10. Overview of JVM Garbage Collectors

    JVM Garbage Collectors are responsible for reclaiming memory occupied by unused objects to prevent memory leaks. Common garbage collectors include Serial, Parallel Scavenge, ParNew, Serial Old, Parallel Old, CMS, G1, and ZGC.
  11. Overview of JVM Garbage Collectors

    The JVM Garbage Collector (GC) is responsible for reclaiming memory occupied by unused objects to prevent memory leaks. Common garbage collectors include Serial, Parallel Scavenge, ParNew, Serial Old, Parallel Old, CMS, G1, and ZGC.
  12. Overview of ArrayBlockingQueue

    ArrayBlockingQueue is a bounded blocking queue backed by an array, implementing the BlockingQueue interface in the java.util.concurrent package. It follows FIFO (First-In-First-Out) order, where the head of the queue is the oldest element. It is thread-safe, using a single ReentrantLock for both enqueue and dequeue operations, meaning producers and consumers cannot operate in parallel, which may become a performance bottleneck in high-concurrency scenarios.