BestHub
Sign in
Tagged articles

concurrency

2234 articles · Page 21 of 23
Zhuanzhuan Tech
Zhuanzhuan Tech
Jan 17, 2019 · Backend Development

Design and Refactoring of the Book Outbound Service with SN Allocation and Concurrency Management

The article describes the challenges of handling book outbound operations—matching SN codes, ensuring data consistency, and avoiding lock contention—and outlines a comprehensive refactor that separates business logic, standardizes APIs, adopts asynchronous processing, and leverages Redis sets to achieve high‑performance, reliable SN allocation.

InventoryRedisRefactoring
0 likes · 10 min read
Design and Refactoring of the Book Outbound Service with SN Allocation and Concurrency Management
Architect's Tech Stack
Architect's Tech Stack
Jan 17, 2019 · Backend Development

Comprehensive Java Interview Questions and Topics

This article compiles an extensive list of Java interview questions covering fundamentals, concurrency, collections, JVM internals, I/O, design patterns, testing, and best practices, providing candidates with a comprehensive study guide for modern backend development roles.

Design PatternsInterviewJVM
0 likes · 12 min read
Comprehensive Java Interview Questions and Topics
Programmer DD
Programmer DD
Dec 11, 2018 · Backend Development

Top 20 Java Interview Questions for Investment Banking (Answers Included)

This article compiles 20 common Java interview questions asked by investment banks, covering topics such as multithreaded HashMap usage, hashCode/equals contracts, String substring memory issues, singleton patterns, design patterns, deadlock avoidance, and performance considerations, each accompanied by concise answers and code examples.

CollectionsDesign PatternsInterview
0 likes · 18 min read
Top 20 Java Interview Questions for Investment Banking (Answers Included)
dbaplus Community
dbaplus Community
Dec 3, 2018 · Backend Development

Mastering Distributed Locks: DB, Redis, and Zookeeper Implementations Compared

This article examines the design and implementation of distributed locks using databases, Redis, and Zookeeper, outlining their core characteristics, practical code patterns, performance trade‑offs, fault‑tolerance mechanisms, and guidance on selecting the right solution for specific workloads.

DB lockRedis LockSystem Design
0 likes · 11 min read
Mastering Distributed Locks: DB, Redis, and Zookeeper Implementations Compared
MaGe Linux Operations
MaGe Linux Operations
Dec 2, 2018 · Backend Development

Master Python asyncio: From Coroutines to Event Loops Explained

This article introduces Python's asyncio library, explains how coroutines are defined and run, demonstrates event‑loop management with run_until_complete and run_forever, covers callbacks, gathering multiple coroutines, and best practices for closing loops, all illustrated with clear code screenshots.

Asynchronous Programmingasyncioconcurrency
0 likes · 7 min read
Master Python asyncio: From Coroutines to Event Loops Explained
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 20, 2018 · Backend Development

Comprehensive Java Multithreading and Concurrency Interview Questions and Answers

This article compiles 46 essential Java multithreading and concurrency interview questions with detailed answers, covering fundamentals such as atomicity, visibility, ordering, thread creation methods, thread pools, synchronization mechanisms, lock types, AQS, deadlocks, and performance considerations for high‑performance backend development.

InterviewJavaThreadPool
0 likes · 24 min read
Comprehensive Java Multithreading and Concurrency Interview Questions and Answers
MaGe Linux Operations
MaGe Linux Operations
Nov 17, 2018 · Fundamentals

Master Python Multithreading: Processes, GIL, and Threading Modules Explained

This article explains the fundamentals of Python concurrency, covering the differences between processes and threads, the role of the Global Interpreter Lock (GIL), how to use the low‑level thread module and the high‑level threading module, synchronization primitives such as Lock, RLock, Event, Condition, and the Queue module for producer‑consumer patterns.

GILconcurrencymultithreading
0 likes · 19 min read
Master Python Multithreading: Processes, GIL, and Threading Modules Explained
Ctrip Technology
Ctrip Technology
Nov 15, 2018 · Mobile Development

Optimizing Startup Process for Platform-Scale Mobile Apps: The Rocket Framework at Trip.com

This article shares Trip.com’s experience in redesigning the mobile app launch process through componentization, concurrent initialization, visual monitoring, and automated experiments, culminating in the Rocket framework that reduced startup time by over 40% while keeping modules isolated and crash‑resilient.

Rocket frameworkTrip.comapp startup
0 likes · 12 min read
Optimizing Startup Process for Platform-Scale Mobile Apps: The Rocket Framework at Trip.com
Meituan Technology Team
Meituan Technology Team
Nov 15, 2018 · Backend Development

Understanding Java Locks: Optimistic, Pessimistic, CAS, and Various Lock Types

The article explains Java’s various lock mechanisms—including optimistic vs. pessimistic, spin and adaptive spin, no‑lock through heavyweight states, fair vs. unfair, reentrant vs. non‑reentrant, and exclusive vs. shared locks—using JDK 8 source code and practical examples to guide developers in choosing the appropriate lock for different concurrency scenarios.

CASJavaLocks
0 likes · 26 min read
Understanding Java Locks: Optimistic, Pessimistic, CAS, and Various Lock Types
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 14, 2018 · Fundamentals

Implementation Principles of ConcurrentHashMap (CurrentHashMap) in JDK 1.7 and JDK 1.8

This article explains the underlying principles of hash tables, compares HashMap, Hashtable and ConcurrentHashMap, and details the architectural differences of ConcurrentHashMap in JDK 1.7 (segment‑based locking) versus JDK 1.8 (array‑list‑tree with CAS), including code examples and performance trade‑offs.

ConcurrentHashMapHashMapJDK1.7
0 likes · 8 min read
Implementation Principles of ConcurrentHashMap (CurrentHashMap) in JDK 1.7 and JDK 1.8
Programmer DD
Programmer DD
Nov 12, 2018 · Backend Development

Why Did My Java ThreadPool Hang? Uncovering a Hidden HashSet Loop in JDK 1.7

A production Java service suffered a thread‑pool alarm due to an unbounded LinkedBlockingQueue and a non‑thread‑safe HashSet, leading to massive memory usage, a circular linked‑list loop in HashMap, and severe CPU load, which was resolved by switching to ConcurrentHashMap and tuning the pool.

HashSetJavaMemoryAnalysis
0 likes · 8 min read
Why Did My Java ThreadPool Hang? Uncovering a Hidden HashSet Loop in JDK 1.7
Java Captain
Java Captain
Nov 11, 2018 · Backend Development

Implementing Optimistic Lock for Red Packet System in Java with Versioning and Retry Mechanisms

This article explains how to fix red‑packet over‑issuance bugs using optimistic locking with CAS, introduces version fields to prevent ABA problems, shows DAO, service and controller code updates, and demonstrates time‑based and count‑based retry strategies to improve success rates under high concurrency.

CASJavaOptimistic Locking
0 likes · 14 min read
Implementing Optimistic Lock for Red Packet System in Java with Versioning and Retry Mechanisms
Beike Product & Technology
Beike Product & Technology
Nov 9, 2018 · Backend Development

Why Go Is Fast: 5 Key Language Features Explained

This article translates David Cheney's 2014 Gocon talk, detailing five Go language features—efficient value handling, inlining, escape analysis, goroutine scheduling, and dynamic stack management—that together explain Go's performance advantages, memory usage, and concurrency model.

Escape AnalysisGoMemory
0 likes · 15 min read
Why Go Is Fast: 5 Key Language Features Explained
Programmer DD
Programmer DD
Nov 9, 2018 · Backend Development

How Java’s Producer‑Consumer Problem Evolved: From Classic Locks to BlockingQueue and Thread Pools

This article walks through the classic Java producer‑consumer synchronization challenge, shows its traditional lock‑based solution, then demonstrates modern approaches using BlockingQueue and ExecutorService thread pools to simplify code, improve reliability, and avoid common pitfalls like deadlocks and thread starvation.

BlockingQueueJavaThreadPool
0 likes · 15 min read
How Java’s Producer‑Consumer Problem Evolved: From Classic Locks to BlockingQueue and Thread Pools
Java Captain
Java Captain
Nov 3, 2018 · Fundamentals

Differences Between synchronized and Lock in Java and Their Usage

This article explains the fundamental differences between Java's synchronized keyword and the Lock interface, covering thread basics, lock types, a detailed comparison table, and practical code demos that illustrate how to acquire, try, and release locks in various scenarios.

Lockconcurrencyjava-lock
0 likes · 14 min read
Differences Between synchronized and Lock in Java and Their Usage
Hujiang Technology
Hujiang Technology
Oct 29, 2018 · Backend Development

Implementing a Custom Java AQS Lock from Scratch

This tutorial walks through building a simple Java lock using AbstractQueuedSynchronizer (AQS), starting with a basic MyLock class, adding thread parking with Unsafe, creating a FIFO thread container, and refining lock and unlock methods to achieve correct synchronization and avoid lock starvation.

AQSJavaLock
0 likes · 15 min read
Implementing a Custom Java AQS Lock from Scratch
UCloud Tech
UCloud Tech
Oct 25, 2018 · Backend Development

Why Go 1.8’s ForkLock Can Hang Goroutines and How Go 1.9 Solves It

The article investigates a Go 1.8.3 issue where goroutines block on ForkLock during fork‑exec, analyzes the kernel and Go runtime behavior, presents a hypothesis about memory‑heavy processes, validates it with experiments, and shows that upgrading to Go 1.9 or later eliminates the problem.

Goconcurrencyforklock
0 likes · 7 min read
Why Go 1.8’s ForkLock Can Hang Goroutines and How Go 1.9 Solves It
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 17, 2018 · Backend Development

Understanding CopyOnWriteArrayList in Java: Implementation, Principles, and Comparison with ArrayList

CopyOnWriteArrayList is a thread‑safe variant of ArrayList that achieves read‑write separation by copying the underlying array on each mutative operation, using a ReentrantLock for writes, making it ideal for read‑heavy, write‑light scenarios, and it differs from ArrayList in safety, performance, and concurrency behavior.

CopyOnWriteArrayListData StructuresJava
0 likes · 5 min read
Understanding CopyOnWriteArrayList in Java: Implementation, Principles, and Comparison with ArrayList
Programmer DD
Programmer DD
Oct 16, 2018 · Backend Development

Deep Dive into ThreadPoolExecutor: Uncover How Java Manages Thread Pools

This article provides a comprehensive analysis of Java's ThreadPoolExecutor source code, covering class relationships, core interfaces, abstract implementations, internal fields, constructors, the Worker class, and detailed walkthroughs of key methods such as execute, addWorker, runWorker, getTask, processWorkerExit, tryTerminate, and idle thread interruption, plus monitoring techniques.

JavaThreadPoolExecutorbackend development
0 likes · 19 min read
Deep Dive into ThreadPoolExecutor: Uncover How Java Manages Thread Pools
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 30, 2018 · Backend Development

BAT Technical Interview Topics and Experience Summary

This guide outlines the key technical interview areas for BAT companies—including algorithms, Java fundamentals and advanced topics, frameworks, concurrency, networking, databases, and architecture—provides example questions with visual references, and shares practical interview and project experience tips to help candidates succeed.

InterviewJavaarchitecture
0 likes · 4 min read
BAT Technical Interview Topics and Experience Summary
UC Tech Team
UC Tech Team
Sep 25, 2018 · Frontend Development

Understanding JavaScript Event Loop: Theory and Practice

This article explains the JavaScript Event Loop mechanism in depth, covering the call stack, heap memory, macro‑ and micro‑tasks, and their queues, and demonstrates the execution order through detailed examples and step‑by‑step visualizations of multiple event‑loop cycles.

JavaScriptNode.jsasync
0 likes · 7 min read
Understanding JavaScript Event Loop: Theory and Practice
Java Captain
Java Captain
Sep 20, 2018 · Backend Development

Common Cache Problems and Their Mitigation Strategies

The article explains major cache issues such as consistency, concurrency, penetration, jitter, avalanche, and the “bottomless pit” phenomenon, and outlines practical techniques like locking, empty‑object caching, request filtering, consistent hashing, rate limiting, and multi‑level caching to prevent system failures.

Cache AvalancheCache Penetrationcaching
0 likes · 8 min read
Common Cache Problems and Their Mitigation Strategies
Programmer DD
Programmer DD
Aug 17, 2018 · Fundamentals

How LinkedTransferQueue Works: The Smart Lock‑Free Queue Behind Java Concurrency

LinkedTransferQueue, introduced in JDK 7, combines the capacity of traditional BlockingQueues with the lock‑free behavior of SynchronousQueue, using a sophisticated node‑based algorithm that matches producers and consumers without locking the whole queue, offering high‑performance concurrent data transfer.

BlockingQueueJavaLinkedTransferQueue
0 likes · 16 min read
How LinkedTransferQueue Works: The Smart Lock‑Free Queue Behind Java Concurrency
Meitu Technology
Meitu Technology
Aug 15, 2018 · Backend Development

Design and Performance Analysis of the Zap Logging Library in Go

The article examines Uber’s high‑throughput Go logging library zap, detailing its structured‑logging design, separation of concerns, copy‑on‑write filtering, extensive sync.Pool object reuse, reflection‑free type‑specific encoding, dynamic HTTP level control, and supplemental features such as a sugar API and log‑rotation, which together deliver superior performance over traditional libraries.

GoLoggingPerformance
0 likes · 18 min read
Design and Performance Analysis of the Zap Logging Library in Go
Programmer DD
Programmer DD
Aug 13, 2018 · Backend Development

Deep Dive into Java’s SynchronousQueue: How It Works and Its Implementation

This article provides a comprehensive analysis of Java's SynchronousQueue, detailing its unique zero-capacity behavior, differences from other BlockingQueue implementations, internal structures such as TransferQueue and TransferStack, fair and non‑fair modes, and the core transfer algorithm with code examples.

BlockingQueueJavaSynchronousQueue
0 likes · 19 min read
Deep Dive into Java’s SynchronousQueue: How It Works and Its Implementation
Architect's Tech Stack
Architect's Tech Stack
Aug 12, 2018 · Backend Development

Understanding and Analyzing the Implementation of Java's Semaphore

This article explains the internal workings of Java's Semaphore, detailing its AQS-based architecture, fair and non‑fair synchronization strategies, core methods such as acquire, release, and their implementations, and provides a practical example demonstrating semaphore usage for thread coordination.

AQSJavaSemaphore
0 likes · 12 min read
Understanding and Analyzing the Implementation of Java's Semaphore
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 11, 2018 · Fundamentals

Explore Java Core Concepts: JVM GC, Concurrency, and Collection Diagrams

This article presents a collection of visual diagrams that map key Java fundamentals, including a JVM garbage‑collection overview, Java concurrency structures, comprehensive collection maps, and detailed class diagrams for List, Map, and Set, offering developers clear reference graphics for understanding core Java APIs.

Class DiagramCollectionsJVM
0 likes · 1 min read
Explore Java Core Concepts: JVM GC, Concurrency, and Collection Diagrams
Programmer DD
Programmer DD
Aug 10, 2018 · Fundamentals

Mastering Java’s DelayQueue: How It Works and When to Use It

This article explains Java's DelayQueue—a blocking queue that releases elements only after their delay expires—covering its primary use cases, core components like ReentrantLock, Condition, and PriorityQueue, the Delayed interface, internal structure, and detailed implementations of the offer() and take() methods, including a discussion of potential memory‑leak pitfalls.

BlockingQueueDelayQueueDelayed Interface
0 likes · 7 min read
Mastering Java’s DelayQueue: How It Works and When to Use It
Architect's Tech Stack
Architect's Tech Stack
Aug 8, 2018 · Backend Development

Deep Dive into Java AQS Shared‑Lock Implementation

This article explains the execution flow, source‑code details, and wake‑up logic of Java's AbstractQueuedSynchronizer shared‑lock mode, covering acquireShared, doAcquireShared, setHeadAndPropagate, doReleaseShared, and releaseShared methods with full code snippets and practical guidance.

AQSJavaSharedLock
0 likes · 11 min read
Deep Dive into Java AQS Shared‑Lock Implementation
Programmer DD
Programmer DD
Aug 8, 2018 · Fundamentals

Unlocking Java’s PriorityBlockingQueue: How Binary Heap Powers Priority Queues

This article explains how Java’s PriorityBlockingQueue implements a priority‑based unbounded blocking queue using a binary heap, covering heap structure, insertion and removal algorithms, underlying ReentrantLock synchronization, and key source code snippets that illustrate the sift‑up, sift‑down, and growth mechanisms.

BinaryHeapDataStructureJava
0 likes · 16 min read
Unlocking Java’s PriorityBlockingQueue: How Binary Heap Powers Priority Queues
Beike Product & Technology
Beike Product & Technology
Aug 3, 2018 · Backend Development

Common Go Language Pitfalls and Best Practices

This article explains frequent pitfalls in Go programming—including file‑naming conventions, defer execution order, panic value handling, for‑range copying, struct composition, init function behavior, pointer operations, command‑line arguments, slice capacity bugs, map usage, and channel communication—while providing clear examples and recommended fixes.

Gobest practicesconcurrency
0 likes · 16 min read
Common Go Language Pitfalls and Best Practices
Beike Product & Technology
Beike Product & Technology
Aug 3, 2018 · Fundamentals

Understanding Java HashMap Optimizations in JDK 1.8

This article explains the fundamental principles of Java's HashMap, covering hash basics, time‑complexity of operations, the role of load factor and initial capacity, the resize algorithm without full rehashing, and the treeification of long buckets, illustrated with JDK 1.8 source code examples.

Data StructuresHashMapJDK8
0 likes · 16 min read
Understanding Java HashMap Optimizations in JDK 1.8
Senior Brother's Insights
Senior Brother's Insights
Jul 23, 2018 · Fundamentals

HashMap vs ConcurrentHashMap: Deep Dive into JDK 1.7 and 1.8 Implementations

This article explains the internal structures of HashMap and ConcurrentHashMap in Java, compares their JDK 1.7 and JDK 1.8 implementations, walks through the put and get algorithms with code examples, highlights performance optimizations such as treeification, and shows why ConcurrentHashMap is needed for thread‑safe access.

ConcurrentHashMapHashMapJava
0 likes · 21 min read
HashMap vs ConcurrentHashMap: Deep Dive into JDK 1.7 and 1.8 Implementations
Programmer DD
Programmer DD
Jul 23, 2018 · Fundamentals

How Does Java’s ArrayBlockingQueue Work Under the Hood?

This article explains the internal design of Java’s ArrayBlockingQueue—a fixed‑size, FIFO blocking queue that uses a ReentrantLock and Condition objects to coordinate producers and consumers, detailing its fields, fairness option, and the concrete implementations of add, offer, poll, and take methods.

ArrayBlockingQueueBlockingQueueJava
0 likes · 10 min read
How Does Java’s ArrayBlockingQueue Work Under the Hood?
Programmer DD
Programmer DD
Jul 10, 2018 · Backend Development

How Guava Cache Works Under the Hood: Expiration, LRU, and Implementation Details

This article explains the design and inner workings of Google Guava's Cache library, covering JVM‑level caching, the advantages over simple maps, a real‑world Kafka alerting scenario, code examples, expiration policies, LRU handling, concurrency mechanisms, and the builder pattern used to configure caches.

GuavaJavaLRU
0 likes · 10 min read
How Guava Cache Works Under the Hood: Expiration, LRU, and Implementation Details
Qunar Tech Salon
Qunar Tech Salon
Jul 4, 2018 · Backend Development

Performance Optimization of Qunar's ATPCO International Ticket Pricing System

This article details how Qunar's ATPCO international fare system was analyzed and optimized through performance profiling, application of Little's Law and Amdahl's Law, code refactoring, cache replacement, pruning of search space, and concurrency improvements such as ForkJoinPool to dramatically reduce response times and CPU pressure.

Amdahl's lawLittle's LawPerformance
0 likes · 12 min read
Performance Optimization of Qunar's ATPCO International Ticket Pricing System
Programmer DD
Programmer DD
Jul 1, 2018 · Backend Development

Mastering Java’s CyclicBarrier: How Threads Synchronize and What Can Go Wrong

This article explains Java’s CyclicBarrier synchronization aid, detailing its purpose, constructors, the await() workflow, internal implementation with ReentrantLock and Condition, generation handling, error scenarios, timeout support, and provides a complete multithreaded example illustrating its practical use.

CyclicBarrierJavaThread Synchronization
0 likes · 10 min read
Mastering Java’s CyclicBarrier: How Threads Synchronize and What Can Go Wrong
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 30, 2018 · Fundamentals

Fundamentals of the Java Memory Model and Concurrency

This article explains the core concepts of the Java Memory Model, including atomicity, visibility, ordering, instruction reordering, sequential consistency, volatile semantics, lock mechanisms, happens‑before rules, and double‑checked locking for lazy initialization.

JavaMemory ModelReordering
0 likes · 11 min read
Fundamentals of the Java Memory Model and Concurrency
Programmer DD
Programmer DD
Jun 28, 2018 · Backend Development

Inside Alibaba’s Multi‑Round Java Interview: Real Questions & Lessons Learned

The author recounts a four‑month journey through three Alibaba departments, detailing each technical and HR interview round, the specific Java‑focused questions asked, the on‑the‑spot coding test, and practical takeaways for candidates preparing for large‑scale backend interview processes.

InterviewJavaTechnicalInterview
0 likes · 15 min read
Inside Alibaba’s Multi‑Round Java Interview: Real Questions & Lessons Learned
JD Tech
JD Tech
Jun 28, 2018 · Backend Development

Asynchronous Programming and Promise Patterns in Backend Systems

This article introduces the concepts of synchronous versus asynchronous calls, explains the challenges of RPC services in large-scale systems, and provides detailed guidance on using polling, callbacks, futures, and CompletableFuture in Java to implement efficient, non‑blocking backend architectures with practical code examples.

Asynchronous ProgrammingFutureJava
0 likes · 18 min read
Asynchronous Programming and Promise Patterns in Backend Systems
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jun 22, 2018 · Backend Development

Master Go Channels: From Basics to Advanced Patterns

This article explains Go's channel primitive in depth, covering its conceptual model, types, operations, internal queues, rule scenarios, practical code examples, and best‑practice tips for building clear and efficient concurrent programs.

GoGo Programmingchannel
0 likes · 12 min read
Master Go Channels: From Basics to Advanced Patterns
Programmer DD
Programmer DD
Jun 21, 2018 · Fundamentals

Master Java Interview Essentials: 8 Classic Questions Explained

This article breaks down eight core Java interview questions, offering deep analysis of platform fundamentals, exception handling, reflection, I/O, concurrency, and object‑oriented design to help candidates demonstrate solid understanding beyond superficial answers.

Core ConceptsIOInterview
0 likes · 12 min read
Master Java Interview Essentials: 8 Classic Questions Explained
Programmer DD
Programmer DD
Jun 16, 2018 · Fundamentals

How Java AQS Uses CLH Queues and LockSupport to Manage Thread Blocking

This article explains the internal mechanisms of Java's AbstractQueuedSynchronizer, detailing how the CLH synchronization queue, the shouldParkAfterFailedAcquire method, and the LockSupport utility work together to decide when a thread should spin, block, or be unblocked, with full code examples and step‑by‑step analysis.

AQSCLHQueueJava
0 likes · 8 min read
How Java AQS Uses CLH Queues and LockSupport to Manage Thread Blocking
MaGe Linux Operations
MaGe Linux Operations
Jun 12, 2018 · Operations

Why Your Workflow Feels Like a Slow Kung Pao Chicken Order (And How to Fix It)

The article uses a humorous Kung Pao chicken ordering analogy to expose common workflow design pitfalls—such as focusing on functions over processes, lacking proper locking, over‑complicating steps, unclear role responsibilities, and rigid naming—while offering practical guidance for building flexible, component‑based operation systems.

Case ManagementWorkflowconcurrency
0 likes · 10 min read
Why Your Workflow Feels Like a Slow Kung Pao Chicken Order (And How to Fix It)
Programmer DD
Programmer DD
Jun 10, 2018 · Backend Development

Unlocking Java Concurrency: How AQS Powers Modern Locks

This article explains the role of Java's AbstractQueuedSynchronizer (AQS) as the core framework for building locks and other synchronizers, detailing its state management, FIFO queue mechanism, and the essential methods developers need to implement custom concurrency utilities.

AQSJavaLock
0 likes · 7 min read
Unlocking Java Concurrency: How AQS Powers Modern Locks
Programmer DD
Programmer DD
Jun 9, 2018 · Fundamentals

Unlocking Java’s Memory Model: Core Concepts and the Happens‑Before Rule

This concise summary explains the Java Memory Model’s definition of thread‑memory interaction, covering atomicity, visibility, ordering, the happens‑before principle, compiler/processor reordering constraints, and sequential consistency, while also listing key reference articles and further reading.

AtomicityJavaMemory Model
0 likes · 7 min read
Unlocking Java’s Memory Model: Core Concepts and the Happens‑Before Rule
Programmer DD
Programmer DD
Jun 6, 2018 · Fundamentals

Why Double‑Checked Locking Fails in Java and How to Fix It

This article explains why the classic Double‑Checked Locking implementation of a lazy singleton is unsafe in Java, analyzes the underlying object‑creation reordering problem, and presents two reliable solutions—using a volatile field or a static holder class—to achieve thread‑safe lazy initialization.

JavaVolatileconcurrency
0 likes · 7 min read
Why Double‑Checked Locking Fails in Java and How to Fix It
MaGe Linux Operations
MaGe Linux Operations
Jun 6, 2018 · Operations

Why Your Workflow Feels Like a Slow Kung Pao Chicken Order—and How to Fix It

Through a humorous restaurant analogy, the article reveals common workflow design flaws such as over‑emphasizing functions over processes, missing locking mechanisms, overly complex steps, unclear role responsibilities, and the necessity for flexible, component‑based workflow systems to handle changing requirements.

Case ManagementWorkflowconcurrency
0 likes · 10 min read
Why Your Workflow Feels Like a Slow Kung Pao Chicken Order—and How to Fix It
Programmer DD
Programmer DD
Jun 4, 2018 · Fundamentals

How Java’s As‑If‑Serial Semantics Keep Single‑Thread Results but Break Multithreaded Guarantees

The article explains why Java and the JVM reorder instructions for performance, the conditions that must be met, how the as‑if‑serial rule protects single‑threaded outcomes, and why the same reordering can violate happens‑before guarantees in multithreaded code, illustrated with concrete examples and code.

JavaMemory Modelas-if-serial
0 likes · 8 min read
How Java’s As‑If‑Serial Semantics Keep Single‑Thread Results but Break Multithreaded Guarantees
Programmer DD
Programmer DD
Jun 2, 2018 · Fundamentals

Unlocking Java’s Happens‑Before: When Do Thread Changes Become Visible?

The article explains the Java Memory Model’s happens‑before principle, detailing its eight core rules, how they ensure visibility and ordering across threads, provides code examples, analyzes a non‑thread‑safe snippet, and shows how to achieve safety using locks or volatile variables.

JavaMemory ModelThread Safety
0 likes · 9 min read
Unlocking Java’s Happens‑Before: When Do Thread Changes Become Visible?
ITPUB
ITPUB
May 31, 2018 · Databases

Mastering Redis: Why It’s Fast, Common Pitfalls, and How to Solve Them

This article provides a comprehensive review of Redis, covering why it’s used, its performance advantages, single‑threaded speed, data types and use cases, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, avalanche, and concurrent key competition.

Data TypesPerformanceRedis
0 likes · 16 min read
Mastering Redis: Why It’s Fast, Common Pitfalls, and How to Solve Them
Qunar Tech Salon
Qunar Tech Salon
May 29, 2018 · Backend Development

Async Mutex: Eliminating Blocking in High‑Performance Concurrent Java Programs

This article analyses the performance challenges of high‑concurrency Java applications, explains how misuse of atomic operations and blocking degrade throughput, introduces an asynchronous monitor concept and a concrete AsyncMutex implementation, and presents experimental results showing its scalability advantages over traditional ReentrantLock‑based locking.

JavaLock-FreePerformance
0 likes · 15 min read
Async Mutex: Eliminating Blocking in High‑Performance Concurrent Java Programs
Didi Tech
Didi Tech
May 18, 2018 · Backend Development

Understanding the Thundering Herd Problem in Linux and Nginx

The article explains the thundering herd problem where many processes wake for a single event, describes Linux’s kernel fixes for accept() and partial epoll solutions, and details how Nginx avoids the issue using a custom inter‑process accept mutex and lock design.

Linux kernelconcurrencyepoll
0 likes · 14 min read
Understanding the Thundering Herd Problem in Linux and Nginx
Architecture Digest
Architecture Digest
May 17, 2018 · Backend Development

Implementing a Distributed Lock with Redis in Java

This article explains the principles of distributed locks, discusses why they are needed in distributed applications, and provides a complete Java implementation using Redis’s NX and EX parameters, including lock acquisition, blocking and non‑blocking modes, unlocking with Lua scripts, configuration, usage examples, and testing strategies.

JavaRedisconcurrency
0 likes · 12 min read
Implementing a Distributed Lock with Redis in Java
Qunar Tech Salon
Qunar Tech Salon
May 16, 2018 · Backend Development

Performance Analysis and Optimization of Synchronized Reflection Calls in a Java Backend Service

The article investigates a high‑traffic Java backend issue caused by synchronized reflection calls, analyzes thread‑blocking stack traces, demonstrates the problematic code, and presents a compile‑time PropertyDescriptor optimization that eliminates runtime locking, resulting in significant latency improvements and a deeper understanding of JVM lock mechanisms.

JVMPerformanceconcurrency
0 likes · 14 min read
Performance Analysis and Optimization of Synchronized Reflection Calls in a Java Backend Service
JD Tech
JD Tech
May 10, 2018 · Backend Development

Asynchronous Programming and Promise Patterns in Backend Services

This article introduces the concepts of synchronous vs asynchronous calls, explains RPC and I/O models, and demonstrates how to use callback, Future/Promise, and ReactiveX styles with Java's CompletableFuture and Guava's ListenableFuture to improve performance and scalability of backend services.

AsynchronousFutureJava
0 likes · 17 min read
Asynchronous Programming and Promise Patterns in Backend Services
21CTO
21CTO
May 9, 2018 · Backend Development

Why Use Locks? Deep Dive into Java Synchronization, Volatile, and AQS

This article explains why locks are needed in concurrent programming, explores the fundamentals of volatile and synchronized, details monitor mechanisms, lock optimizations like biased and lightweight locks, compares CAS and AQS, and illustrates Java lock implementations with diagrams and code examples.

AQSCASJava
0 likes · 11 min read
Why Use Locks? Deep Dive into Java Synchronization, Volatile, and AQS
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 27, 2018 · Fundamentals

Mastering Java Core Concepts: ThreadLocal, JVM Memory, GC, Concurrency, and More

This article provides a comprehensive overview of essential Java fundamentals, covering ThreadLocal, the JVM memory model, garbage collection mechanisms, synchronization primitives like synchronized and ReentrantLock, volatile semantics, concurrency utilities, thread pools, class loading, and common data structures such as HashMap and ConcurrentHashMap.

JVMMemory ManagementThreadPool
0 likes · 31 min read
Mastering Java Core Concepts: ThreadLocal, JVM Memory, GC, Concurrency, and More
Java Backend Technology
Java Backend Technology
Apr 25, 2018 · Backend Development

Master Java Interview Prep: 100+ Essential Backend Questions & Answers

This article compiles a comprehensive set of Java interview topics—including core language concepts, concurrency, JVM tuning, database optimization, data structures, operating‑system fundamentals, networking, frameworks, distributed systems, and design challenges—to help developers deepen their understanding and excel in technical interviews.

DatabaseJavaconcurrency
0 likes · 11 min read
Master Java Interview Prep: 100+ Essential Backend Questions & Answers
Programmer DD
Programmer DD
Apr 22, 2018 · Backend Development

Unveiling Spring Session’s Redis Data Structures: From A to C Keys Explained

This article dissects Spring Session’s Redis implementation, explaining the three key types (A, B, C), their TTL settings, how they enable session sharing, the pitfalls of Redis expiration, concurrency challenges, and the sophisticated cleanup and notification mechanisms Spring Session employs to ensure reliable session management.

JavaSession managementSpring Session
0 likes · 15 min read
Unveiling Spring Session’s Redis Data Structures: From A to C Keys Explained
MaGe Linux Operations
MaGe Linux Operations
Apr 15, 2018 · Fundamentals

Master Python Threading: From Basics to Advanced Synchronization

This article explains Python threading fundamentals, including thread context, kernel vs. user threads, the low‑level _thread module and the high‑level threading module, functional and class‑based thread creation, synchronization with locks, and using Queue for thread‑safe communication, all illustrated with complete code examples.

PythonQueueconcurrency
0 likes · 13 min read
Master Python Threading: From Basics to Advanced Synchronization
JD Tech
JD Tech
Apr 12, 2018 · Backend Development

Designing a High‑Availability Inventory System: Stock Pre‑allocation, Duplicate Order Prevention, Rollback Mechanisms, and Concurrency Control

The article explains how JD Daojia's inventory system achieves stability and high availability for millions of items by using health‑monitoring platforms, choosing an order‑submission stock reservation strategy, preventing duplicate submissions with token and idempotent mechanisms, implementing rollback procedures, and applying various concurrency‑safe stock‑deduction techniques with code examples.

Inventorybackendconcurrency
0 likes · 12 min read
Designing a High‑Availability Inventory System: Stock Pre‑allocation, Duplicate Order Prevention, Rollback Mechanisms, and Concurrency Control
Java Backend Technology
Java Backend Technology
Apr 11, 2018 · Backend Development

Unlock Java Interview Success: Core JVM, Concurrency, DB & Linux Questions

This guide compiles over a hundred essential interview questions covering Java fundamentals, JVM tuning, thread pools, memory management, databases, Linux system internals, networking basics, and popular frameworks like Spring and Dubbo, helping candidates prepare comprehensively for backend development roles.

DatabaseJavaconcurrency
0 likes · 9 min read
Unlock Java Interview Success: Core JVM, Concurrency, DB & Linux Questions
Architecture Digest
Architecture Digest
Apr 11, 2018 · Backend Development

Golang High‑Performance Practice: Architecture and Optimization Techniques

This article presents a comprehensive technical sharing on Golang high‑performance engineering, covering architecture design, profiling tools, concurrency optimizations, distributed rate limiting, timer mechanisms, GC tuning, and deployment strategies, supplemented with PPT links and extensive code excerpts for practical reference.

Performance Tuningconcurrencygolang
0 likes · 12 min read
Golang High‑Performance Practice: Architecture and Optimization Techniques
Java Captain
Java Captain
Apr 1, 2018 · Fundamentals

A Simple Explanation of Multithreading and Its Use Cases

Multithreading allows concurrent processing by dividing tasks among multiple threads, improving throughput and scalability when used appropriately, as illustrated through examples such as web servers, file processing, database operations, background jobs, and UI responsiveness, while highlighting the importance of choosing the right number of threads.

Performanceconcurrency
0 likes · 6 min read
A Simple Explanation of Multithreading and Its Use Cases
Architect's Tech Stack
Architect's Tech Stack
Mar 21, 2018 · Fundamentals

Comprehensive Java Interview Questions and Topics Guide

This article compiles over 300 essential Java interview questions covering fundamentals, multithreading, design patterns, JVM internals, data structures, algorithms, databases, Spring, Netty, caching, distributed systems, Linux, and networking to help developers prepare for technical interviews and deepen their understanding of core backend concepts.

Design PatternsInterviewJVM
0 likes · 16 min read
Comprehensive Java Interview Questions and Topics Guide
Java Architect Essentials
Java Architect Essentials
Mar 19, 2018 · Backend Development

40 Common Java Multithreading Interview Questions and Answers

This article compiles and answers 40 frequently asked Java multithreading interview questions, covering thread purpose, creation methods, key APIs, synchronization mechanisms, thread safety levels, performance considerations, and practical debugging techniques for developers seeking a solid understanding of concurrent programming.

InterviewThreadPoolconcurrency
0 likes · 29 min read
40 Common Java Multithreading Interview Questions and Answers
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 19, 2018 · Fundamentals

Master Java Interview Essentials: JVM, Collections, Concurrency, and System Fundamentals

This article provides concise explanations of core Java and system concepts—including JVM class loading, HashMap implementation, concurrency utilities, IPC mechanisms, garbage collection, sorting algorithms, networking protocols, Linux scheduling, deadlock conditions, hashing techniques, and database normalization—useful for technical interviews and foundational study.

Data StructuresHashMapJVM
0 likes · 25 min read
Master Java Interview Essentials: JVM, Collections, Concurrency, and System Fundamentals
Java Backend Technology
Java Backend Technology
Mar 17, 2018 · Backend Development

Mastering Java Memory Model: Unlocking Thread Visibility and Concurrency

This article explains Java's concurrency fundamentals, covering shared memory vs. message‑passing models, the abstract structure of the Java Memory Model, instruction reordering, write‑buffer effects, memory barriers, and the happens‑before rules that guarantee correct thread communication.

JavaMemory Modelconcurrency
0 likes · 9 min read
Mastering Java Memory Model: Unlocking Thread Visibility and Concurrency