Tagged articles

2077 articles

Page 17 of 21

Jul 8, 2020 · Fundamentals

Understanding Deadlocks: Causes, Conditions, Prevention, Detection, and Recovery

Deadlocks occur when multiple processes hold exclusive resources while waiting for each other, leading to indefinite blocking; this article explains deadlock concepts, resource types, the four necessary conditions, various detection and recovery methods, prevention strategies such as the banker’s algorithm, and related issues like livelocks and starvation.

ConcurrencyOperating SystemsSynchronization

0 likes · 28 min read

Understanding Deadlocks: Causes, Conditions, Prevention, Detection, and Recovery

Big Data Technology & Architecture

Jul 8, 2020 · Fundamentals

Understanding Java Locks: Optimistic vs Pessimistic, Spin Locks, and ReentrantLock

This article explains the various types of locks provided by Java, compares optimistic and pessimistic locking, introduces spin locks and adaptive spin locks, details lock states such as biased, lightweight, and heavyweight, and examines fair versus non‑fair, reentrant versus non‑reentrant, and exclusive versus shared locks with source code references.

CASConcurrencyJava

0 likes · 25 min read

Understanding Java Locks: Optimistic vs Pessimistic, Spin Locks, and ReentrantLock

Full-Stack Internet Architecture

Jul 6, 2020 · Backend Development

Analyzing JDK 1.8 FutureTask Source Code

This article provides a detailed analysis of JDK 1.8’s FutureTask implementation, explaining its purpose, usage examples, internal structure, state transitions, key methods such as run, get, cancel, and the concurrency mechanisms like volatile fields, CAS operations, and thread‑waiting queues.

CallableConcurrencyFuture

0 likes · 32 min read

Analyzing JDK 1.8 FutureTask Source Code

Selected Java Interview Questions

Jul 5, 2020 · Fundamentals

Java Concurrency Interview Questions and Answers: Wait/Notify, Locks, Volatile, AQS, Thread Pools, and More

This article provides a comprehensive overview of Java concurrency concepts for interview preparation, covering wait/notify mechanisms, atomicity, visibility, ordering, synchronized implementation, volatile semantics, Java Memory Model, AQS, lock characteristics, ReentrantLock, ReadWriteLock, thread pool configurations, and producer‑consumer patterns with code examples.

ConcurrencyJavaLocks

0 likes · 24 min read

Java Concurrency Interview Questions and Answers: Wait/Notify, Locks, Volatile, AQS, Thread Pools, and More

JavaEdge

Jul 5, 2020 · Backend Development

Why Java Concurrency Is Tricky: 4 Pitfalls Every Developer Must Avoid

The article explains why Java concurrency is fraught with hidden traps, outlines four key misconceptions, and offers practical guidance on safely using threads, understanding memory models, and recognizing the limits of testing and libraries.

ConcurrencyJavamultithreading

0 likes · 11 min read

Why Java Concurrency Is Tricky: 4 Pitfalls Every Developer Must Avoid

Full-Stack Internet Architecture

Jul 1, 2020 · Backend Development

Efficient Large File Reading in Java: Memory‑Friendly Approaches and Concurrency

This article explains how to read large files in Java without running out of memory by comparing full‑file loading, line‑by‑line reading using BufferedReader, Apache Commons IO, and Java 8 streams, and shows how to boost throughput with batch processing and multithreaded file splitting.

ConcurrencyFile I/OJava

0 likes · 12 min read

Efficient Large File Reading in Java: Memory‑Friendly Approaches and Concurrency

Mike Chen's Internet Architecture

Jun 30, 2020 · Fundamentals

Understanding Java Volatile Keyword and Memory Model

This article provides a comprehensive tutorial on Java's volatile keyword, covering its role in the Java Memory Model, the three concurrency fundamentals of atomicity, visibility, and ordering, and detailed explanations of volatile's visibility, ordering guarantees, implementation mechanisms, and a source code example.

ConcurrencyJMMJava

0 likes · 10 min read

Understanding Java Volatile Keyword and Memory Model

Ctrip Technology

Jun 29, 2020 · Backend Development

Controlling Goroutine Concurrency in Go: Risks of Unbounded Goroutine Creation and Practical Limiting Techniques

The article explains why creating unlimited Goroutines in Go can exhaust system resources, demonstrates the problem with a sample program, and presents practical methods—including channel throttling, sync.WaitGroup, and third‑party Goroutine pools—to safely limit concurrency and improve performance.

ChannelConcurrencyGo

0 likes · 10 min read

Controlling Goroutine Concurrency in Go: Risks of Unbounded Goroutine Creation and Practical Limiting Techniques

Programmer DD

Jun 29, 2020 · Backend Development

Why Spring Beans Aren’t Thread‑Safe and How ThreadLocal Solves It

This article explains that Spring does not guarantee thread safety for its beans, describes the various bean scopes, clarifies why stateless singleton beans are safe, and shows how ThreadLocal works—including its implementation, usage, and potential memory‑leak pitfalls—so developers can write correct concurrent code.

ConcurrencyJavaMemory Leak

0 likes · 17 min read

Why Spring Beans Aren’t Thread‑Safe and How ThreadLocal Solves It

FunTester

Jun 28, 2020 · Fundamentals

Mastering Java Thread Lifecycle: From NEW to TERMINATED Explained

This article provides a comprehensive guide to Java's thread lifecycle, detailing each of the six thread states, their meanings, how they are triggered, and practical code examples that demonstrate state transitions and logging output.

ConcurrencyJavaThread

0 likes · 10 min read

Mastering Java Thread Lifecycle: From NEW to TERMINATED Explained

Programmer DD

Jun 28, 2020 · Fundamentals

Unlocking Java AQS Shared Mode: How Semaphore Works Under the Hood

This article explains the shared‑mode acquisition in Java's AbstractQueuedSynchronizer, walks through the core template methods, compares them with exclusive mode, and demonstrates a classic application by dissecting the Semaphore source code and its usage patterns.

AQSConcurrencyJava

0 likes · 14 min read

Unlocking Java AQS Shared Mode: How Semaphore Works Under the Hood

Top Architect

Jun 27, 2020 · Databases

MySQL Lock Mechanisms: Row‑Level, Table‑Level, Page‑Level Locks and Optimistic vs Pessimistic Concurrency Control

This article explains MySQL's locking mechanisms, detailing row‑level, table‑level, and page‑level locks, their characteristics and usage, and compares optimistic and pessimistic concurrency control, including implementation methods, storage‑engine specifics, deadlock causes, and strategies to avoid them.

ConcurrencyInnoDBLocks

0 likes · 13 min read

MySQL Lock Mechanisms: Row‑Level, Table‑Level, Page‑Level Locks and Optimistic vs Pessimistic Concurrency Control

Java Backend Technology

Jun 27, 2020 · Fundamentals

Why Use a while Loop Instead of if with wait() in Java Synchronization?

This article explains why a while loop is required rather than an if statement when using wait() inside synchronized blocks, demonstrates the race condition with a bounded buffer example, shows the correct fix, discusses notifyAll versus notify, and illustrates how improper use can lead to deadlocks in Java multithreading.

ConcurrencyJavamultithreading

0 likes · 8 min read

Why Use a while Loop Instead of if with wait() in Java Synchronization?

Selected Java Interview Questions

Jun 26, 2020 · Backend Development

Why Executors Should Not Be Used to Create Thread Pools and How to Properly Configure ThreadPoolExecutor in Java

This article explains the definition of thread pools, why using Executors to create them is discouraged, details the ThreadPoolExecutor constructor and its parameters, compares different Executors factory methods, demonstrates OOM testing, and provides practical guidelines for defining safe thread‑pool parameters in Java.

ConcurrencyExecutorsJava

0 likes · 13 min read

Why Executors Should Not Be Used to Create Thread Pools and How to Properly Configure ThreadPoolExecutor in Java

Selected Java Interview Questions

Jun 25, 2020 · Fundamentals

Java Multithreading and Concurrency Basics: Threads, Synchronization, Thread Pools, and Common Pitfalls

This article introduces the fundamentals of Java multithreading and concurrency, covering the differences between processes and threads, the relationship between Thread and Runnable, start vs run, thread creation methods, handling return values, thread states, sleep vs wait, notify vs notifyAll, yield, interrupt, and the use of thread pools with executors.

CallableConcurrencyJava

0 likes · 21 min read

Java Multithreading and Concurrency Basics: Threads, Synchronization, Thread Pools, and Common Pitfalls

FunTester

Jun 25, 2020 · Backend Development

Implementing Asynchronous Test Case Execution with Thread Pool in Java

This article explains how to design and implement a multithreaded framework for executing test cases concurrently in Java, covering thread‑pool creation, a runnable test‑case class, collection execution logic, and parameter handling with user credentials and random data generation.

ConcurrencyJavaTestAutomation

0 likes · 8 min read

Implementing Asynchronous Test Case Execution with Thread Pool in Java

Full-Stack Internet Architecture

Jun 23, 2020 · Fundamentals

Understanding ThreadLocal: Introduction, Source Code, Problems, and Application Scenarios

This article explains the purpose and internal mechanics of Java's ThreadLocal class, walks through its core source‑code methods (get, set, remove, etc.), discusses memory‑leak pitfalls and mitigation, and outlines common usage patterns and interview questions for developers.

ConcurrencyInterviewJava

0 likes · 11 min read

Understanding ThreadLocal: Introduction, Source Code, Problems, and Application Scenarios

Java Architect Essentials

Jun 22, 2020 · Operations

ActiveMQ Message Queue Optimization: Removing Synchronized Lock and Tuning queuePrefetch

This article analyzes a severe ActiveMQ message‑queue backlog caused by a synchronized onMessage listener, then demonstrates how removing the lock and tuning the queuePrefetch parameter, along with a dual‑queue redesign, can boost consumption throughput by over thirty times, eliminating the data pile‑up.

ActiveMQConcurrencyMessage Queue

0 likes · 8 min read

ActiveMQ Message Queue Optimization: Removing Synchronized Lock and Tuning queuePrefetch

Full-Stack Internet Architecture

Jun 20, 2020 · Fundamentals

Java Basics: Features, Core Concepts, and Common Interview Questions

This article provides a comprehensive overview of Java fundamentals, covering language features, value vs. reference passing, equality operators, string immutability, static and final keywords, collections, concurrency, memory management, I/O, design patterns, and many typical interview topics.

CollectionsConcurrencyInterview

0 likes · 41 min read

Java Basics: Features, Core Concepts, and Common Interview Questions

ITPUB

Jun 19, 2020 · Backend Development

Beyond C10K: Uncovering the Theoretical Limits of Server and Client Concurrency

This article examines the classic C10K problem, explores its evolution to the C10M challenge, and analytically derives the theoretical maximum concurrent connections for servers and clients using five‑tuple calculations, port‑IP combinations, and NAT constraints, while highlighting practical limits and performance considerations.

C10KConcurrencyScalability

0 likes · 9 min read

Beyond C10K: Uncovering the Theoretical Limits of Server and Client Concurrency

FunTester

Jun 17, 2020 · Backend Development

How to Efficiently Manage Test User Login Credentials with Thread‑Safe Caching in Java

This article explains a practical approach to validate test‑account login status by using a special syntax, per‑user locking, and thread‑safe caching to avoid repeated logins, while discussing transaction isolation levels and propagation settings needed for reliable backend testing.

CacheConcurrencyJava

0 likes · 8 min read

How to Efficiently Manage Test User Login Credentials with Thread‑Safe Caching in Java

Programmer DD

Jun 17, 2020 · Fundamentals

What Really Happens When You Call Thread.Sleep? A Deep Dive into CPU Scheduling

This article explains the true behavior of Thread.Sleep, clarifies common misconceptions about its timing, compares Thread.Sleep(0) with no sleep, and uses a cake‑sharing analogy to illustrate time‑slice versus preemptive scheduling in operating systems.

CCPU schedulingConcurrency

0 likes · 10 min read

What Really Happens When You Call Thread.Sleep? A Deep Dive into CPU Scheduling

Java Backend Technology

Jun 16, 2020 · Backend Development

How to Optimize Java Thread Pool Settings for Maximum Performance

This article explains the principles behind Java thread pools, details the Executor framework, describes key parameters, provides formulas for calculating optimal thread counts for CPU‑bound and I/O‑bound workloads, and includes practical code examples and performance test results to help developers fine‑tune their thread pools.

ConcurrencyExecutorJava

0 likes · 14 min read

How to Optimize Java Thread Pool Settings for Maximum Performance

Architect's Tech Stack

Jun 15, 2020 · Backend Development

Understanding Java Stream Pipeline: Implementation Principles and Execution

This article explains how Java Stream pipelines are built and executed, covering operation recording, the role of stages and sinks, differences between intermediate and terminal operations, and how the library achieves efficient single-pass processing while avoiding common pitfalls.

ConcurrencyJavabackend

0 likes · 17 min read

Understanding Java Stream Pipeline: Implementation Principles and Execution

Selected Java Interview Questions

Jun 13, 2020 · Fundamentals

Why StringBuilder Is Not Thread‑Safe and How It Differs from StringBuffer

This article explains the internal implementation of Java's StringBuilder and StringBuffer, demonstrates how concurrent appends cause incorrect lengths and occasional ArrayIndexOutOfBoundsException, and shows why StringBuffer remains thread‑safe by using synchronized methods.

ConcurrencyJavastringbuffer

0 likes · 7 min read

Why StringBuilder Is Not Thread‑Safe and How It Differs from StringBuffer

Youzan Coder

Jun 12, 2020 · Fundamentals

When to Use synchronized vs. Lock: Mastering Java Locks

This article explains Java's lock mechanisms, comparing synchronized and the Lock interface, detailing their usage, implementation via AQS, system‑level primitives, and providing code examples to help developers choose the appropriate synchronization tool.

AQSConcurrencyJava

0 likes · 11 min read

When to Use synchronized vs. Lock: Mastering Java Locks

macrozheng

Jun 12, 2020 · Databases

Why Does MySQL Show Negative Balances? Unraveling MVCC and Isolation Levels

This article analyzes a production incident where concurrent MySQL transactions caused an over‑deduction of account balance, explains the underlying MVCC mechanism, consistency view rules, and how different isolation levels (RR vs RC) affect data visibility and lead to negative balances.

ConcurrencyDatabaseInnoDB

0 likes · 12 min read

Why Does MySQL Show Negative Balances? Unraveling MVCC and Isolation Levels

Selected Java Interview Questions

Jun 11, 2020 · Fundamentals

Understanding Java Runtime Memory Areas and the Java Memory Model

This article explains the distinction between Java memory regions and the Java Memory Model, describes each JVM runtime data area—including the program counter, stacks, heap, metaspace, and direct memory—and outlines how the model governs visibility, ordering, and synchronization in concurrent programs.

ConcurrencyGarbage CollectionJVM

0 likes · 20 min read

Understanding Java Runtime Memory Areas and the Java Memory Model

MaGe Linux Operations

Jun 10, 2020 · Fundamentals

Understanding Processes and Threads: Core Concepts, Lifecycle, and Scheduling

This article explains operating system fundamentals such as process and thread definitions, time‑slice preemptive scheduling, process features and lifecycle, thread characteristics, priority handling, multi‑core execution models, and synchronization mechanisms like mutexes and semaphores.

ConcurrencySchedulingThread

0 likes · 17 min read

Understanding Processes and Threads: Core Concepts, Lifecycle, and Scheduling

Python Programming Learning Circle

Jun 8, 2020 · Backend Development

Understanding Synchronous vs Asynchronous Programming in Python with asyncio and aiohttp

This article explains the limitations of Python's GIL, compares synchronous and asynchronous execution models, introduces asyncio and aiohttp, provides concrete code examples for single and multiple concurrent HTTP requests, and offers solutions for common concurrency errors such as too many file descriptors.

AsynchronousConcurrencyPython

0 likes · 8 min read

Understanding Synchronous vs Asynchronous Programming in Python with asyncio and aiohttp

Programmer DD

Jun 8, 2020 · Fundamentals

Why Java Replaced synchronized with Lock and How AQS Powers Modern Concurrency

This article explains why Java introduced the Lock API after Java 1.5, compares it with synchronized, details the explicit lock features, walks through the AQS (AbstractQueuedSynchronizer) implementation, and shows how ReentrantLock, fairness, reentrancy, and conditions are built on top of AQS.

AQSConcurrencyJava

0 likes · 36 min read

Why Java Replaced synchronized with Lock and How AQS Powers Modern Concurrency

Xueersi Online School Tech Team

Jun 5, 2020 · Fundamentals

Understanding Go Stack Memory Management: Initialization, Allocation, Expansion, and Shrinking

This article explains how Go's runtime initializes, allocates, expands, and shrinks goroutine stack memory, detailing the underlying heap structures, global pools, platform‑specific constants, and the code paths that handle stack growth and reclamation.

ConcurrencyGoGoroutine

0 likes · 11 min read

Understanding Go Stack Memory Management: Initialization, Allocation, Expansion, and Shrinking

Python Programming Learning Circle

Jun 4, 2020 · Fundamentals

Python Multiprocessing Module: Process Creation, Synchronization, and Inter‑Process Communication

This article provides a comprehensive guide to Python's multiprocessing module, covering how to create and manage processes, use join for synchronization, configure daemon processes, and employ synchronization primitives such as Lock, Semaphore, Event, and Queue for safe inter‑process communication, with complete code examples.

ConcurrencyInterprocess CommunicationPython

0 likes · 12 min read

Python Multiprocessing Module: Process Creation, Synchronization, and Inter‑Process Communication

Selected Java Interview Questions

Jun 2, 2020 · Backend Development

Deep Dive into ThreadPoolExecutor: Principles, State Control, and Source Code Analysis

This article provides a comprehensive analysis of Java's ThreadPoolExecutor, covering its underlying JUC synchronizer framework, core and non‑core thread handling, state management, key configuration parameters, and detailed walkthrough of critical source‑code methods such as execute, addWorker, and runWorker, supplemented with illustrative code examples.

AQSConcurrencyCoreThreadPool

0 likes · 30 min read

Deep Dive into ThreadPoolExecutor: Principles, State Control, and Source Code Analysis

Huawei Cloud Developer Alliance

Jun 1, 2020 · Fundamentals

Master Java Singleton: DCL, Volatile, Static Inner Class & Enum Explained

This article explores several advanced Java singleton implementations—including double‑check locking with volatile, static inner‑class lazy loading, and enum‑based singletons—explaining their mechanisms, thread‑safety benefits, and trade‑offs for modern backend development.

ConcurrencyDCLEnum

0 likes · 8 min read

Master Java Singleton: DCL, Volatile, Static Inner Class & Enum Explained

FunTester

Jun 1, 2020 · Backend Development

Avoiding Read‑Modify‑Write Race Conditions in ConcurrentHashMap Using Lambda compute

The article explains how read‑modify‑write race conditions can occur when updating a ConcurrentHashMap from multiple threads, demonstrates a failing JUnit example, and shows how using the atomic compute method with a lambda expression eliminates the race and ensures thread‑safe updates.

ComputeConcurrencyConcurrentHashMap

0 likes · 7 min read

Avoiding Read‑Modify‑Write Race Conditions in ConcurrentHashMap Using Lambda compute

Selected Java Interview Questions

May 31, 2020 · Backend Development

Java Interview Question Series (Issues 1‑100) – Collection of Article Links

This page compiles a chronological list of 100 WeChat articles covering Java interview topics, including core language concepts, data structures, concurrency, Spring, MySQL, Redis, and system design, providing readers with direct links to each issue for comprehensive preparation.

ConcurrencyData StructuresInterview

0 likes · 13 min read

Java Interview Question Series (Issues 1‑100) – Collection of Article Links

Laravel Tech Community

May 30, 2020 · Backend Development

Mastering Swoole Locks in PHP: Types, Methods, and Practical Examples

This guide explains how to use Swoole\Lock in PHP, covering the five supported lock types, constructor parameters, key methods such as lock, unlock, trylock, lockwait, and lock_read, along with best‑practice warnings and a complete example demonstrating inter‑process synchronization.

ConcurrencyLockPHP

0 likes · 5 min read

Mastering Swoole Locks in PHP: Types, Methods, and Practical Examples

Laravel Tech Community

May 29, 2020 · Backend Development

Swoole Coroutine Channel: Overview, Methods, and Example Usage

This article introduces Swoole's Coroutine Channel for inter‑coroutine communication, explains its memory‑efficient implementation and key methods such as __construct, push, pop, stats, close, length, isEmpty, isFull, capacity and errCode, and provides a complete PHP example demonstrating producer‑consumer behavior.

AsyncChannelConcurrency

0 likes · 5 min read

Swoole Coroutine Channel: Overview, Methods, and Example Usage

Laravel Tech Community

May 28, 2020 · Backend Development

Using Swoole Atomic for Lock‑Free Counters in PHP

Because PHP lacks native multithreading, Swoole adopts a multi‑process model and provides the Atomic class for lock‑free integer operations, which can be shared across worker processes; this guide explains its purpose, configuration, usage patterns, code examples, and important pitfalls.

ConcurrencyPHPServer

0 likes · 3 min read

Using Swoole Atomic for Lock‑Free Counters in PHP

macrozheng

May 27, 2020 · Backend Development

Master Java Thread Interruption: Using interrupt(), isInterrupted() & interrupted()

This article explains Java’s thread interruption mechanism, detailing the purpose and differences of interrupt(), isInterrupted() and interrupted(), how interruption flags work, when InterruptedException is thrown, proper handling practices, common usage scenarios, and examples from JDK classes such as ThreadPoolExecutor and FutureTask.

ConcurrencyInterrupt APIJava

0 likes · 12 min read

Master Java Thread Interruption: Using interrupt(), isInterrupted() & interrupted()

Programmer DD

May 26, 2020 · Backend Development

Deep Dive into Java's ConcurrentHashMap: Implementation, Put & Remove Mechanics

This article thoroughly examines Java's ConcurrentHashMap, covering its evolution from JDK 1.7 segmented locks to JDK 1.8's CAS‑based design, detailing key internal fields, the thread‑safe put and remove operations, and the complex resizing and transfer mechanisms that enable high‑concurrency performance.

ConcurrencyConcurrentHashMapHashMap

0 likes · 24 min read

Deep Dive into Java's ConcurrentHashMap: Implementation, Put & Remove Mechanics

FunTester

May 25, 2020 · Fundamentals

Understanding Java Daemon Threads and How to Create Them

This article explains what daemon threads are in Java, how they differ from user threads, the importance of setDaemon(true), provides the official setDaemon method documentation, and includes a complete demo program showing a daemon thread printing messages every second until the main thread ends.

ConcurrencyDaemon ThreadJava

0 likes · 4 min read

Understanding Java Daemon Threads and How to Create Them

Laravel Tech Community

May 21, 2020 · Databases

When to Use Optimistic vs. Pessimistic Locks in MySQL (and Redis)

This article explains the concepts, advantages, and drawbacks of MySQL pessimistic and optimistic locks, shows how to implement each with SQL and PHP code, compares their suitability for different traffic patterns, and demonstrates a Redis‑based optimistic lock for high‑concurrency flash‑sale scenarios.

ConcurrencyMySQLOptimistic Lock

0 likes · 10 min read

When to Use Optimistic vs. Pessimistic Locks in MySQL (and Redis)

Liangxu Linux

May 20, 2020 · Fundamentals

Essential Operating System Concepts: From Kernel Mode to Virtualization

This article provides a comprehensive, numbered glossary of core operating‑system concepts—including OS fundamentals, kernel and user modes, memory hierarchy, process management, I/O mechanisms, virtualization, and networking—each defined succinctly and illustrated with diagrams to aid understanding.

ConcurrencySecurityVirtualization

0 likes · 48 min read

Essential Operating System Concepts: From Kernel Mode to Virtualization

Sohu Tech Products

May 20, 2020 · Mobile Development

Understanding Deadlocks and Their Prevention in Android Development

This article explains the concept of deadlocks, illustrates classic scenarios such as the dining philosophers problem, shows common lock‑order and multi‑object deadlocks with Java code examples, and details Android's WatchDog mechanism and practical techniques for detecting and avoiding deadlocks in mobile applications.

ConcurrencyJavaWatchdog

0 likes · 21 min read

Understanding Deadlocks and Their Prevention in Android Development

Python Programming Learning Circle

May 20, 2020 · Fundamentals

Comprehensive Guide to Python Threading, Locks, Semaphores, Events and Timers

This article explains Python's threading module, demonstrating how to import it, create and manage single and multiple threads, use thread locks (Lock and RLock), condition variables, semaphores, events, thread‑local storage, and timers, providing complete code examples for each concept.

ConcurrencyEventLock

0 likes · 12 min read

Comprehensive Guide to Python Threading, Locks, Semaphores, Events and Timers

Programmer DD

May 20, 2020 · Backend Development

Understanding Java's java.util.concurrent (J.U.C) Framework and AQS Mechanism

This article provides a comprehensive overview of Java's java.util.concurrent package, detailing its core components such as atomic classes, locks, collections, executors, tools, as well as an in‑depth explanation of the AbstractQueuedSynchronizer (AQS) framework, its fields, methods, and related concurrency utilities like FutureTask, BlockingQueue, ForkJoin, and work‑stealing algorithms.

AQSConcurrencyForkJoin

0 likes · 22 min read

Understanding Java's java.util.concurrent (J.U.C) Framework and AQS Mechanism

Java Captain

May 14, 2020 · Fundamentals

Understanding Java volatile: Visibility, Ordering, and Usage in Concurrent Programming

This article explains Java's volatile keyword as a lightweight synchronization mechanism, covering its role in ensuring visibility, ordering, and limited atomicity, the underlying Java Memory Model concepts of atomicity, visibility, and ordering, and when volatile is appropriate or insufficient in concurrent programming.

ConcurrencyJavaMemory Model

0 likes · 12 min read

Understanding Java volatile: Visibility, Ordering, and Usage in Concurrent Programming

Full-Stack Internet Architecture

May 13, 2020 · Fundamentals

Java 8 New Features and Functional Programming Overview

An extensive guide to Java 8’s new capabilities, covering lambda expressions, functional interfaces, streams, default methods, Optional, CompletableFuture, the new date‑time API, concurrency enhancements, and numerous language and library improvements, with detailed explanations and code examples.

CompletableFutureConcurrencyFunctional Interfaces

0 likes · 51 min read

Java 8 New Features and Functional Programming Overview

Open Source Linux

May 11, 2020 · Fundamentals

Understanding Processes: Basics, Forking, and Lifecycle in Operating Systems

This article explains what a process is, how it differs from a program, outlines its key characteristics, clarifies concurrency versus parallelism, describes how to create child processes, and covers orphan and zombie processes, termination methods, process groups, sessions, and race conditions.

Concurrencyforkoperating system

0 likes · 7 min read

Understanding Processes: Basics, Forking, and Lifecycle in Operating Systems

FunTester

May 9, 2020 · Fundamentals

Mastering Java Synchronization: Object vs Class Locks Explained

This guide explains Java's synchronized keyword, detailing how object‑level and class‑level locks work, provides code examples for each, and lists essential best‑practice tips and common pitfalls to avoid when writing thread‑safe Java code.

ConcurrencyJavaLocks

0 likes · 6 min read

Mastering Java Synchronization: Object vs Class Locks Explained

58 Tech

May 8, 2020 · Backend Development

Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning

This article analyzes the performance bottlenecks of the 58 used‑car list service under high concurrency, breaks down data‑query and data‑transfer stages, and presents three optimization solutions—including query redesign, concurrent data conversion, and thread‑pool parameter tuning—that together reduce latency by over 80 ms and improve resource utilization.

ConcurrencyJavahigh concurrency

0 likes · 9 min read

Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning

Python Programming Learning Circle

May 8, 2020 · Fundamentals

Introduction to the Producer‑Consumer Model with Queue and JoinableQueue in Python

This article explains the producer‑consumer pattern, why it is needed, and demonstrates two Python implementations using a standard Queue and a JoinableQueue, including full code samples, execution results, and discussion of graceful termination for multiple consumers.

ConcurrencyJoinableQueueProducer Consumer

0 likes · 8 min read

Introduction to the Producer‑Consumer Model with Queue and JoinableQueue in Python

Big Data Technology & Architecture

May 7, 2020 · Fundamentals

Understanding the Implementation of ConcurrentHashMap in JDK 7 and JDK 8

This article explains how ConcurrentHashMap ensures thread safety in Java, comparing the lock‑segmentation design of JDK 7 with the CAS‑based, bucket‑level synchronization of JDK 8, and includes key source code excerpts illustrating the insertion process.

CASConcurrencyConcurrentHashMap

0 likes · 11 min read

Understanding the Implementation of ConcurrentHashMap in JDK 7 and JDK 8

Liangxu Linux

May 5, 2020 · Backend Development

Why Do “Average” Candidates Struggle in Java Interviews? Real Stories and Tips

The author reflects on recent campus recruitment interviews, sharing personal anecdotes, common pitfalls in Java fundamentals, collections, concurrency, and Redis, and offers practical advice on how candidates can improve their technical depth and interview performance.

ConcurrencyHashMapInterview

0 likes · 22 min read

Why Do “Average” Candidates Struggle in Java Interviews? Real Stories and Tips

dbaplus Community

Apr 27, 2020 · Backend Development

Why Your Redis Distributed Lock May Fail and How to Fix It

This article examines common failure scenarios of Redis‑based distributed locks, compares a simple lock implementation with the Redlock algorithm, and provides practical solutions for single‑point failures, lock expiration issues, clock drift, and high‑concurrency pitfalls.

ConcurrencyJavaLock Pitfalls

0 likes · 18 min read

Why Your Redis Distributed Lock May Fail and How to Fix It

Radish, Keep Going!

Apr 24, 2020 · Fundamentals

Mastering Go’s sync.Cond: Coordinating Goroutine Execution with Condition Variables

This article explains how Go's sync.Cond works, demonstrates its usage with practical code examples, analyzes its internal implementation, and shows a real‑world application in Kubernetes FIFO queues, helping developers control goroutine synchronization effectively.

ConcurrencyGoGoroutine

0 likes · 6 min read

Mastering Go’s sync.Cond: Coordinating Goroutine Execution with Condition Variables

MaGe Linux Operations

Apr 22, 2020 · Fundamentals

Demystifying Concurrency: From Threads to Coroutines and Monitors

This article clarifies core operating‑system concepts such as tasks, jobs, hyper‑threading, threads, processes, fibers, monitors, and coroutines, explaining their differences, relationships, and how they enable efficient concurrent execution.

ConcurrencyCoroutinesThreads

0 likes · 8 min read

Demystifying Concurrency: From Threads to Coroutines and Monitors

Programmer DD

Apr 22, 2020 · Backend Development

How ThreadLocal Guarantees Thread Isolation and Avoids Memory Leaks in Java

ThreadLocal provides thread‑confined variables in Java, eliminating race conditions without synchronization; this article explains its concept, demonstrates usage with code examples, analyzes the underlying ThreadLocalMap implementation, discusses hash calculations, potential memory‑leak pitfalls, and outlines common application scenarios.

ConcurrencyJavaMemory Leak

0 likes · 15 min read

How ThreadLocal Guarantees Thread Isolation and Avoids Memory Leaks in Java

Programmer DD

Apr 21, 2020 · Backend Development

Unlocking Java’s Unsafe: How CAS Powers High‑Performance Concurrency

This article explains Java's Unsafe class, its low‑level memory operations, how Compare‑and‑Swap (CAS) is implemented via Unsafe, and how AtomicInteger leverages CAS for lock‑free thread safety while also covering the ABA problem and its mitigation.

AtomicIntegerCASConcurrency

0 likes · 9 min read

Unlocking Java’s Unsafe: How CAS Powers High‑Performance Concurrency

Selected Java Interview Questions

Apr 17, 2020 · Backend Development

Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

This article explains the advantages of Java thread pools, breaks down the ThreadPoolExecutor parameters and execution flow, compares common pool types, and demonstrates how to implement a thread‑pool as a singleton to efficiently manage concurrency in backend applications.

ConcurrencyDesignPatternJava

0 likes · 10 min read

Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

Qunar Tech Salon

Apr 15, 2020 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Design, Implementation, and Dynamic Configuration

This article explains the concept, design, and internal implementation of Java's ThreadPoolExecutor, discusses common thread‑pool problems, presents dynamic configuration solutions, and provides practical usage scenarios and code examples to help developers efficiently manage concurrency in backend applications.

ConcurrencyDynamic ConfigurationJava

0 likes · 27 min read

Deep Dive into Java ThreadPoolExecutor: Design, Implementation, and Dynamic Configuration

Selected Java Interview Questions

Apr 13, 2020 · Backend Development

Differences Between synchronized and Lock in Java with Code Examples

This article explains Java's thread synchronization mechanisms by comparing synchronized blocks with the Lock interface, detailing thread basics, lifecycle methods, lock types, code demonstrations, fairness settings, and underlying JVM implementations, helping readers understand when and how to use each construct effectively.

ConcurrencyJavaLock

0 likes · 17 min read

Differences Between synchronized and Lock in Java with Code Examples

21CTO

Apr 12, 2020 · Backend Development

What I Learned from 20+ Java Backend Interviews: Questions, Answers, and Tips

The author, a 985‑master’s graduate, shares a detailed chronicle of her preparation and interview experiences across dozens of Chinese tech giants, listing the technical questions asked—ranging from Java fundamentals, JVM internals, concurrency, data structures, design patterns, to system design—and offering practical advice for future candidates.

AlgorithmsConcurrencyJVM

0 likes · 11 min read

What I Learned from 20+ Java Backend Interviews: Questions, Answers, and Tips

FunTester

Apr 11, 2020 · Operations

Building a Java Multithreaded Performance Testing Framework: Base and Execution Classes

This article explains how to design a Java performance testing framework by defining an abstract multithreaded base class for common behaviors, implementing two virtual classes for different load‑testing modes, and creating an execution class that orchestrates thread pools, collects metrics, and generates visual reports, with full source code examples and a Gitee repository link.

Code ExampleConcurrencyFramework

0 likes · 12 min read

Building a Java Multithreaded Performance Testing Framework: Base and Execution Classes

Selected Java Interview Questions

Apr 9, 2020 · Backend Development

Understanding Java Thread Pools: Benefits, Risks, and Best Practices

This article explains why Java thread pools are preferred over creating a new thread per request, outlines associated risks such as deadlocks, resource exhaustion, and thread leaks, and provides practical guidelines, sizing formulas, and code examples for various common thread‑pool implementations.

ConcurrencyJavaThreadPool

0 likes · 14 min read

Understanding Java Thread Pools: Benefits, Risks, and Best Practices

Programmer DD

Apr 7, 2020 · Fundamentals

Why Does HashMap Become Thread‑Unsafe? Deep Dive into JDK 7 & 8 Resizing Bugs

This article explains why Java's HashMap is not thread‑safe, analyzing the dead‑loop and data‑loss problems caused by resizing in JDK 7 and the overwrite issue in JDK 8, with code examples and step‑by‑step thread interleaving illustrations.

ConcurrencyHashMapJDK7

0 likes · 11 min read

Why Does HashMap Become Thread‑Unsafe? Deep Dive into JDK 7 & 8 Resizing Bugs

Open Source Linux

Apr 6, 2020 · Backend Development

What I Learned from My Alibaba CBU Technical Interview: A Detailed Self‑Review

This article recounts the author's Alibaba CBU technical interview experience, covering self‑introduction, core computer‑science topics such as data structures, concurrency, HTTP, and security, reflections on the interview process, and a concrete plan for future technical growth.

ConcurrencyData Structuresbackend

0 likes · 10 min read

What I Learned from My Alibaba CBU Technical Interview: A Detailed Self‑Review

Meituan Technology Team

Apr 2, 2020 · Backend Development

Java ThreadPoolExecutor: Design, Implementation, and Dynamic Management

The article explains Java’s ThreadPoolExecutor—its purpose, core design, lifecycle management, task scheduling, worker behavior, and typical configurations for fast response or batch processing—then proposes a dynamic pool with runtime‑adjustable core and max sizes, queue selection, and real‑time monitoring to prevent mis‑configuration and boost stability.

ConcurrencyDynamic ConfigurationJava

0 likes · 30 min read

Java ThreadPoolExecutor: Design, Implementation, and Dynamic Management

Programmer DD

Mar 29, 2020 · Fundamentals

Mastering Java Thread Lifecycle: States, Transitions, and Debugging Tips

This article explains Java thread lifecycle, compares OS generic thread states with Java’s six states, shows how to query thread state via getState(), and introduces debugging tools like jstack and Arthas, helping developers master state transitions and write robust concurrent code.

ArthasConcurrencyDebugging

0 likes · 12 min read

Mastering Java Thread Lifecycle: States, Transitions, and Debugging Tips

Selected Java Interview Questions

Mar 29, 2020 · Backend Development

Understanding Java Synchronized: Basic Usage, Underlying Mechanism, and Execution Results

This article explains the three forms of using the synchronized keyword in Java—method, static method, and block synchronization—demonstrates each with runnable code examples, analyzes the JVM monitorenter/monitorexit instructions, and clarifies why synchronized methods and blocks enforce mutual exclusion and visibility guarantees.

ConcurrencyJVMJava

0 likes · 13 min read

Understanding Java Synchronized: Basic Usage, Underlying Mechanism, and Execution Results

Selected Java Interview Questions

Mar 25, 2020 · Backend Development

Comprehensive Guide to Java HashMap: Structure, Operations, Concurrency Issues, and Interview Insights

This article provides an in‑depth explanation of Java's HashMap, covering its array‑plus‑linked‑list (and tree) structure, default capacity and load factor, constructors, put/get workflows, concurrency pitfalls, differences between Java 7 and 8, and key points to ace interview questions.

ConcurrencyData StructureHashMap

0 likes · 8 min read

Comprehensive Guide to Java HashMap: Structure, Operations, Concurrency Issues, and Interview Insights

FunTester

Mar 23, 2020 · Backend Development

Curated Collection of Java, Groovy, and Python Technical Articles

This article presents a curated list of technical resources covering Java, Groovy, and Python, including tutorials on concurrency, memory management, regular expressions, scripting, and performance optimization, each linked to detailed explanations and code examples.

ConcurrencyGroovyJava

0 likes · 9 min read

Curated Collection of Java, Groovy, and Python Technical Articles

Programmer DD

Mar 22, 2020 · Fundamentals

Why Use Locks in Java? Understanding volatile, synchronized, and CAS

This article explains why Java uses locks to prevent dirty reads and data inconsistency, compares volatile and synchronized mechanisms, details monitor-based lock implementation, lock optimizations like biased and lightweight locks, introduces CAS and AbstractQueuedSynchronizer, and illustrates these concepts with code examples and diagrams.

AQSCASConcurrency

0 likes · 13 min read

Why Use Locks in Java? Understanding volatile, synchronized, and CAS

Programmer DD

Mar 21, 2020 · Fundamentals

Why Does Concurrent Programming Need Wait/Notify? Unlock Efficient Thread Coordination

This article explains why busy‑waiting loops waste CPU in Java concurrency, introduces the wait/notify mechanism, shows how synchronized, wait() and notify()/notifyAll() work together, highlights common pitfalls such as using if instead of while, and provides practical code examples and best‑practice guidelines for safe thread coordination.

ConcurrencyJavaMESA Model

0 likes · 14 min read

Why Does Concurrent Programming Need Wait/Notify? Unlock Efficient Thread Coordination

Ctrip Technology

Mar 19, 2020 · Mobile Development

Ctrip Hotel Android Map Development: Architecture, Challenges, and Solutions

This article details the design and implementation of Ctrip's hotel Android map features, covering business background, module architecture, coordinate system handling, multithreading challenges, and practical solutions such as MVP, AsyncTask, and atomic flags to ensure smooth user experience.

AndroidConcurrencyKotlin

0 likes · 10 min read

Ctrip Hotel Android Map Development: Architecture, Challenges, and Solutions

Open Source Linux

Mar 16, 2020 · Operations

QPS vs TPS vs Concurrency: Uncovering the Real Difference in System Throughput

This article explains core performance metrics such as Queries Per Second (QPS) and Transactions Per Second (TPS), distinguishes their differences, introduces related concepts like concurrency, PV, UV, and DAU, and outlines how to evaluate system throughput and conduct basic performance testing.

ConcurrencyQPSTPS

0 likes · 9 min read

QPS vs TPS vs Concurrency: Uncovering the Real Difference in System Throughput

Selected Java Interview Questions

Mar 16, 2020 · Databases

Understanding MySQL Table Locks, Row Locks, and Gap Locks

This article explains the differences between MySQL table locks and row locks, describes how MyISAM and InnoDB handle locking, provides explicit lock syntax with examples, discusses gap locks, and offers practical recommendations for avoiding lock contention in concurrent applications.

ConcurrencyGap LockInnoDB

0 likes · 7 min read

Understanding MySQL Table Locks, Row Locks, and Gap Locks

FunTester

Mar 15, 2020 · Backend Development

Curated Collection of Java, Groovy, and Python Articles

This curated collection presents dozens of Chinese-language articles covering Java, Groovy, and Python topics such as concurrency, performance optimization, regular expressions, JMeter scripting, and algorithmic challenges, providing links to in-depth tutorials and code examples for developers seeking to deepen their programming expertise.

AlgorithmsConcurrencyGroovy

0 likes · 9 min read

Curated Collection of Java, Groovy, and Python Articles

Programmer DD

Mar 8, 2020 · Backend Development

Mastering Java NIO File Locks: Exclusive & Shared Lock Techniques

This tutorial explains how to use Java NIO's FileChannel to acquire exclusive and shared file locks, covering lock types, required channel modes, code examples for FileOutputStream, RandomAccessFile, and FileInputStream, and discusses platform-specific considerations and common exceptions.

Backend DevelopmentConcurrencyFile I/O

0 likes · 10 min read

Mastering Java NIO File Locks: Exclusive & Shared Lock Techniques

Xueersi Online School Tech Team

Mar 6, 2020 · Backend Development

Understanding Go's sync.Pool: Implementation, Usage Scenarios, and Evolution from Go 1.12 to 1.13

This article explains what a sync.Pool object pool is, when it should be used, details the Go 1.12 implementation with its internal structures and algorithms, describes the enhancements introduced in Go 1.13, and analyzes the resulting performance improvements for high‑concurrency backend applications.

ConcurrencyGoobject pool

0 likes · 18 min read

Understanding Go's sync.Pool: Implementation, Usage Scenarios, and Evolution from Go 1.12 to 1.13

Programmer DD

Mar 6, 2020 · Backend Development

Mastering Java ThreadPoolExecutor Rejection Policies: When and How to Use Them

This article explains the design principles of thread pools, when Java's ThreadPoolExecutor triggers rejection policies, details the four built‑in JDK policies with code examples, and explores additional strategies from Dubbo, Netty, ActiveMQ and Pinpoint, helping developers choose the right approach for their workloads.

ConcurrencyJDKJava

0 likes · 13 min read

Mastering Java ThreadPoolExecutor Rejection Policies: When and How to Use Them

Selected Java Interview Questions

Mar 4, 2020 · Backend Development

Classification and Explanation of Java Locks for Interview Preparation

This article summarizes the main types of Java locks—including fair/unfair, reentrant, exclusive/shared, mutex/read‑write, optimistic/pessimistic, segment, biased/lightweight/heavyweight, and spin locks—provides brief definitions, usage notes, and a code example to help interview candidates answer concurrency questions effectively.

ConcurrencyInterviewJava

0 likes · 8 min read

Classification and Explanation of Java Locks for Interview Preparation

Xueersi Online School Tech Team

Feb 28, 2020 · Fundamentals

Understanding Locks and Mutex Implementation in Go

This article explains the concept of locks, why they are needed in concurrent programming, and provides an in‑depth look at Go's synchronization primitives—including CAS, atomic operations, spinlocks, semaphores, and the evolution of the sync.Mutex implementation with code examples and performance considerations.

ConcurrencyGolangLock

0 likes · 17 min read

Understanding Locks and Mutex Implementation in Go

FunTester

Feb 26, 2020 · Fundamentals

Why Thread‑Safe Collections Still Fail with Non‑Thread‑Safe Objects in Java

Through a series of Java demos, this article examines how storing non‑thread‑safe objects inside thread‑safe collections like ConcurrentHashMap or CopyOnWriteArrayList can still cause concurrency bugs, explains the underlying remove() implementation, and shows how switching to a thread‑safe Vector resolves the issue.

CollectionsConcurrencyConcurrentHashMap

0 likes · 8 min read

Why Thread‑Safe Collections Still Fail with Non‑Thread‑Safe Objects in Java

Xiaokun's Architecture Exploration Notes

Feb 25, 2020 · Fundamentals

Why Thread Context Switching Slows Your Java App—and How to Fix It

This article explains how thread context switching and concurrency affect Java program performance, demonstrates the impact with code examples and benchmarks, and provides practical solutions for thread safety, visibility, deadlock avoidance, and resource optimization.

Concurrencycontext switchingthreading

0 likes · 10 min read

Why Thread Context Switching Slows Your Java App—and How to Fix It

FunTester

Feb 24, 2020 · Backend Development

Achieving Thread‑Safe Java Performance Tests Without Locks

This article explains why traditional locking harms Java performance‑testing throughput, introduces lock‑free alternatives such as CAS and ThreadLocal, and provides a complete Java demo that shows how each thread can hold its own object to eliminate contention and boost speed.

ConcurrencyJavaThreadLocal

0 likes · 5 min read

Achieving Thread‑Safe Java Performance Tests Without Locks

Programmer DD

Feb 21, 2020 · Backend Development

Mastering Thread Termination in Java: Safe Practices and Common Pitfalls

This article explains how to properly stop a Java thread, compares deprecated Thread.stop() with interruption techniques, demonstrates checking a thread's interrupted state, shows how to use exceptions and return statements for graceful termination, and warns about the dangers of forceful stops and lock release.

ConcurrencyExceptionJava

0 likes · 12 min read

Mastering Thread Termination in Java: Safe Practices and Common Pitfalls

Python Programming Learning Circle

Feb 20, 2020 · Backend Development

Understanding Backpressure in Asynchronous Systems

Backpressure, the resistance to data flow in overloaded systems, is crucial for reliable asynchronous programming; this article explains its concepts, illustrates pitfalls in Python asyncio and other languages, and presents strategies such as buffering, draining, semaphores, and protocol-level flow control to manage overload.

AsyncConcurrencyFlow Control

0 likes · 16 min read

Understanding Backpressure in Asynchronous Systems

High Availability Architecture

Feb 20, 2020 · Fundamentals

Structured Concurrency in Rust: Concepts, Scope Implementation, and Practical Examples

This article introduces the challenges of traditional concurrency, explains the structured concurrency paradigm, surveys its history and implementations across languages, and provides a detailed Rust example using the task_scope library with Scope, CancelScope, timeout handling, nested scopes, and a practical Happy Eyeballs exercise.

Concurrencyasynchronous programmingcancellation

0 likes · 12 min read

Structured Concurrency in Rust: Concepts, Scope Implementation, and Practical Examples

Qunar Tech Salon

Feb 19, 2020 · Fundamentals

Deep Dive into Java's AbstractQueuedSynchronizer (AQS) and ReentrantLock

This article provides a comprehensive analysis of Java's AbstractQueuedSynchronizer (AQS) framework, explains how ReentrantLock is built on AQS, walks through lock acquisition and release mechanisms, discusses queue management, and demonstrates how to create a custom lock using AQS.

AQSConcurrencyJava

0 likes · 32 min read

Deep Dive into Java's AbstractQueuedSynchronizer (AQS) and ReentrantLock

FunTester

Feb 18, 2020 · Backend Development

Why Java’s volatile Can’t Replace Synchronization: Understanding Memory Consistency and Deadlocks

This article explains Java memory‑consistency problems, demonstrates how stale values arise with unsynchronized threads, shows how volatile and synchronized provide happens‑before guarantees, and illustrates common synchronization pitfalls such as reference locks and deadlocks with concrete code examples.

ConcurrencyJavaMemory Model

0 likes · 7 min read

Why Java’s volatile Can’t Replace Synchronization: Understanding Memory Consistency and Deadlocks

FunTester

Feb 17, 2020 · Fundamentals

Mastering Thread‑Safe Objects in Java: From Synchronized Collections to Atomic Variables

This article explains how Java threads share objects, why immutable objects are safest, how to make mutable collections thread‑safe using synchronized wrappers or concurrent classes, handles non‑thread‑safe types like SimpleDateFormat, and demonstrates race‑condition fixes with synchronized blocks and AtomicInteger.

AtomicIntegerCollectionsConcurrency

0 likes · 10 min read

Mastering Thread‑Safe Objects in Java: From Synchronized Collections to Atomic Variables

FunTester

Feb 15, 2020 · Backend Development

Understanding Double-Checked Locking Singleton Pattern in Java

This article explains the double‑checked locking design pattern for thread‑safe singletons in Java, demonstrates its performance drawbacks, and presents alternative implementations such as early initialization, init‑on‑demand holder, and enum‑based singletons, highlighting their advantages and limitations.

ConcurrencyJavaSingleton

0 likes · 6 min read

Understanding Double-Checked Locking Singleton Pattern in Java

Java Interview Crash Guide

Feb 12, 2020 · Backend Development

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

Distributed locks ensure that, across hundreds of servers handling millions of concurrent red‑packet requests, only one instance updates the shared total at a time, preventing inconsistencies and deadlocks, with implementations ranging from Java synchronized blocks to Redis SETNX and Zookeeper Znode mechanisms.

ConcurrencyZooKeeperdistributed-lock

0 likes · 14 min read

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

FunTester

Feb 12, 2020 · Backend Development

How to Stress-Test a VIP Payment Callback API with Distributed Locks

This article walks through a complete performance‑testing setup for a VIP purchase callback API, detailing the request flow, distributed‑lock handling with Redis, parameter generation using AtomicInteger, Java implementation, and pitfalls to ensure accurate, high‑concurrency testing.

APIConcurrencyJava

0 likes · 6 min read

How to Stress-Test a VIP Payment Callback API with Distributed Locks

Alibaba Cloud Native

Feb 6, 2020 · Operations

How Modern Schedulers Work: From Linux Kernels to Go Runtime and Kubernetes

This article explores the design principles, evolution, and implementation details of schedulers across operating systems, the Go programming language runtime, and Kubernetes, covering concepts such as task and resource allocation, cooperative vs. preemptive scheduling, work‑stealing, priority algorithms, and the latest scheduling framework extensions.

ConcurrencySchedulinggo runtime

0 likes · 55 min read

How Modern Schedulers Work: From Linux Kernels to Go Runtime and Kubernetes

Xiaokun's Architecture Exploration Notes

Jan 28, 2020 · Fundamentals

Why Java’s final Keyword Guarantees Thread Safety – Deep Dive

This article explains the semantics of Java's final keyword, how the compiler and JVM enforce immutability and memory‑barrier rules, and why final fields provide thread‑safe, write‑once‑read‑many behavior for both instance and static variables.

ConcurrencyJavafinal

0 likes · 13 min read

Why Java’s final Keyword Guarantees Thread Safety – Deep Dive