BestHub
Sign in
Tagged articles

Concurrency

2155 articles · Page 21 of 22
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.

ConcurrencyJVMPerformance
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.

ConcurrencyFutureJava
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.

AQSCASConcurrency
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.

ConcurrencyJVMMemory management
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.

ConcurrencyDatabaseJava
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.

ConcurrencyExpirationJava
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.

ConcurrencyMultithreadingPython
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.

ConcurrencyInventorybackend
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.

ConcurrencyDatabaseJava
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.

ConcurrencyGolangPerformance Tuning
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.

ConcurrencyPerformance
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.

ConcurrencyDesign PatternsFundamentals
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.

ConcurrencyMultithreadingSynchronization
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.

ConcurrencyData StructuresHashMap
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.

ConcurrencyJavaMemory Model
0 likes · 9 min read
Mastering Java Memory Model: Unlocking Thread Visibility and Concurrency
Java Backend Technology
Java Backend Technology
Mar 3, 2018 · Backend Development

Essential Java Interview Questions Every Backend Developer Should Master

A comprehensive collection of Java interview questions covering fundamentals, common collections, concurrency, JVM internals, design patterns, data structures, networking, databases, caching, messaging, frameworks, distributed systems, and micro‑service architecture to help developers prepare for junior to mid‑level positions.

ConcurrencyDatabasesDesign Patterns
0 likes · 19 min read
Essential Java Interview Questions Every Backend Developer Should Master
21CTO
21CTO
Jan 23, 2018 · Databases

Why Simple MySQL Queries Stall: Unraveling Table Locks, Deadlocks, and Metadata Locks

This article examines common MySQL concurrency problems—including table locks from MyISAM, metadata locks during online DDL, row‑level deadlocks, and lock‑wait timeouts—explains how to detect them with processlist and InnoDB status, and provides practical mitigation strategies.

ConcurrencyDatabaseDeadlock
0 likes · 16 min read
Why Simple MySQL Queries Stall: Unraveling Table Locks, Deadlocks, and Metadata Locks
Architecture Digest
Architecture Digest
Jan 21, 2018 · Databases

Common MySQL Concurrency Issues: Table Locks, Metadata Locks, Deadlocks, and Lock Waits

This article examines typical MySQL concurrency problems—including table lock‑induced slow queries, metadata lock blocking during online schema changes, deadlock scenarios, and lock‑wait timeouts—provides step‑by‑step reproductions, analysis of lock behavior, and practical mitigation strategies such as using InnoDB, online DDL tools, and monitoring techniques.

ConcurrencyDeadlockInnoDB
0 likes · 15 min read
Common MySQL Concurrency Issues: Table Locks, Metadata Locks, Deadlocks, and Lock Waits
Java Backend Technology
Java Backend Technology
Jan 14, 2018 · Backend Development

Mastering Distributed Locks in Java: From Databases to Redis and Zookeeper

This article explains why distributed locks are needed in Java applications, outlines the essential conditions they must satisfy, and compares three practical implementations—database‑based, Redis‑based, and Zookeeper‑based—providing code snippets and performance considerations for each.

ConcurrencyDatabaseDistributed Lock
0 likes · 12 min read
Mastering Distributed Locks in Java: From Databases to Redis and Zookeeper
Java Captain
Java Captain
Jan 11, 2018 · Fundamentals

Understanding Java's synchronized(this) Object Lock and Thread Interaction

This article explains how Java's synchronized(this) keyword creates an object lock that allows only one thread to execute a synchronized block at a time, demonstrates various scenarios with code examples, and shows how non‑synchronized sections remain concurrent while all synchronized sections on the same object are blocked.

ConcurrencyMultithreadingSynchronization
0 likes · 9 min read
Understanding Java's synchronized(this) Object Lock and Thread Interaction
Qunar Tech Salon
Qunar Tech Salon
Dec 27, 2017 · Backend Development

Understanding the Implementation and Optimization of Java synchronized

This article explains how Java's synchronized keyword works internally, covering its implementation via monitorenter/monitorexit, the role of object headers and monitors, and the various lock optimizations introduced in JDK 1.6 such as spin locks, biased locks, lightweight locks, lock elimination, and lock coarsening.

ConcurrencyJavaLocking
0 likes · 17 min read
Understanding the Implementation and Optimization of Java synchronized
Tencent Database Technology
Tencent Database Technology
Dec 7, 2017 · Databases

Implementation and Optimizations of Percona 5.7 Thread Pool

This article explains how Percona Server 5.7 implements a thread‑pool model for MySQL, detailing the activation parameters, internal architecture, functional threads, timer mechanisms, and several performance optimizations such as priority scheduling and special handling for long‑running commands.

ConcurrencyDatabase PerformanceMySQL
0 likes · 13 min read
Implementation and Optimizations of Percona 5.7 Thread Pool
MaGe Linux Operations
MaGe Linux Operations
Dec 6, 2017 · Fundamentals

Master Python Multiprocessing and Coroutines: From Queues to Async Efficiency

This article explains Python's inter-process communication methods, including process creation, queues, pipes, locks, and pools, and introduces coroutines as lightweight alternatives, detailing their creation with gevent, practical web crawling, and socket server implementations, highlighting performance benefits and appropriate use cases.

ConcurrencyMultiprocessingPython
0 likes · 6 min read
Master Python Multiprocessing and Coroutines: From Queues to Async Efficiency
JD Retail Technology
JD Retail Technology
Nov 29, 2017 · Operations

iOS Thread Synchronization Mechanisms and Lock Implementations

This article explains various iOS thread synchronization tools—including NSLock, NSRecursiveLock, NSConditionLock, NSCondition, @synchronized, dispatch_semaphore, pthread_mutex, and the deprecated OSSpinLock—detailing their internal implementations, usage patterns, code examples, and performance considerations for developers seeking safe concurrent programming on Apple platforms.

ConcurrencyLocksNSLock
0 likes · 22 min read
iOS Thread Synchronization Mechanisms and Lock Implementations
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Nov 29, 2017 · Databases

Case Study: Resolving a One‑Cent Discrepancy Caused by Distributed‑Lock Timeout and Concurrency Issues in Alibaba’s Financial System

This article analyzes a real Alibaba internal financial‑system incident where a one‑cent accounting error arose from concurrent database writes after a distributed‑lock timeout, details the root‑cause investigation, and presents two remediation strategies—adjusting timeout settings and strengthening idempotent controls—to prevent similar issues.

AlibabaConcurrencyDistributed Lock
0 likes · 7 min read
Case Study: Resolving a One‑Cent Discrepancy Caused by Distributed‑Lock Timeout and Concurrency Issues in Alibaba’s Financial System
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 27, 2017 · Backend Development

How a 0.01‑Yuan Mistake Exposed Distributed Lock Flaws in Alibaba’s Backend

A tiny 0.01‑yuan discrepancy in an Alibaba product revealed duplicate settlement records, exposing a distributed‑lock timeout and concurrency issue that led to double commits, and the article walks through the root‑cause analysis, reverse engineering of the process, and two remediation strategies focusing on timeout adjustments and idempotency controls.

AlibabaConcurrencyDistributed Lock
0 likes · 8 min read
How a 0.01‑Yuan Mistake Exposed Distributed Lock Flaws in Alibaba’s Backend
21CTO
21CTO
Nov 17, 2017 · Fundamentals

Master Java Concurrency: Threads, Thread Pools, and Synchronization

This article provides a comprehensive overview of Java concurrency, covering thread creation methods, thread pools, thread models, the Future and Fork/Join frameworks, volatile and CAS mechanisms, AQS, synchronized locks, and various concurrent queue implementations, with practical code examples and references for deeper study.

ConcurrencyJavaSynchronization
0 likes · 38 min read
Master Java Concurrency: Threads, Thread Pools, and Synchronization
Architecture Digest
Architecture Digest
Nov 17, 2017 · Backend Development

A Comprehensive Overview of Java Concurrency Programming

This article provides a high‑level summary of Java concurrency, covering thread creation methods, thread models, thread pools, Future and CompletableFuture, the Fork/Join framework, volatile, CAS, AQS, synchronized locks, and concurrent queue implementations, with code examples and reference links for deeper study.

AQSCASConcurrency
0 likes · 39 min read
A Comprehensive Overview of Java Concurrency Programming
Java Backend Technology
Java Backend Technology
Nov 6, 2017 · Backend Development

Mastering Java’s Future Pattern: From CountDownLatch to Callable

This article explains Java’s asynchronous call mechanisms, reviews thread counters like CountDownLatch, introduces the Future pattern with its core roles and structure, provides a step‑by‑step code implementation, and shows how the JDK implements Future using Callable and FutureTask.

Backend DevelopmentCallableConcurrency
0 likes · 8 min read
Mastering Java’s Future Pattern: From CountDownLatch to Callable
Architecture Digest
Architecture Digest
Nov 6, 2017 · Backend Development

Understanding Concurrency, Synchronization, and Locking Mechanisms in Java and Hibernate

This article explains the concepts of synchronous and asynchronous execution, common concurrency problems such as dirty reads and non‑repeatable reads, and presents practical solutions using Java synchronized blocks, database pessimistic and optimistic locks, Hibernate lock modes, and performance‑optimizing techniques for high‑traffic web applications.

ConcurrencyDatabaseHibernate
0 likes · 25 min read
Understanding Concurrency, Synchronization, and Locking Mechanisms in Java and Hibernate
Java Backend Technology
Java Backend Technology
Oct 31, 2017 · Backend Development

Unlock High-Performance Java with Lock-Free Concurrency and Atomic Classes

This article explains how lock-free techniques such as Compare-And-Swap (CAS) and Java's atomic classes—including AtomicBoolean, AtomicInteger, AtomicReference, and their array and field updaters—provide optimistic concurrency control, reduce context switches, and improve performance compared to traditional locking mechanisms.

CASConcurrencyJava
0 likes · 11 min read
Unlock High-Performance Java with Lock-Free Concurrency and Atomic Classes
21CTO
21CTO
Oct 24, 2017 · Backend Development

Mastering Java Concurrency: Key Concepts, Thread Lifecycle, and JMM Explained

This article explains essential Java concurrency concepts—including synchronous vs. asynchronous execution, concurrency vs. parallelism, critical sections, blocking and non‑blocking operations—covers thread states, creation methods, priorities, common thread APIs, and the Java Memory Model’s guarantees on atomicity, visibility, and ordering.

ConcurrencyJMMJava
0 likes · 22 min read
Mastering Java Concurrency: Key Concepts, Thread Lifecycle, and JMM Explained
Java Backend Technology
Java Backend Technology
Oct 24, 2017 · Fundamentals

ThreadLocal OOM? Exploring Singleton Pitfalls in Java Multithreading

This article examines common Java singleton implementations—including eager, thread‑safe lazy, double‑checked locking, and static inner‑class approaches—explaining their requirements, potential memory‑leak pitfalls such as ThreadLocal‑induced OOM, and how improper usage in multithreaded environments can lead to unexpected instance creation and performance issues.

ConcurrencyDesign PatternsJava
0 likes · 6 min read
ThreadLocal OOM? Exploring Singleton Pitfalls in Java Multithreading
Architecture Digest
Architecture Digest
Oct 24, 2017 · Backend Development

Understanding Java Thread Concurrency: Concepts, Lifecycle, and the Java Memory Model

This article explains key Java concurrency concepts—including synchronization, parallelism, critical sections, blocking vs non‑blocking, thread lifecycle, priority, common thread methods, interrupt handling, and the Java Memory Model’s guarantees of atomicity, visibility, ordering, and happens‑before relations—providing practical examples and code snippets for backend developers.

ConcurrencyJMMJava
0 likes · 24 min read
Understanding Java Thread Concurrency: Concepts, Lifecycle, and the Java Memory Model
Java Backend Technology
Java Backend Technology
Oct 12, 2017 · Backend Development

Mastering Java’s ReentrantReadWriteLock: When to Use Read/Write Locks

This article explains Java’s ReentrantReadWriteLock, detailing its shared read lock and exclusive write lock behavior, comparing it to ReentrantLock and concurrent collections, and provides clear code examples demonstrating read‑read sharing, write‑write exclusion, and read‑write mutual exclusion.

ConcurrencyJavaLock
0 likes · 3 min read
Mastering Java’s ReentrantReadWriteLock: When to Use Read/Write Locks
Java Backend Technology
Java Backend Technology
Oct 10, 2017 · Fundamentals

Mastering Java Thread Communication: Wait/Notify Explained with Real Code

This article introduces Java's wait/notify thread communication mechanism, explains its principles with analogies, details the behavior of wait and notify methods, provides step‑by‑step code examples—including a simple producer‑consumer queue—and highlights important considerations such as lock handling and thread states.

ConcurrencyJavaThread Communication
0 likes · 9 min read
Mastering Java Thread Communication: Wait/Notify Explained with Real Code
Java Backend Technology
Java Backend Technology
Sep 27, 2017 · Fundamentals

Unlocking ThreadLocal: How Java Gives Each Thread Its Own Variable

This article explains the purpose of Java's ThreadLocal class, shows a practical example with code and output images, compares it to synchronized locking, and demonstrates how ThreadLocal provides each thread with an independent variable copy for safe concurrent access.

ConcurrencyJavaProgramming Fundamentals
0 likes · 3 min read
Unlocking ThreadLocal: How Java Gives Each Thread Its Own Variable
Java Backend Technology
Java Backend Technology
Sep 16, 2017 · Backend Development

Mastering Java’s Synchronized Reentrant Lock: Features, Pitfalls, and Best Practices

This article explains Java’s synchronized keyword’s reentrant lock capability, demonstrates how nested synchronized methods acquire the same lock without deadlock, explores additional features such as automatic lock release on exceptions, using arbitrary objects as monitors, and illustrates the double‑checked locking pattern for singleton implementation.

ConcurrencyJavaReentrantLock
0 likes · 5 min read
Mastering Java’s Synchronized Reentrant Lock: Features, Pitfalls, and Best Practices
Meituan Technology Team
Meituan Technology Team
Sep 14, 2017 · Backend Development

Java Concurrency Q&A: Akka, Locks, ThreadPoolExecutor, and More

The article answers twelve Java concurrency questions, covering Meituan’s simple Akka use, when to prefer ReentrantLock or synchronized, queue rejection policies, Java 8 ConcurrentHashMap internals, ThreadPoolExecutor workflow, read‑write locks and Conditions, interview preparation, beginner resources, volatile ordering nuances, and notes on unclear flash‑sale overselling safeguards.

AkkaConcurrencyJava
0 likes · 10 min read
Java Concurrency Q&A: Akka, Locks, ThreadPoolExecutor, and More
Meituan Technology Team
Meituan Technology Team
Aug 25, 2017 · Backend Development

Java and JVM Q&A: Performance, Tools, and Best Practices

This article compiles a Java club’s Q&A covering backend development essentials—from network bandwidth checks and static‑method hooking to JNI choices, OSGi modularity, plugin performance, CPU‑heavy thread analysis, ConcurrentHashMap improvements, micro‑service frameworks, cross‑data-center protocols, JVM GC mechanisms, inheritance alternatives, ThreadLocal pitfalls, career advice, cloning, generics erasure, JVM tuning, multithreading strategies, lock upgrades, monitoring tools, database failure handling, Spring Data JPA design, and distributed transaction practices.

ConcurrencyJVMJava
0 likes · 16 min read
Java and JVM Q&A: Performance, Tools, and Best Practices
Java Captain
Java Captain
Aug 22, 2017 · Fundamentals

Comparison of synchronized and Lock in Java: Limitations, Advantages, and Usage

This article explains the limitations of Java's synchronized keyword, introduces the Lock framework from java.util.concurrent.locks, compares their features, and demonstrates practical usage through multiple code examples covering ReentrantLock, tryLock, lockInterruptibly, ReadWriteLock, and fairness concepts.

ConcurrencyLockMultithreading
0 likes · 25 min read
Comparison of synchronized and Lock in Java: Limitations, Advantages, and Usage
21CTO
21CTO
Aug 10, 2017 · Backend Development

How to Build a High‑Concurrency Flash‑Sale (SecKill) System in Java

This article explains how to design and implement a Java‑based flash‑sale (seckill) system that can handle tens of thousands of concurrent requests, covering entity modeling, DAO methods, service logic, controller handling, a concurrency simulation test, and an improved locking strategy to prevent overselling.

ConcurrencyDatabaseJava
0 likes · 9 min read
How to Build a High‑Concurrency Flash‑Sale (SecKill) System in Java
Baidu Waimai Technology Team
Baidu Waimai Technology Team
Jul 11, 2017 · Backend Development

Handling Hotspot Accounts in Baidu Waimai Financial Accounting System: Challenges and Solutions

The article examines the upgrade to a balance‑based financial accounting system, defines hotspot accounts, explains why they pose concurrency challenges, and evaluates several technical solutions—including optimistic locking, asynchronous processing, and account splitting—to guide appropriate strategy selection for different business scenarios.

Concurrencyaccount splittingasynchronous processing
0 likes · 9 min read
Handling Hotspot Accounts in Baidu Waimai Financial Accounting System: Challenges and Solutions
Qunar Tech Salon
Qunar Tech Salon
May 11, 2017 · Operations

Designing Performance Test Scenarios: Models, Metrics, and Strategies

This article explains how to design performance testing scenarios, covering test models, metrics, script preparation, concurrency calculations, pressure strategies, run times, delay settings, user termination, monitoring methods, and various typical scenario types such as baseline, load, mixed, capacity, large‑concurrency, stability and scalability tests.

ConcurrencyMonitoringTPS
0 likes · 24 min read
Designing Performance Test Scenarios: Models, Metrics, and Strategies
Architecture Digest
Architecture Digest
May 7, 2017 · Backend Development

Design and Implementation of a Java-Based Flash Sale (Seckill) System

This article explains the architecture and Java code for a high‑concurrency flash‑sale system, covering request distribution, pre‑processing, queue selection, transaction handling, and database interaction to efficiently manage limited‑stock purchases under massive traffic.

ConcurrencyFlash SaleJava
0 likes · 7 min read
Design and Implementation of a Java-Based Flash Sale (Seckill) System
21CTO
21CTO
May 2, 2017 · Backend Development

How Toutiao Scaled to Millions of QPS with Go‑Powered Microservices

This article chronicles Toutiao’s evolution from a monolithic Python/C++/PHP stack to a large‑scale Go‑based microservice architecture, detailing the reasons for adopting Go, the design of the kite framework, concurrency models, timeout control, performance tuning, monitoring, and a reusable DAO component for efficient RPC aggregation.

ConcurrencyPerformancebackend
0 likes · 27 min read
How Toutiao Scaled to Millions of QPS with Go‑Powered Microservices
ITPUB
ITPUB
May 2, 2017 · Databases

Understanding Oracle Lock Mechanisms: DML, DDL, and Row‑Level Locks Explained

This article explains how Oracle uses various lock types—including DML, DDL, and internal locks—to protect shared resources, details the lock manager workflow, describes the three lock components and lock modes, and shows practical SQL examples of transaction handling and blocking detection.

ConcurrencyDatabaseLocks
0 likes · 13 min read
Understanding Oracle Lock Mechanisms: DML, DDL, and Row‑Level Locks Explained
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 9, 2017 · Backend Development

Mastering Distributed Locks and Idempotency for High‑Concurrency Systems

This article explores the challenges of mutual exclusion and idempotency in distributed environments, explains the underlying principles of locks in multi‑threaded and multi‑process contexts, and presents practical implementations using Zookeeper, Redis, Tair, and the Cerberus and GTIS frameworks to ensure reliable, scalable operations.

ConcurrencyDistributed LockRedis
0 likes · 35 min read
Mastering Distributed Locks and Idempotency for High‑Concurrency Systems
ZhiKe AI
ZhiKe AI
Feb 23, 2017 · Fundamentals

Why volatile Is Not Thread‑Safe: A Java Increment Test

The article presents a Java program where 100 threads each increment a volatile int 1,000 times, showing that the final value may be less than the expected 100,000, and explains that volatile only guarantees visibility, not atomicity, making it unsuitable for concurrent modifications.

AtomicityConcurrencyJava
0 likes · 2 min read
Why volatile Is Not Thread‑Safe: A Java Increment Test
ZhiKe AI
ZhiKe AI
Feb 22, 2017 · Fundamentals

Understanding Java’s java.util.concurrent Package and Thread Pools

This article introduces the java.util.concurrent package introduced since JDK 5, explains the five thread‑pool creation methods, demonstrates how to use Runnable and Callable, details BlockingQueue operations and implementations, and summarizes best practices for building robust, high‑concurrency Java applications.

BlockingQueueConcurrencyJava
0 likes · 10 min read
Understanding Java’s java.util.concurrent Package and Thread Pools
Qunar Tech Salon
Qunar Tech Salon
Jan 21, 2017 · Backend Development

Message Consumption Patterns and Best Practices in Qunar's QMQ

This article shares Qunar's practical experiences with message-driven architecture, detailing consumer handling of duplicate messages, ordering, concurrency control, asynchronous processing, and batch strategies, and presents concrete solutions such as idempotent checks, deduplication tables, versioning, and QMQ's built‑in executors.

ConcurrencyOrderingasynchronous ack
0 likes · 18 min read
Message Consumption Patterns and Best Practices in Qunar's QMQ
Qunar Tech Salon
Qunar Tech Salon
Dec 19, 2016 · Backend Development

Asynchronous Refactoring of an HTTP Service Using a Graph‑Based Execution Engine

This article describes how a Java‑based HTTP service was transformed from a synchronous, thread‑blocking design to a fully asynchronous architecture by evaluating coroutine, Actor model, and Rx approaches, and ultimately implementing a Graph‑Based Execution Engine integrated with Servlet 3.0 and Spring MVC to improve stability, performance, and throughput.

ConcurrencyServletasynchronous
0 likes · 12 min read
Asynchronous Refactoring of an HTTP Service Using a Graph‑Based Execution Engine
Architects Research Society
Architects Research Society
Nov 23, 2016 · Databases

ScyllaDB Architecture and Performance Optimizations: Design Insights

ScyllaDB, a Cassandra‑compatible NoSQL database, achieves over tenfold performance improvements through a thread‑per‑core design, asynchronous I/O, custom caching, self‑tuning schedulers, a user‑space TCP/IP stack, and LLVM‑JIT query execution, making it a compelling study for high‑performance database engineering.

Cache DesignConcurrencyDatabase Performance
0 likes · 5 min read
ScyllaDB Architecture and Performance Optimizations: Design Insights
Ctrip Technology
Ctrip Technology
Nov 22, 2016 · Backend Development

Understanding Java Object.wait() and notify() Implementation in the HotSpot JVM

This article explains the internal workings of Java's Object.wait() and notify() methods, detailing how synchronized blocks, monitorenter/monitorexit instructions, the HotSpot ObjectMonitor, wait sets, and entry lists cooperate to manage thread coordination and lock ownership in multithreaded environments.

ConcurrencyHotSpotJVM
0 likes · 10 min read
Understanding Java Object.wait() and notify() Implementation in the HotSpot JVM
Meituan Technology Team
Meituan Technology Team
Nov 18, 2016 · Backend Development

Understanding the Disruptor: High‑Performance Java Queue and Its Implementation

The Disruptor library provides a lock‑free, CAS‑driven ring‑buffer queue that eliminates lock contention and false sharing, delivering 4–7× higher throughput and nanosecond‑level latency compared to Java’s built‑in queues, and is employed by systems such as Log4j 2, Apache Storm, and Meituan‑Dianping.

ConcurrencyDisruptorJava
0 likes · 21 min read
Understanding the Disruptor: High‑Performance Java Queue and Its Implementation
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 16, 2016 · Operations

Calculate System Throughput: QPS, TPS, Concurrency & Response Time

This article explains key performance testing concepts such as system throughput, QPS/TPS, concurrency, response time, and their interrelationships, provides practical calculation examples, shows how daily PV relates to TPS for different platforms, and outlines essential metrics and formulas for evaluating software performance.

ConcurrencyQPSResponse Time
0 likes · 11 min read
Calculate System Throughput: QPS, TPS, Concurrency & Response Time
dbaplus Community
dbaplus Community
Nov 10, 2016 · Backend Development

Why Distributed Systems Are Essential for Scaling Modern Web Services

The article explains why distributed systems are fundamental for handling massive web traffic, detailing concepts such as high throughput, concurrency, low latency, load balancing, layered architectures, concurrency models, caching, NoSQL storage, fault tolerance, scaling, deployment, and monitoring, while highlighting practical techniques and challenges.

ConcurrencyNoSQLdistributed systems
0 likes · 23 min read
Why Distributed Systems Are Essential for Scaling Modern Web Services
ITPUB
ITPUB
Oct 17, 2016 · Databases

Why Some MySQL Inserts Are Blocked: Decoding Next‑Key Lock Ranges

This article examines MySQL InnoDB's next‑key lock behavior by creating a test table, running concurrent transactions, and analyzing how the lock range is determined across primary and secondary index columns, revealing why certain insert statements are blocked while others succeed.

ConcurrencyGAP LockInnoDB
0 likes · 9 min read
Why Some MySQL Inserts Are Blocked: Decoding Next‑Key Lock Ranges
ITPUB
ITPUB
Oct 11, 2016 · Databases

How a Simple MySQL UPDATE Solved a Multi‑Threaded Counting Problem

A developer recounts how a seemingly trivial MySQL UPDATE statement—‘UPDATE table_name SET sum = sum + 5 WHERE id = 1’—proved thread‑safe for aggregating file counts across a multi‑threaded module, highlighting the importance of knowledge reserves and cautious evaluation before implementing complex synchronization solutions.

ConcurrencyDatabaseMySQL
0 likes · 5 min read
How a Simple MySQL UPDATE Solved a Multi‑Threaded Counting Problem
ITPUB
ITPUB
Sep 5, 2016 · Backend Development

Why a Barrier‑Based Config Swap Still Crashed: Uncovering a Shallow Copy Bug

A seemingly safe configuration swap using barriers caused a crash because a shallow copy duplicated resource pointers, leading to premature freeing of the active configuration; the article explains the bug, shows the faulty code, and presents a corrected approach.

BarrierBug FixC Programming
0 likes · 5 min read
Why a Barrier‑Based Config Swap Still Crashed: Uncovering a Shallow Copy Bug
ITPUB
ITPUB
Aug 31, 2016 · Databases

Lock‑Free Transactions and Cache Switching: MVCC Techniques for Key‑Value Stores

This article explains how traditional ACID transactions fall short for modern large‑scale systems and presents lock‑free transaction methods, atomic and partial cache‑switch techniques, and a PostgreSQL‑style MVCC model for key‑value databases, including practical rules and trade‑offs.

CacheConcurrencyDatabase
0 likes · 10 min read
Lock‑Free Transactions and Cache Switching: MVCC Techniques for Key‑Value Stores
Qunar Tech Salon
Qunar Tech Salon
Aug 3, 2016 · Backend Development

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

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

CacheConcurrencySharding
0 likes · 8 min read
Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies
Architecture Digest
Architecture Digest
Jul 11, 2016 · Backend Development

Implementing a High‑Performance RPC Server with Netty in Java

This article explains the principles of RPC, evaluates performance‑critical factors such as I/O models and transport protocols, and provides a step‑by‑step guide to building a high‑throughput, Netty‑based RPC server in Java, including design, code structure, testing, and possible enhancements.

ConcurrencyJavaNetty
0 likes · 14 min read
Implementing a High‑Performance RPC Server with Netty in Java