BestHub
Sign in
Tagged articles

Concurrency

2155 articles · Page 5 of 22
Deepin Linux
Deepin Linux
Mar 21, 2025 · Fundamentals

Understanding Memory Pools: Concepts, Implementations, and Practical Use Cases

This article explains the concept of memory pools, how they reduce allocation overhead and fragmentation compared to traditional malloc/new, describes various pool designs and Linux kernel APIs, provides multiple C and C++ implementations, and discusses performance benefits and typical application scenarios such as servers, real‑time and embedded systems.

C++ConcurrencyLinux kernel
0 likes · 40 min read
Understanding Memory Pools: Concepts, Implementations, and Practical Use Cases
Java Tech Enthusiast
Java Tech Enthusiast
Mar 19, 2025 · Backend Development

Java Backend Interview Topics: Thread‑Safe Collections, JVM Memory, Optimistic Lock, Caching, and More

The article reviews key Java backend interview topics—including thread‑safe collections, JVM memory layout and heap tuning, Full GC troubleshooting, Java 8 features, optimistic locking, stock‑over‑sell handling with Redis, MySQL scaling, cache‑consistency patterns, anti‑bot safeguards, and Bloom filters—while noting JD’s recent 30% salary hike for algorithm engineers.

ConcurrencyJVMJava
0 likes · 22 min read
Java Backend Interview Topics: Thread‑Safe Collections, JVM Memory, Optimistic Lock, Caching, and More
Code Ape Tech Column
Code Ape Tech Column
Mar 19, 2025 · Backend Development

ExecutorService vs CompletionService: In‑Depth Comparison and Practical Usage in Java

This article explains the differences between ExecutorService and CompletionService, demonstrates how to replace a simple Future‑based approach with CompletionService for faster result retrieval, analyzes the underlying source code, and outlines typical use‑cases such as load‑balancing and early‑return patterns in concurrent Java applications.

AsyncCompletionServiceConcurrency
0 likes · 12 min read
ExecutorService vs CompletionService: In‑Depth Comparison and Practical Usage in Java
Architect's Must-Have
Architect's Must-Have
Mar 18, 2025 · Backend Development

Why Netty Uses FastThreadLocal and How It Outperforms JDK ThreadLocal

This article explains the motivation behind Netty's FastThreadLocal, details its internal design using an indexed array to avoid hash collisions, analyzes the core source code of InternalThreadLocalMap, FastThreadLocalThread, and FastThreadLocal, and discusses performance implications and reclamation strategies.

ConcurrencyFastThreadLocalJava
0 likes · 10 min read
Why Netty Uses FastThreadLocal and How It Outperforms JDK ThreadLocal
Tencent Cloud Developer
Tencent Cloud Developer
Mar 18, 2025 · Fundamentals

Java vs Go: Syntax, OOP, Error Handling, Concurrency, Garbage Collection and Performance Comparison

The article compares Java and Go across syntax, variable declaration, object‑oriented features, error handling, concurrency models, garbage collection, resource usage, and ecosystem maturity, concluding that Go offers simpler code, lightweight concurrency and lower overhead, while Java provides a richer library ecosystem and more mature tooling, making the choice dependent on project requirements.

ConcurrencyError handlingGarbage Collection
0 likes · 26 min read
Java vs Go: Syntax, OOP, Error Handling, Concurrency, Garbage Collection and Performance Comparison
Lin is Dream
Lin is Dream
Mar 16, 2025 · Fundamentals

Mastering TPS and QPS: Simple Calculations and Real-World Examples

This article explains the key performance metrics TPS (transactions per second) and QPS (queries per second), provides formulas for calculating them, and demonstrates practical calculations for multi-node deployments, illustrating how request latency, thread pools, and instance count affect overall system concurrency and throughput.

ConcurrencyQPSSystem Performance
0 likes · 3 min read
Mastering TPS and QPS: Simple Calculations and Real-World Examples
Architecture Development Notes
Architecture Development Notes
Mar 16, 2025 · Backend Development

Choosing the Right Concurrency Model: Go vs Python vs Rust

This article compares Go, Python, and Rust concurrency implementations—covering CSP‑based goroutines, GIL constraints, and ownership‑driven thread safety—to help developers select the most suitable model for high‑throughput, CPU‑bound, or safety‑critical applications.

ConcurrencyMultithreadingPython
0 likes · 9 min read
Choosing the Right Concurrency Model: Go vs Python vs Rust
FunTester
FunTester
Mar 15, 2025 · Operations

Simulating Elderly Checkout Times with ThreadLocalRandom in Java

The article revises a supermarket checkout performance test by incorporating elderly customers who take twice as long to pay, demonstrates using Java's ThreadLocalRandom to randomly assign customer age groups, modifies the pay() method to double payment time for seniors, and explains why realistic scenarios improve testing accuracy.

ConcurrencyJavaSimulation
0 likes · 4 min read
Simulating Elderly Checkout Times with ThreadLocalRandom in Java
Ops Development & AI Practice
Ops Development & AI Practice
Mar 12, 2025 · Backend Development

Mastering Go Closures: How Functions Capture Their Environment

This article explains Go closures—what they are, how they capture surrounding variables, key characteristics, practical code examples, common pitfalls like memory leaks and concurrency issues, and typical use‑cases such as function factories, state management, callbacks, and interface implementation.

Backend DevelopmentConcurrencyFunctions
0 likes · 7 min read
Mastering Go Closures: How Functions Capture Their Environment
Cognitive Technology Team
Cognitive Technology Team
Mar 9, 2025 · Backend Development

Understanding wait() and notify() in Java Multithreading

This article explains the concepts, usage conditions, execution flow, internal mechanisms, and best‑practice guidelines for Java's wait() and notify() methods, illustrated with a producer‑consumer example and code snippets for safe thread coordination.

ConcurrencyJavaNotify
0 likes · 6 min read
Understanding wait() and notify() in Java Multithreading
Raymond Ops
Raymond Ops
Mar 6, 2025 · Backend Development

Why Switch from PHP to Go? Mastering Concurrency with WaitGroup and ErrGroup

This article explains why backend developers are moving from PHP to Go, outlines the concurrency challenges of high‑traffic live streaming services, and demonstrates two practical Go patterns—sync.WaitGroup and errgroup.Group—with code examples, while also warning about common closure pitfalls in loops.

ConcurrencyErrGroupPHP migration
0 likes · 9 min read
Why Switch from PHP to Go? Mastering Concurrency with WaitGroup and ErrGroup
JavaScript
JavaScript
Mar 6, 2025 · Frontend Development

Why Promise.allSettled Beats Promise.all for Robust Async JavaScript

Promise.allSettled overcomes the fatal flaw of Promise.all by waiting for all promises to settle—whether fulfilled or rejected—returning a uniform result array that lets developers identify successful outcomes and handle failures without aborting the entire operation, enabling more resilient asynchronous code.

ConcurrencyJavaScriptPromise
0 likes · 3 min read
Why Promise.allSettled Beats Promise.all for Robust Async JavaScript
FunTester
FunTester
Mar 6, 2025 · Backend Development

Common Mistakes with Go's select Statement and How to Fix Them

This article examines frequent errors when using Go's select statement—such as omitting a default case, misunderstanding case order, handling nil channels, missing timeout logic, and duplicate cases—explaining their impact, offering best‑practice guidance, and providing corrected code examples for each scenario.

ConcurrencyError handlinggo
0 likes · 14 min read
Common Mistakes with Go's select Statement and How to Fix Them
Architecture Digest
Architecture Digest
Mar 5, 2025 · Backend Development

Understanding Java Virtual Threads and Their Performance Benefits in Spring Boot

This article introduces Java 21's virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, compares performance against traditional threads, and offers additional Java performance‑tuning techniques.

ConcurrencyJavaJava 21
0 likes · 7 min read
Understanding Java Virtual Threads and Their Performance Benefits in Spring Boot
Java High-Performance Architecture
Java High-Performance Architecture
Mar 5, 2025 · Backend Development

Unlock Massive Concurrency: How Java 21 Virtual Threads Supercharge Spring Boot

Java 21’s virtual threads provide lightweight, high‑concurrency execution managed by the JVM, enabling developers to create hundreds of thousands of threads with minimal overhead; this article explains their basics, demonstrates Spring Boot integration, compares performance against traditional threads, and shares additional Java optimization techniques.

ConcurrencyJavaPerformance
0 likes · 8 min read
Unlock Massive Concurrency: How Java 21 Virtual Threads Supercharge Spring Boot
macrozheng
macrozheng
Mar 5, 2025 · Backend Development

How to Merge Concurrent Requests in Spring Boot to Save Database Connections

This article explains how to combine multiple simultaneous user requests on the server side using a queue, scheduled thread pool and CompletableFuture in Spring Boot, reducing database connections while handling high concurrency, and discusses implementation details, testing, and potential pitfalls.

ConcurrencySpring Bootbatch processing
0 likes · 15 min read
How to Merge Concurrent Requests in Spring Boot to Save Database Connections
Su San Talks Tech
Su San Talks Tech
Mar 3, 2025 · Backend Development

Mastering Java Thread Pools: Architecture, Parameters, and Customization

This article provides a comprehensive guide to Java thread pools, explaining their purpose, construction parameters, execution flow, worker reuse, task retrieval with timeout, lifecycle states, shutdown mechanisms, monitoring methods, and best practices for customizing pools in real-world projects.

ConcurrencyExecutorServiceJava
0 likes · 17 min read
Mastering Java Thread Pools: Architecture, Parameters, and Customization
Open Source Tech Hub
Open Source Tech Hub
Mar 2, 2025 · Backend Development

Can PHP Achieve True Asynchronous Execution? Inside the True Async RFC

This article examines the PHP True Async RFC, outlining its goals to provide a standard C‑API for non‑blocking I/O, describing implicit versus explicit async models, presenting a scheduler‑reactor design, and showing example code that runs concurrent fibers without altering existing PHP code.

ConcurrencyPHPasynchronous
0 likes · 7 min read
Can PHP Achieve True Asynchronous Execution? Inside the True Async RFC
Ops Development & AI Practice
Ops Development & AI Practice
Mar 1, 2025 · Fundamentals

Understanding Concurrency Scheduling Models: From User Threads to Go’s M:P:G Scheduler

This article explains the main concurrency scheduling models—including user‑level, kernel‑level, two‑level (M:N), and coroutine approaches—covers common scheduling algorithms, and details Go’s unique M:P:G scheduler, highlighting its principles, workflow, and advantages for high‑performance parallel execution.

ConcurrencySchedulingThreads
0 likes · 9 min read
Understanding Concurrency Scheduling Models: From User Threads to Go’s M:P:G Scheduler
Cognitive Technology Team
Cognitive Technology Team
Mar 1, 2025 · Databases

Async IO Thread in Redis 8.0 M3: Design, Implementation, and Performance Evaluation

The article explains why Redis needs asynchronous IO threading, describes the shortcomings of previous IO‑thread models, details the design of the new async IO thread architecture with event‑notified client queues and thread‑safety mechanisms, and presents performance test results showing up to double the QPS and significantly lower latency.

Async IOConcurrencyDatabase
0 likes · 15 min read
Async IO Thread in Redis 8.0 M3: Design, Implementation, and Performance Evaluation
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 26, 2025 · Backend Development

Mastering Optimistic Locking in Spring Boot 3: From Pitfalls to Proven Solutions

This article examines the challenges of using JPA optimistic locking for inventory deduction under high concurrency, demonstrates why naive retry logic can cause deadlocks and stale data, and walks through five progressively refined implementations that resolve transaction, caching, and isolation issues.

ConcurrencyOptimistic LockingSpring Boot
0 likes · 13 min read
Mastering Optimistic Locking in Spring Boot 3: From Pitfalls to Proven Solutions
Code Mala Tang
Code Mala Tang
Feb 20, 2025 · Fundamentals

Mastering Lock Mechanisms: From Mutexes to Distributed Locks in Python

This comprehensive guide explores why locks are essential in concurrent programming, explains the principles behind mutexes, semaphores, read‑write locks, and re‑entrant locks, provides Python code examples, discusses common pitfalls like deadlocks, and offers best‑practice strategies for production environments.

ConcurrencyDeadlockLocking
0 likes · 22 min read
Mastering Lock Mechanisms: From Mutexes to Distributed Locks in Python
FunTester
FunTester
Feb 20, 2025 · Backend Development

How to Build a Custom Multithreaded Test Engine in Java

This article walks through designing and implementing a Java multithreaded execution class for performance testing, covering thread‑pool creation, task coordination with CountDownLatch, start/stop control, and a complete demo that runs concurrent tasks with timed logging.

ConcurrencyCountDownLatchJava
0 likes · 10 min read
How to Build a Custom Multithreaded Test Engine in Java
JD Tech
JD Tech
Feb 19, 2025 · Backend Development

Understanding the Design and Implementation of Caffeine Cache

This article provides a comprehensive walkthrough of Caffeine cache's architecture, explaining its fixed-size eviction policy, underlying data structures such as ConcurrentHashMap, MPSC buffers, Count‑Min Sketch frequency tracking, and the dynamic window‑probation‑protected zones, while detailing key methods like put, getIfPresent, and maintenance.

CacheCaffeineConcurrency
0 likes · 71 min read
Understanding the Design and Implementation of Caffeine Cache
Selected Java Interview Questions
Selected Java Interview Questions
Feb 18, 2025 · Backend Development

Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions

The article explains how Java's synchronized keyword works only within a single JVM, why it fails to provide mutual exclusion across multiple processes in distributed systems, and presents alternative distributed locking mechanisms such as database locks and Redis-based locks with code examples.

ConcurrencyDistributed LockJava
0 likes · 8 min read
Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions
FunTester
FunTester
Feb 18, 2025 · Fundamentals

Understanding Mutex Locks and Their Use in Go Concurrency

This article explains what a mutex is, why it is needed in concurrent programming, shows basic lock/unlock operations with Go code examples, compares mutexes with atomic operations, and provides best‑practice guidelines to avoid deadlocks and improve performance.

ConcurrencyDeadlockSynchronization
0 likes · 8 min read
Understanding Mutex Locks and Their Use in Go Concurrency
Radish, Keep Going!
Radish, Keep Going!
Feb 18, 2025 · Fundamentals

Which Programming Language Wins a 10 Billion Loop Test? Insights from a Community Benchmark

Ben Dicken conducted a massive benchmark running 10 billion nested loops across many languages—Zig, Julia, Perl, Elixir, Fortran, C#, Lua, and more—while the community contributed optimizations such as goroutine‑based Go improvements, sparking discussions on fair measurement, startup overhead, and concurrency advantages.

BenchmarkConcurrencyOptimization
0 likes · 3 min read
Which Programming Language Wins a 10 Billion Loop Test? Insights from a Community Benchmark
Java Tech Enthusiast
Java Tech Enthusiast
Feb 17, 2025 · Fundamentals

Why a Java Volatile Example May Terminate Without Volatile

The program that loops on a non‑volatile boolean flag sometimes terminates because changing the counter to a volatile int or to an Integer causes the JVM to emit hidden memory barriers on reference writes, making the flag visible, but this behavior is JVM‑specific and not a reliable substitute for declaring the flag volatile.

ConcurrencyHotSpotJVM
0 likes · 11 min read
Why a Java Volatile Example May Terminate Without Volatile
Raymond Ops
Raymond Ops
Feb 15, 2025 · Backend Development

Why Switch from PHP to Go? Boosting Concurrency for Live Streaming

This article explains why backend developers are moving from PHP to Go, demonstrates how Go's built-in concurrency primitives like sync.WaitGroup and errgroup simplify high‑traffic live‑streaming services, and warns about common closure pitfalls when launching goroutines in loops.

ConcurrencyLive Streamingclosure
0 likes · 10 min read
Why Switch from PHP to Go? Boosting Concurrency for Live Streaming
Code Mala Tang
Code Mala Tang
Feb 15, 2025 · Fundamentals

Unlock Full CPU Power in Python: A Hands‑On Guide to Multiprocessing

This article explains why Python’s Global Interpreter Lock limits CPU core usage, introduces the multiprocessing module for parallel execution of CPU‑intensive tasks, and provides step‑by‑step code examples, key concepts, synchronization tools, a real‑world image‑processing case, and best practices to dramatically speed up your programs.

CPU BoundConcurrencyMultiprocessing
0 likes · 9 min read
Unlock Full CPU Power in Python: A Hands‑On Guide to Multiprocessing
FunTester
FunTester
Feb 12, 2025 · Backend Development

Mastering Thread Coordination: Waiters, Rendezvous, Joiners in Java

The article explains the Helper class’s built‑in thread coordination operations—including Waiters, Rendezvous, Joiners, and execution‑aborting methods—detailing their APIs, usage scenarios, parameters, and behavior such as signaling, timeouts, rejoinable points, and how they differ from standard Java synchronization primitives.

ConcurrencyHelper APIJava
0 likes · 12 min read
Mastering Thread Coordination: Waiters, Rendezvous, Joiners in Java
Radish, Keep Going!
Radish, Keep Going!
Feb 11, 2025 · Fundamentals

How Go 1.24’s New Spinning Mutex Boosts Performance by Up to 70%

The article explains the background of the Go mutex performance proposal, details the new spinning flag added to the mutex state, walks through fast‑path, spinning, and sleep phases of lock acquisition, presents benchmark results showing up to 70% speed‑up, and provides references for further reading.

Concurrencygomutex
0 likes · 11 min read
How Go 1.24’s New Spinning Mutex Boosts Performance by Up to 70%
Go Programming World
Go Programming World
Feb 11, 2025 · Backend Development

Deep Dive into Go's sync.Map: Implementation, Usage, and Performance

An in‑depth exploration of Go’s sync.Map reveals its concurrent map implementation, covering core structures, read‑only and dirty maps, entry states, and detailed walkthroughs of Store, Load, Delete, Range, Clear, and advanced operations like LoadOrStore, CompareAndSwap, and CompareAndDelete with code examples.

Concurrencygomap
0 likes · 30 min read
Deep Dive into Go's sync.Map: Implementation, Usage, and Performance
Sanyou's Java Diary
Sanyou's Java Diary
Feb 10, 2025 · Backend Development

10 Essential Backend Optimization Techniques Every Developer Should Master

This comprehensive guide explores ten critical backend optimization strategies—from defensive validation and batch N+1 query elimination to asynchronous processing, parallel execution, caching, connection pooling, compression, message queuing, and design patterns—providing practical examples, Go code snippets, and best‑practice insights to boost performance and reliability.

Backend DevelopmentConcurrencyDesign Patterns
0 likes · 32 min read
10 Essential Backend Optimization Techniques Every Developer Should Master
Lobster Programming
Lobster Programming
Feb 10, 2025 · Backend Development

How to Choose the Right Distributed Lock: DB, Redis, or ZooKeeper?

This article explains the concept of distributed locks and compares three common implementation approaches—using a database, Redis, and ZooKeeper—detailing their mechanisms, advantages, drawbacks, and suitable scenarios for ensuring consistent access to shared resources in distributed systems.

ConcurrencyDistributed LockZookeeper
0 likes · 7 min read
How to Choose the Right Distributed Lock: DB, Redis, or ZooKeeper?
JavaScript
JavaScript
Feb 7, 2025 · Frontend Development

Mastering Promise Concurrency: Techniques to Control Async Tasks in JavaScript

This article explains how to manage Promise concurrency in JavaScript, covering built‑in methods like Promise.all, allSettled, race, any, custom throttling functions, third‑party libraries, generator‑based solutions, and message‑queue approaches to improve performance and user experience.

ConcurrencyJavaScriptPromise
0 likes · 8 min read
Mastering Promise Concurrency: Techniques to Control Async Tasks in JavaScript
Programmer XiaoFu
Programmer XiaoFu
Feb 5, 2025 · Backend Development

Elegant Ways to Capture Exceptions from Java ThreadPool Tasks

This article explains why tasks submitted with ExecutorService.submit hide exceptions while execute prints them, demonstrates how Future.get() can retrieve hidden errors, and presents three practical solutions—inline try‑catch, a custom ThreadFactory with UncaughtExceptionHandler, and overriding afterExecute—to reliably handle thread‑pool exceptions in Java.

ConcurrencyExceptionHandlingExecutorService
0 likes · 15 min read
Elegant Ways to Capture Exceptions from Java ThreadPool Tasks
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 3, 2025 · Backend Development

Code Review of Coupon Claim and Approval Workflow: Issues and Optimization Strategies

This article reviews Java Spring code for a coupon claim and approval workflow, identifies concurrency and transaction issues such as missing locks and inconsistent update order, and proposes optimizations including user‑level locking, simplifying lock management, and aligning transactional update sequences to prevent deadlocks.

ConcurrencyDistributed LockJava
0 likes · 12 min read
Code Review of Coupon Claim and Approval Workflow: Issues and Optimization Strategies
Java Web Project
Java Web Project
Feb 1, 2025 · Backend Development

Choosing the Right Java Async Tool: Future, CompletableFuture, or FutureTask

This article compares three Java concurrency approaches—Future with Callable, CompletableFuture, and FutureTask—explaining their underlying principles, step‑by‑step usage, code examples, and trade‑offs so you can decide which asynchronous tool best fits your reporting workload.

CompletableFutureConcurrencyFuture
0 likes · 10 min read
Choosing the Right Java Async Tool: Future, CompletableFuture, or FutureTask
Java Tech Enthusiast
Java Tech Enthusiast
Jan 31, 2025 · Backend Development

Java 21 Virtual Threads: Benefits, Usage, and Performance Comparison

Java 21’s virtual threads provide a lightweight, JVM‑managed alternative to OS threads that enables hundreds of thousands of concurrent tasks, simplifies scheduling, integrates easily into Spring Boot via a preview flag and Tomcat executor, and delivers up to five‑fold speed‑ups and lower latency in high‑load I/O‑intensive applications.

ConcurrencyJavaPerformance
0 likes · 7 min read
Java 21 Virtual Threads: Benefits, Usage, and Performance Comparison
Architecture & Thinking
Architecture & Thinking
Jan 28, 2025 · Fundamentals

Understanding Java Deadlocks: Causes, Examples, and Prevention Strategies

This article explains the concept of deadlocks in concurrent programming, outlines the four necessary conditions, examines common causes in Java, provides a runnable code example, and presents practical prevention, avoidance, detection, and recovery techniques to keep multithreaded applications running smoothly.

ConcurrencyDeadlockMultithreading
0 likes · 7 min read
Understanding Java Deadlocks: Causes, Examples, and Prevention Strategies
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 25, 2025 · Backend Development

Mastering CompletableFuture in Java: Basics, Advanced Features, and Best Practices

This comprehensive guide introduces Java's CompletableFuture, explains its advantages over the traditional Future API, demonstrates how to create and compose asynchronous tasks, manage thread pools, handle timeouts and cancellations, and apply robust exception handling techniques for reliable concurrent programming.

CompletableFutureConcurrencyFuture
0 likes · 16 min read
Mastering CompletableFuture in Java: Basics, Advanced Features, and Best Practices
php Courses
php Courses
Jan 23, 2025 · Backend Development

PHP vs Go: Choosing the Right Language for Your Project

This article compares PHP and Go across history, ecosystem, performance, concurrency, memory management, and typical use‑cases, providing guidance on when to select PHP for rapid web development or Go for high‑performance, cloud‑native and distributed systems.

ComparisonConcurrencyPHP
0 likes · 21 min read
PHP vs Go: Choosing the Right Language for Your Project
Su San Talks Tech
Su San Talks Tech
Jan 23, 2025 · Backend Development

How to Prevent Overselling in High‑Concurrency Flash Sale Systems

This article explores common overselling problems in high‑concurrency flash‑sale scenarios and presents seven practical solutions—including lock timing adjustments, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—each illustrated with SpringBoot code and performance test results.

ConcurrencyDatabaseJava
0 likes · 20 min read
How to Prevent Overselling in High‑Concurrency Flash Sale Systems
DeWu Technology
DeWu Technology
Jan 20, 2025 · Backend Development

Migrating Observability Compute Layer from Java to Rust: Ownership, Concurrency, Deployment, and Monitoring

The article details how moving a high‑throughput observability compute layer from Java to Rust—leveraging Rust’s ownership, zero‑cost async, and static binary deployment—cut memory usage by roughly 68%, CPU consumption by 40%, while outlining monitoring setup, concurrency model, and the steep learning‑curve challenges.

ConcurrencyDeploymentObservability
0 likes · 18 min read
Migrating Observability Compute Layer from Java to Rust: Ownership, Concurrency, Deployment, and Monitoring
JD Tech Talk
JD Tech Talk
Jan 20, 2025 · Backend Development

Inventory Pre-Reservation: Challenges, Solutions, and Performance Optimizations

The article examines inventory pre‑reservation in e‑commerce, detailing performance challenges under high concurrency, and evaluates solutions such as asynchronous rate limiting, horizontal stock splitting, Redis caching, database transaction handling, deadlock avoidance, and data consistency mechanisms, highlighting a 24‑fold throughput increase.

CachingConcurrencyDatabase
0 likes · 9 min read
Inventory Pre-Reservation: Challenges, Solutions, and Performance Optimizations
FunTester
FunTester
Jan 20, 2025 · Fundamentals

Mastering ThreadLocal in Java: From Basics to Best Practices

ThreadLocal provides a simple yet powerful way to give each thread its own independent variable, eliminating shared-state conflicts; this guide explains its underlying mechanism, creation methods, basic get/set operations, a complete example with console output, and important usage considerations such as potential memory leaks.

ConcurrencyJavaMultithreading
0 likes · 6 min read
Mastering ThreadLocal in Java: From Basics to Best Practices
Java Architect Essentials
Java Architect Essentials
Jan 19, 2025 · Backend Development

Proper Declaration, Monitoring, and Configuration of Java Thread Pools

This article explains how to correctly declare Java thread pools using ThreadPoolExecutor, monitor their runtime status, configure parameters for CPU‑bound and I/O‑bound workloads, assign meaningful names, avoid common pitfalls such as unbounded queues and thread‑local leakage, and leverage dynamic pool frameworks.

Best PracticesConcurrencyJava
0 likes · 16 min read
Proper Declaration, Monitoring, and Configuration of Java Thread Pools
Architect
Architect
Jan 18, 2025 · Backend Development

Mastering High‑Concurrency Flash‑Sale: 7 Locking & Queue Strategies in SpringBoot

This article analyzes a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, and JMeter, demonstrates seven implementations—from service‑level locks to AOP, pessimistic/optimistic locks, and queue‑based designs—examines their trade‑offs with concrete code, test results, and practical recommendations.

ConcurrencyDatabaseJMeter
0 likes · 20 min read
Mastering High‑Concurrency Flash‑Sale: 7 Locking & Queue Strategies in SpringBoot
IT Services Circle
IT Services Circle
Jan 18, 2025 · Fundamentals

Why Multithreading Programming Is So Hard

The article uses everyday analogies to explain why multithreaded programming, especially when dealing with shared data, debugging, and performance optimization, is inherently difficult due to nondeterministic execution, combination explosion, and the challenges of lock granularity.

ConcurrencyPerformancedebugging
0 likes · 4 min read
Why Multithreading Programming Is So Hard
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 17, 2025 · Backend Development

Why Reentrant Locks Prevent Deadlocks and How to Use Them in Java

Reentrant locks are thread‑safe synchronization tools that let the same thread acquire the same lock multiple times without deadlocking, tracking acquisition counts, and offering advantages over traditional synchronized blocks, with Java’s ReentrantLock providing flexible features such as interruptible and timed locking, illustrated by a complete code example.

ConcurrencyJavaReentrantLock
0 likes · 6 min read
Why Reentrant Locks Prevent Deadlocks and How to Use Them in Java
Su San Talks Tech
Su San Talks Tech
Jan 16, 2025 · Backend Development

Boost Java Performance with Virtual Threads: A Hands‑On Guide

This article explains Java 21's virtual threads, their lightweight and auto‑managed nature, demonstrates basic usage and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance tips for high‑concurrency applications.

ConcurrencyJavaPerformance
0 likes · 8 min read
Boost Java Performance with Virtual Threads: A Hands‑On Guide
BirdNest Tech Talk
BirdNest Tech Talk
Jan 15, 2025 · Backend Development

Data Race vs Race Condition in Go: Clear Differences and How to Fix Them

The article explains the distinction between a data race—simultaneous unsynchronized memory access by goroutines—and a race condition—logic errors caused by timing dependencies—using Go code examples, demonstrates how to reproduce each issue, and shows how mutexes or atomic operations can resolve them.

ConcurrencyData Raceatomic
0 likes · 5 min read
Data Race vs Race Condition in Go: Clear Differences and How to Fix Them
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 14, 2025 · Backend Development

Mastering Java ThreadLocal: Core Operations, Map Structure, and Practical Examples

This article explains Java's ThreadLocal mechanism, detailing its internal ThreadLocalMap structure, core set/get/remove operations with full code examples, and demonstrates how multiple ThreadLocal variables are stored per thread, providing a clear understanding of thread‑local storage in backend development.

Backend DevelopmentConcurrencyJava
0 likes · 6 min read
Mastering Java ThreadLocal: Core Operations, Map Structure, and Practical Examples
Senior Tony
Senior Tony
Jan 13, 2025 · Backend Development

How Java’s AQS Powers ReentrantLock – A Deep Dive into the Source

This article explains the core concepts of Java’s AbstractQueuedSynchronizer (AQS), its exclusive and shared modes, the template‑method design it uses, and walks through the actual source code showing how ReentrantLock implements both fair and non‑fair locking, complete with diagrams and code snippets for interview preparation.

AQSConcurrencyJava
0 likes · 10 min read
How Java’s AQS Powers ReentrantLock – A Deep Dive into the Source
FunTester
FunTester
Jan 13, 2025 · Backend Development

Mastering Java’s Phaser: Advanced Thread Synchronization for Performance Testing

This article explains Java’s java.util.concurrent.Phaser class, compares it with CountDownLatch, details its core methods, demonstrates practical usage with code examples, and shows how to build a custom lightweight synchronization utility for performance testing scenarios.

ConcurrencyJavaPerformanceTesting
0 likes · 13 min read
Mastering Java’s Phaser: Advanced Thread Synchronization for Performance Testing
Test Development Learning Exchange
Test Development Learning Exchange
Jan 10, 2025 · Fundamentals

Advanced Python Features and Their Use Cases

This article introduces twenty advanced Python concepts—including decorators, context managers, generators, metaclasses, multiple inheritance, coroutines, closures, magic methods, dynamic attributes, GIL, async IO, regular expressions, garbage collection, modules, virtual environments, SOLID principles, type annotations, IPC, memory management, and reflection—explaining their typical use cases and providing clear code examples for each.

Advanced FeaturesConcurrencyPython
0 likes · 11 min read
Advanced Python Features and Their Use Cases
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 10, 2025 · Backend Development

Mastering CountDownLatch and CyclicBarrier: Java Concurrency Made Simple

CountDownLatch and CyclicBarrier are two essential Java synchronization tools from java.util.concurrent, enabling threads to coordinate tasks; this guide explains their concepts, usage with code examples, advantages, disadvantages, and key differences, helping developers choose the right tool for thread coordination.

ConcurrencyCountDownLatchCyclicBarrier
0 likes · 10 min read
Mastering CountDownLatch and CyclicBarrier: Java Concurrency Made Simple
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 9, 2025 · Fundamentals

Master Java Thread Communication: wait/notify, Locks, Conditions & BlockingQueue

This article explores Java's thread communication techniques—including the basic wait/notify mechanism, advanced Lock and Condition usage, and the thread‑safe BlockingQueue—providing detailed explanations, producer‑consumer examples, and additional concurrency utilities like CountDownLatch, illustrating how to coordinate threads efficiently in multithreaded applications.

BlockingQueueConcurrencyCondition
0 likes · 18 min read
Master Java Thread Communication: wait/notify, Locks, Conditions & BlockingQueue
Code Ape Tech Column
Code Ape Tech Column
Jan 8, 2025 · Backend Development

Implementing High‑Concurrency Flash‑Sale (Seckill) in SpringBoot: Locking Strategies, Queue Solutions, and Performance Testing

This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, Mybatis‑Plus and JMeter, analyzes the overselling problem caused by premature lock release, and presents seven solutions—including lock‑first strategies, AOP, pessimistic and optimistic locks, and queue‑based approaches—along with code samples and test results.

AOPConcurrencyDatabase
0 likes · 19 min read
Implementing High‑Concurrency Flash‑Sale (Seckill) in SpringBoot: Locking Strategies, Queue Solutions, and Performance Testing
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 8, 2025 · Backend Development

Why Java ThreadPoolExecutor’s Core Threads Aren’t Recycled by Default

In Java’s ThreadPoolExecutor, core threads remain alive even when idle unless the allowCoreThreadTimeOut flag is set to true, which then permits both core and non‑core threads to be reclaimed after exceeding the keepAliveTime threshold, a behavior that contradicts the pool’s design principle of minimizing thread creation overhead.

ConcurrencyJavaThreadPoolExecutor
0 likes · 2 min read
Why Java ThreadPoolExecutor’s Core Threads Aren’t Recycled by Default
Raymond Ops
Raymond Ops
Jan 7, 2025 · Backend Development

Mastering Go’s Context: Control Goroutine Lifecycles and Cancel Operations

This article explains Go's Context concept, its role in managing Goroutine lifecycles, the standard library's context package API, how to create and cancel contexts, share values safely, and best practices for using Contexts in concurrent backend applications.

Backend DevelopmentConcurrencyContext
0 likes · 11 min read
Mastering Go’s Context: Control Goroutine Lifecycles and Cancel Operations
IT Services Circle
IT Services Circle
Jan 7, 2025 · Backend Development

Replacing Thread.sleep Loops with Proper Scheduling in Java

The article explains why using Thread.sleep in a loop causes busy‑waiting and performance problems, and demonstrates several Java scheduling alternatives—including Timer/TimerTask, ScheduledExecutorService, wait/notify, and CompletableFuture—to efficiently check a flag at fixed intervals.

CompletableFutureConcurrencyJava
0 likes · 9 min read
Replacing Thread.sleep Loops with Proper Scheduling in Java
BirdNest Tech Talk
BirdNest Tech Talk
Jan 6, 2025 · Fundamentals

Mastering Go Concurrency: From Basics to Advanced Patterns

This article outlines a comprehensive guide to Go's concurrency model, covering fundamental concepts, goroutine scheduling, synchronization primitives, channel communication, common patterns, deadlock avoidance techniques, and performance‑optimizing mechanisms with concrete code examples and step‑by‑step explanations.

ChannelsConcurrencyDeadlock
0 likes · 13 min read
Mastering Go Concurrency: From Basics to Advanced Patterns
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 6, 2025 · Backend Development

Master Thread Sequencing in Java: 8 Proven Techniques

This article explains why thread execution order is nondeterministic and presents eight Java techniques—join, single‑thread executor, CountDownLatch, CyclicBarrier, Semaphore, synchronized with wait/notify, and Lock with Condition—to reliably enforce sequential execution, complete with clear code examples for each method.

ConcurrencyCountDownLatchExecutorService
0 likes · 13 min read
Master Thread Sequencing in Java: 8 Proven Techniques
Top Architect
Top Architect
Jan 2, 2025 · Fundamentals

Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java

This article explains the Fork/Join model and ForkJoinPool in Java, covering divide‑and‑conquer theory, RecursiveTask implementation, task submission methods, work‑stealing queues, common pool pitfalls, and performance testing with code examples to help developers choose and tune parallel execution strategies.

ConcurrencyDivideAndConquerForkJoinPool
0 likes · 25 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java