BestHub
Sign in
Tagged articles

Concurrency

2155 articles · Page 4 of 22
JakartaEE China Community
JakartaEE China Community
Jun 30, 2025 · Backend Development

7 Key Features Introduced in Jakarta EE 10

Jakarta EE 10, now governed by the Eclipse Foundation, brings vendor‑neutral APIs and seven notable enhancements—including managed executor definitions, a new @Asynchronous annotation, multipart/form‑data support, OpenID authentication, UUID primary keys, expanded numeric and date‑time functions, and a pure‑Java view for Jakarta Faces—while inviting community contributions for its upcoming final release.

ConcurrencyJakarta EE 10Java EE
0 likes · 10 min read
7 Key Features Introduced in Jakarta EE 10
Architect's Guide
Architect's Guide
Jun 27, 2025 · Backend Development

Demystifying Java Locks: From Pessimistic vs Optimistic to ReentrantLock Internals

This article explains the classification of Java locks—including pessimistic, optimistic, fair, and unfair variants—details their state transitions from biased to heavyweight, and walks through the source code of ReentrantLock and Condition to illustrate how synchronization, queuing, and thread parking are implemented in the JVM.

AQSConcurrencyCondition
0 likes · 20 min read
Demystifying Java Locks: From Pessimistic vs Optimistic to ReentrantLock Internals
21CTO
21CTO
Jun 19, 2025 · Backend Development

Why Go (Golang) Dominates 2025 Backend Development: Speed, Concurrency & Real‑World Success

Go, created by Google in 2007 and open‑sourced in 2009, has become a top choice for modern backend and cloud‑native development thanks to its simple syntax, powerful built‑in concurrency, fast native compilation, low memory usage, and widespread adoption by companies like Google, Uber, Netflix, Docker, and Kubernetes.

ConcurrencyDockerGolang
0 likes · 26 min read
Why Go (Golang) Dominates 2025 Backend Development: Speed, Concurrency & Real‑World Success
php Courses
php Courses
Jun 19, 2025 · Backend Development

Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained

This article delves into Go’s runtime, explaining the Goroutine scheduler’s G‑P‑M model and work‑stealing, the concurrent tri‑color garbage collector with its phases and tuning flags, the memory allocation hierarchy and escape analysis, and practical tips for high‑performance Go applications.

ConcurrencyGarbage CollectionMemory Model
0 likes · 6 min read
Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained
JakartaEE China Community
JakartaEE China Community
Jun 16, 2025 · Backend Development

What New Features Does Jakarta EE 10 Introduce?

Jakarta EE 10 requires Java 11 (with optional Java 17 support) and brings a mix of minor and major updates across dozens of specifications, including new versions of Authentication, Concurrency, CDI, EL, JSON Binding, Security, Server Faces, Standard Tag Library, SOAP with Attachments, XML Binding, and a streamlined Core Profile for microservices.

CDIConcurrencyExpression Language
0 likes · 9 min read
What New Features Does Jakarta EE 10 Introduce?
Java Architect Essentials
Java Architect Essentials
Jun 14, 2025 · Backend Development

Why System.out.println() Can Kill Your MyBatis Performance and How to Fix It

This article explains why MyBatis's default StdOutImpl logging, which relies on System.out.println, blocks threads and creates severe concurrency bottlenecks, and demonstrates how to replace it with asynchronous logging implementations like Slf4jImpl, configure log levels, and even create custom Log classes for optimal performance.

ConcurrencyJavaLogging
0 likes · 8 min read
Why System.out.println() Can Kill Your MyBatis Performance and How to Fix It
Java Backend Technology
Java Backend Technology
Jun 12, 2025 · Backend Development

Why Debugging a Simple ConcurrentLinkedQueue Can Crash Your Java Program

A seemingly trivial Java program that uses ConcurrentLinkedQueue runs fine normally, but throws a NullPointerException when debugged in IntelliJ IDEA because the IDE silently invokes toString, which mutates internal state, revealing hidden pitfalls of debugging and IDE configurations.

ConcurrencyConcurrentLinkedQueueIntelliJ IDEA
0 likes · 10 min read
Why Debugging a Simple ConcurrentLinkedQueue Can Crash Your Java Program
BirdNest Tech Talk
BirdNest Tech Talk
Jun 11, 2025 · Backend Development

How Go’s New synctest Feature Eliminates Flaky Concurrent Tests

This article explains why Go tests that rely on goroutine scheduling are flaky, demonstrates the problem with concrete code examples, and shows how the experimental synctest feature provides deterministic execution by controlling synthetic time, coordinating goroutine lifecycles, and offering a reliable Wait primitive.

ConcurrencyTestingdeterministic
0 likes · 12 min read
How Go’s New synctest Feature Eliminates Flaky Concurrent Tests
Java Captain
Java Captain
Jun 10, 2025 · Fundamentals

Understanding Java Monitors: How Thread Synchronization Works

Java monitors provide a mechanism for thread synchronization by associating each object with a monitor lock, comprising an entry list, owner thread, and wait set, and the article explains their structure, thread state transitions, and demonstrates usage with a practical code example.

ConcurrencyJavaMonitor
0 likes · 6 min read
Understanding Java Monitors: How Thread Synchronization Works
php Courses
php Courses
Jun 10, 2025 · Backend Development

Unlock Go’s Power: Master the Most Essential Standard Library Packages

This guide walks through Go’s most powerful standard library packages—fmt, net/http, sync, encoding/json, context, os/io, testing, time, sort, and reflect—showing practical code examples, advanced tips, and best‑practice recommendations to boost development efficiency and write professional Go code.

ConcurrencyPerformanceTesting
0 likes · 20 min read
Unlock Go’s Power: Master the Most Essential Standard Library Packages
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 9, 2025 · Backend Development

How Tokio Powers Rust’s Asynchronous Concurrency: Architecture, Scheduling, and Nginx Comparison

This article explains Tokio's role as Rust's premier async runtime, detailing its task pool and scheduler design, the underlying Future/async/await mechanics, runtime construction, task lifecycle, load‑balancing strategies, CPU‑affinity options, and a performance and development comparison with Nginx.

ConcurrencyNginxRust
0 likes · 18 min read
How Tokio Powers Rust’s Asynchronous Concurrency: Architecture, Scheduling, and Nginx Comparison
Architect's Guide
Architect's Guide
Jun 9, 2025 · Fundamentals

Why 65,535 Isn’t the True Limit for TCP Connections on Linux Servers

The article explains that the 65,535 limit refers only to available port numbers, while actual TCP concurrency on Linux depends on the 4‑tuple identification, memory, file‑descriptor limits, and port reuse, allowing servers to handle far more connections than the port count suggests.

ConcurrencyLinuxSocket
0 likes · 12 min read
Why 65,535 Isn’t the True Limit for TCP Connections on Linux Servers
Java Architect Essentials
Java Architect Essentials
Jun 6, 2025 · Fundamentals

Unlocking Java Thread Pools: How ThreadPoolExecutor Works Under the Hood

This article demystifies Java's ThreadPoolExecutor, explaining why thread pools improve performance, detailing their design analogy to factories, exploring constructors, task queues, rejection policies, worker lifecycle, and practical usage examples, while also covering initialization, shutdown, and dynamic resizing techniques for robust backend development.

Backend DevelopmentConcurrencyThreadPoolExecutor
0 likes · 35 min read
Unlocking Java Thread Pools: How ThreadPoolExecutor Works Under the Hood
Zhuanzhuan Tech
Zhuanzhuan Tech
Jun 4, 2025 · Backend Development

A Comprehensive Guide to Redisson Distributed Locks in Java

This article explains Redisson's various distributed lock mechanisms—including watchdog, reentrant lock, multi‑lock, read‑write lock, semaphore, RedLock, and CountDownLatch—detailing their principles, usage patterns, code examples, and best‑practice recommendations for robust backend concurrency control.

ConcurrencyDistributed LocksJava
0 likes · 16 min read
A Comprehensive Guide to Redisson Distributed Locks in Java
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jun 4, 2025 · Backend Development

Understanding Java Locks, synchronized, ReentrantLock, and Kotlin Coroutine Synchronization

This article explains Java's lock mechanisms—including synchronized, ReentrantLock, and their JVM implementations—covers lock classifications, memory barriers, CAS, and compares them with Kotlin coroutine synchronization tools like Mutex, providing code examples and practical guidance for safe concurrent programming.

ConcurrencyCoroutinesJVM
0 likes · 22 min read
Understanding Java Locks, synchronized, ReentrantLock, and Kotlin Coroutine Synchronization
Code Mala Tang
Code Mala Tang
May 31, 2025 · Backend Development

How to Overcome FastAPI’s CPU‑Bound Bottlenecks: Practical Parallelism Strategies

This article explains why FastAPI struggles with CPU‑intensive tasks due to Python’s Global Interpreter Lock, describes the types of workloads affected, and provides concrete solutions such as background task queues, microservices, ProcessPoolExecutor, and C/C++ extensions to keep APIs responsive and scalable.

CPU BoundConcurrencyFastAPI
0 likes · 8 min read
How to Overcome FastAPI’s CPU‑Bound Bottlenecks: Practical Parallelism Strategies
AndroidPub
AndroidPub
May 29, 2025 · Mobile Development

Avoid These 5 Dangerous Kotlin Coroutine Pitfalls in Android

This article highlights five common Kotlin coroutine pitfalls for Android developers—directly calling suspend functions in Views, misusing GlobalScope, sequential network calls, improper exception handling, and ignoring cancellation—while providing correct implementations and best‑practice guidelines to avoid them.

AndroidConcurrencyCoroutines
0 likes · 10 min read
Avoid These 5 Dangerous Kotlin Coroutine Pitfalls in Android
Architect's Guide
Architect's Guide
May 27, 2025 · Backend Development

Understanding CopyOnWrite (COW) Concept and Its Implementation in Java

The article explains the CopyOnWrite (COW) concept, its read‑write separation benefits for thread‑safe, read‑heavy scenarios, key implementation details in Java’s CopyOnWriteArrayList—including volatile and transient usage—and discusses its memory overhead and eventual‑consistency drawbacks.

ConcurrencyCopyOnWriteDataStructure
0 likes · 5 min read
Understanding CopyOnWrite (COW) Concept and Its Implementation in Java
FunTester
FunTester
May 26, 2025 · Backend Development

Thread‑Safe Round Robin Load Balancer Using Java AtomicInteger

This article explains how to implement a thread‑safe round‑robin load balancer in Java using AtomicInteger, discusses its advantages and limitations, provides sample code for single‑thread and multithreaded scenarios, and suggests further optimizations such as health checks, weighted routing, and dynamic server updates.

AtomicIntegerConcurrencyJava
0 likes · 11 min read
Thread‑Safe Round Robin Load Balancer Using Java AtomicInteger
FunTester
FunTester
May 24, 2025 · Backend Development

How to Stress-Test Netty WebSocket for 10,000 Subscriptions and Keepalive

This article presents advanced WebSocket testing techniques—including asynchronous connection creation, result statistics, price verification, latency measurement, TPS modeling—and demonstrates a Netty‑WebSocket subscription test for 10,000 users plus Java‑ and Netty‑based keepalive implementations for high‑concurrency scenarios.

ConcurrencyJavaNetty
0 likes · 7 min read
How to Stress-Test Netty WebSocket for 10,000 Subscriptions and Keepalive
Didi Tech
Didi Tech
May 22, 2025 · Backend Development

Why Go Services Must Be Optimized and How to Make Them Faster

Optimizing Go services is essential for saving resources, improving stability, and delivering a responsive user experience, and this guide explains the underlying mechanisms, common pitfalls, and practical techniques—from GC tuning and concurrency control to I/O tricks and profiling tools—to help developers build high‑performance, production‑ready Go applications.

ConcurrencyOptimizationPerformance
0 likes · 33 min read
Why Go Services Must Be Optimized and How to Make Them Faster
Java Captain
Java Captain
May 21, 2025 · Fundamentals

Understanding Java Thread States and Their Transitions with Example Code

This article explains the six Java thread states defined in java.lang.Thread.State, describes the meaning of each state, illustrates the possible state transitions, and provides three runnable code examples that demonstrate NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING and TERMINATED states along with their console outputs.

ConcurrencyJavaThreadState
0 likes · 11 min read
Understanding Java Thread States and Their Transitions with Example Code
Deepin Linux
Deepin Linux
May 20, 2025 · Fundamentals

Understanding and Preventing Deadlocks in C++ Multithreaded Programming

This article explains what deadlocks are in C++ multithreaded programming, outlines their causes and four necessary conditions, presents common scenarios and code examples, and offers practical strategies such as consistent lock ordering, std::lock, std::scoped_lock, recursive mutexes, and lock hierarchies to avoid them.

C++ConcurrencyDeadlock
0 likes · 20 min read
Understanding and Preventing Deadlocks in C++ Multithreaded Programming
JD Cloud Developers
JD Cloud Developers
May 19, 2025 · Backend Development

Unlocking Java’s ConcurrentHashMap: Inside Constructors, Put, and Resizing

This article provides a thorough, English‑language walkthrough of Java 8+ ConcurrentHashMap’s source code, covering its constructor logic, load‑factor handling, CAS‑based insertion, node optimizations, the put method, element‑count updates, multi‑threaded resizing, treeification, and auxiliary operations such as get, remove, and computeIfAbsent.

ConcurrencyData StructuresJava
0 likes · 42 min read
Unlocking Java’s ConcurrentHashMap: Inside Constructors, Put, and Resizing
JavaScript
JavaScript
May 19, 2025 · Frontend Development

Mastering Promise Concurrency: Alternatives to Promise.all in JavaScript

While Promise.all is a common way to run multiple promises concurrently, it fails when any promise rejects and offers no control over the number of simultaneous executions; this article explores its limitations and presents elegant alternatives such as Promise.allSettled, simple queue implementations, and libraries like p-limit for effective concurrency management.

ConcurrencyJavaScriptPromise
0 likes · 3 min read
Mastering Promise Concurrency: Alternatives to Promise.all in JavaScript
Cognitive Technology Team
Cognitive Technology Team
May 16, 2025 · Fundamentals

Why Java Switched HashMap Insertion to Tail and How It Affects Concurrency

This article examines the evolution of Java's HashMap from head‑insertion in JDK 1.7 to tail‑insertion in JDK 1.8, explains how the change eliminates circular‑list deadlocks during concurrent resizing, discusses remaining concurrency pitfalls such as red‑black tree conversion, and offers best‑practice solutions like using ConcurrentHashMap and proper initial capacity settings.

ConcurrencyData StructuresHashMap
0 likes · 10 min read
Why Java Switched HashMap Insertion to Tail and How It Affects Concurrency
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 15, 2025 · Fundamentals

Mastering Thread‑Safe Classes in Java: 6 Proven Design Strategies

This article explains what makes a class thread‑safe in Java, illustrates common race‑condition pitfalls with sample code, and presents six practical design strategies—including stateless, immutable, synchronized, volatile, concurrent collections, thread‑confinement, and defensive copying—to help developers build robust, high‑performance concurrent applications.

ConcurrencyDesign PatternsImmutable
0 likes · 11 min read
Mastering Thread‑Safe Classes in Java: 6 Proven Design Strategies
Java Captain
Java Captain
May 12, 2025 · Fundamentals

Understanding Java Thread Pools: Design, Implementation, and Usage

This article explains the purpose, advantages, design principles, configuration parameters, task queue options, rejection policies, lifecycle management, and internal execution flow of Java's ThreadPoolExecutor, providing code examples and detailed insights into how thread pools work in concurrent applications.

ConcurrencyExecutorJava
0 likes · 30 min read
Understanding Java Thread Pools: Design, Implementation, and Usage
IT Services Circle
IT Services Circle
May 10, 2025 · Backend Development

Understanding Java synchronized: Locks, Optimizations, and Example Code

This article explains how Java's synchronized keyword works, covering object and class locks, lock upgrades such as biased, lightweight, and heavyweight locks, the underlying monitor implementation, example code for a thread‑safe counter, and performance considerations for high‑concurrency scenarios.

ConcurrencyJavaLocking
0 likes · 7 min read
Understanding Java synchronized: Locks, Optimizations, and Example Code
Raymond Ops
Raymond Ops
May 8, 2025 · Backend Development

Mastering Go Concurrency: Goroutines, Channels, and Synchronization Explained

This article provides a comprehensive guide to Go's concurrency model, covering goroutine creation, the scheduler, synchronization primitives such as WaitGroup, atomic operations, mutexes, and both unbuffered and buffered channels, with practical code examples and explanations of race conditions and best practices.

ChannelsConcurrencySynchronization
0 likes · 25 min read
Mastering Go Concurrency: Goroutines, Channels, and Synchronization Explained
Ma Wei Says
Ma Wei Says
May 8, 2025 · Backend Development

Mastering Java ThreadPoolExecutor: Prevent OOM and Boost Concurrency

This article explains the fundamentals of Java threads and thread pools, details the configurable parameters of ThreadPoolExecutor, highlights the pitfalls of the Executors factory methods, and provides concrete recommendations and code examples for safely tuning thread pools across different workload types.

ConcurrencyJavaPerformance
0 likes · 14 min read
Mastering Java ThreadPoolExecutor: Prevent OOM and Boost Concurrency
Sohu Tech Products
Sohu Tech Products
May 7, 2025 · Backend Development

Master Java Concurrency: Fork/Join, CountDownLatch, CyclicBarrier, Semaphore & Exchanger Deep Dive

This article provides a comprehensive guide to Java's core concurrency utilities—including Fork/Join, CountDownLatch, CyclicBarrier, Semaphore, and Exchanger—explaining their principles, internal AQS implementation, practical usage patterns, performance optimizations, and complete code examples for real‑world scenarios.

ConcurrencyCountDownLatchCyclicBarrier
0 likes · 25 min read
Master Java Concurrency: Fork/Join, CountDownLatch, CyclicBarrier, Semaphore & Exchanger Deep Dive
Architect's Must-Have
Architect's Must-Have
May 7, 2025 · Backend Development

How ReentrantLock Works: Inside Java’s AbstractQueuedSynchronizer

This article dissects Java’s ReentrantLock implementation, detailing its delegation to AbstractQueuedSynchronizer, the lock acquisition process, the role of non‑fair and fair sync subclasses, the internal CLH queue mechanics, and how unlocking is handled, while comparing Lock with synchronized.

AbstractQueuedSynchronizerConcurrencyJava
0 likes · 14 min read
How ReentrantLock Works: Inside Java’s AbstractQueuedSynchronizer
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 6, 2025 · Backend Development

Understanding Java CyclicBarrier with Practical Examples

This article explains Java's CyclicBarrier synchronization tool, compares it with CountDownLatch, demonstrates basic and array‑sum examples with reusable barriers and callback actions, and shows how it can coordinate multiple threads for tasks such as parallel computation and result aggregation.

ConcurrencyCyclicBarrierJava
0 likes · 6 min read
Understanding Java CyclicBarrier with Practical Examples
Cognitive Technology Team
Cognitive Technology Team
May 6, 2025 · Backend Development

Understanding Java's AbstractQueuedSynchronizer (AQS): Core Components, Design, and Practical Applications

AbstractQueuedSynchronizer (AQS) is the core framework for building Java locks and synchronizers, providing state management, FIFO queuing, and blocking/unblocking mechanisms; this article explains its components, design patterns, thread safety operations, and real-world implementations such as ReentrantLock and Semaphore, with code examples.

AQSConcurrencyJava
0 likes · 11 min read
Understanding Java's AbstractQueuedSynchronizer (AQS): Core Components, Design, and Practical Applications
Deepin Linux
Deepin Linux
May 6, 2025 · Fundamentals

Understanding Processes and Threads: Concepts, Differences, and When to Use Them

This article explains the fundamental concepts of processes and threads, their relationship, resource allocation, scheduling, communication methods, practical use cases, and interview preparation tips, helping readers choose between multiprocessing and multithreading for various scenarios.

ConcurrencyMultiprocessingMultithreading
0 likes · 22 min read
Understanding Processes and Threads: Concepts, Differences, and When to Use Them
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 5, 2025 · Backend Development

Using CountDownLatch in Java to Synchronize Multiple Threads for a Lucky Card Collection Example

This article explains the Java CountDownLatch utility, demonstrates its countdown synchronization mechanism with a lucky‑card‑collection scenario, provides a complete runnable example, and shows how the main thread waits for all worker threads to finish before proceeding to the lottery step.

ConcurrencyCountDownLatchJava
0 likes · 5 min read
Using CountDownLatch in Java to Synchronize Multiple Threads for a Lucky Card Collection Example
Cognitive Technology Team
Cognitive Technology Team
May 5, 2025 · Fundamentals

Evolution of Java ConcurrentHashMap: From Segment Locks to CAS + synchronized (Java 7 vs Java 8)

This article examines the evolution of Java's ConcurrentHashMap, comparing the segment‑lock implementation in Java 7 with the CAS‑plus‑synchronized, bucket‑level locking and red‑black tree enhancements introduced in Java 8, covering lock mechanisms, data structures, resizing strategies, core operations, performance and suitable use cases.

ConcurrencyDataStructureJava
0 likes · 11 min read
Evolution of Java ConcurrentHashMap: From Segment Locks to CAS + synchronized (Java 7 vs Java 8)
Java Captain
Java Captain
May 4, 2025 · Backend Development

Understanding Java Counter Implementations: AtomicLong vs LongAdder

This article explains the principles, advantages, and drawbacks of Java's AtomicLong and LongAdder counters, describes the CAS operation and its ABA problem, and analyzes why Alibaba recommends LongAdder for high‑concurrency, high‑availability scenarios in distributed systems.

CASConcurrencyJava
0 likes · 7 min read
Understanding Java Counter Implementations: AtomicLong vs LongAdder
Cognitive Technology Team
Cognitive Technology Team
May 4, 2025 · Backend Development

Understanding Java ThreadLocal Memory Leaks: Mechanisms, Risks, Diagnosis, and Defensive Practices

This article explains the inner workings of Java's ThreadLocal, analyzes how weak and strong references can cause memory leaks in thread pools, demonstrates typical leak scenarios with code examples, and provides diagnostic tools and defensive coding practices to prevent such leaks.

Best PracticesConcurrencyGarbage Collection
0 likes · 9 min read
Understanding Java ThreadLocal Memory Leaks: Mechanisms, Risks, Diagnosis, and Defensive Practices
Cognitive Technology Team
Cognitive Technology Team
May 3, 2025 · Fundamentals

Understanding Java ThreadLocalMap: Structure, Operations, and Memory Management

This article explains the internal design of Java's ThreadLocalMap, covering its core Entry structure, hash table storage, linear probing for collision resolution, key operations (set, get, remove), memory‑leak scenarios, automatic cleanup mechanisms, and practical usage patterns such as thread‑context propagation and Android Looper.

ConcurrencyJavaMemoryManagement
0 likes · 10 min read
Understanding Java ThreadLocalMap: Structure, Operations, and Memory Management
Cognitive Technology Team
Cognitive Technology Team
May 3, 2025 · Backend Development

Understanding ThreadLocal: Core Principles, Use Cases, Pitfalls, and Best Practices

ThreadLocal provides per‑thread variable storage to achieve thread isolation, improving concurrency performance, and is essential for safe data handling in Java, but improper use can cause memory leaks, data contamination, and other issues; this article explains its internal mechanism, common scenarios, pitfalls, and best‑practice guidelines with code examples.

Best PracticesConcurrencyJava
0 likes · 19 min read
Understanding ThreadLocal: Core Principles, Use Cases, Pitfalls, and Best Practices
Deepin Linux
Deepin Linux
May 3, 2025 · Backend Development

Analyzing and Resolving Uninterruptible Thread States During System Suspend

This article examines why a thread may remain in an uninterruptible wake‑up state during system suspend, explains deadlock fundamentals, outlines thread lifecycle states, and provides practical debugging steps and mitigation strategies using Java concurrency tools and system monitoring.

ConcurrencyDeadlockJava
0 likes · 23 min read
Analyzing and Resolving Uninterruptible Thread States During System Suspend
Java Captain
Java Captain
May 2, 2025 · Fundamentals

Understanding Java Concurrency: Challenges and Solutions from Hardware to JVM

This article uses real‑world analogies to dissect the three core challenges of Java concurrency—ordering, visibility, and atomicity—and explains how hardware instructions, JVM mechanisms, and Java SDK tools such as locks, CAS, and waiting/notification utilities provide efficient solutions.

CASConcurrencyJVM
0 likes · 14 min read
Understanding Java Concurrency: Challenges and Solutions from Hardware to JVM
Architect
Architect
May 2, 2025 · Backend Development

Understanding and Implementing LMAX Disruptor in Java

This article introduces the high‑performance LMAX Disruptor library, explains its core concepts such as Ring Buffer, Sequence, Sequencer, and Wait Strategy, and provides a step‑by‑step Java demo with complete code to build a producer‑consumer message queue.

Backend DevelopmentConcurrencyDisruptor
0 likes · 11 min read
Understanding and Implementing LMAX Disruptor in Java
Cognitive Technology Team
Cognitive Technology Team
May 1, 2025 · Backend Development

10 Tips and Tricks for Using ExecutorService in Java

This article presents ten practical tips for Java developers on naming thread‑pool threads, dynamically changing thread names, safely shutting down executors, handling interruptions, bounding queue sizes, proper exception handling, monitoring wait times, preserving client stack traces, preferring CompletableFuture, and using SynchronousQueue with ThreadPoolExecutor.

Best PracticesConcurrencyExecutorService
0 likes · 15 min read
10 Tips and Tricks for Using ExecutorService in Java
Sohu Tech Products
Sohu Tech Products
Apr 29, 2025 · Backend Development

Mastering Java Concurrency: Deep Dive into Threads, Locks, and AQS

This comprehensive guide explores Java multithreading fundamentals, covering thread creation, lifecycle, synchronization challenges, context switching costs, deadlock detection, various lock mechanisms such as synchronized, ReentrantLock, ReadWriteLock, and the underlying AbstractQueuedSynchronizer architecture with practical code examples and performance tips.

AQSConcurrencyCondition
0 likes · 42 min read
Mastering Java Concurrency: Deep Dive into Threads, Locks, and AQS
Cognitive Technology Team
Cognitive Technology Team
Apr 29, 2025 · Backend Development

Common CompletableFuture Pitfalls and Best Practices in Java

This article examines the powerful Java CompletableFuture class, identifies frequent misuse pitfalls such as ignored exceptions, wrong thread‑pool choices, blocking callbacks, context loss, and overly fragmented chains, and provides concrete avoidance strategies and best‑practice recommendations for robust asynchronous programming.

Best PracticesCompletableFutureConcurrency
0 likes · 9 min read
Common CompletableFuture Pitfalls and Best Practices in Java
Selected Java Interview Questions
Selected Java Interview Questions
Apr 28, 2025 · Backend Development

Understanding Java Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison

This article introduces Java 21's virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic usage and Spring Boot integration with code examples, and compares their performance against traditional threads through practical experiments and additional optimization tips.

ConcurrencyPerformanceSpring Boot
0 likes · 7 min read
Understanding Java Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
Architecture Digest
Architecture Digest
Apr 27, 2025 · Backend Development

Using Java 21 Virtual Threads in Spring Boot: Basics, Performance Comparison, and Best Practices

This article introduces Java 21 virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed creation, shows how to enable them in Spring Boot with minimal configuration, compares performance against traditional threads, and provides additional Java performance optimization tips.

ConcurrencyJavaJava 21
0 likes · 6 min read
Using Java 21 Virtual Threads in Spring Boot: Basics, Performance Comparison, and Best Practices
Java Captain
Java Captain
Apr 27, 2025 · Backend Development

Understanding Java Executors Thread Pools: newCachedThreadPool, newScheduledThreadPool, newSingleThreadExecutor, newWorkStealingPool, and newFixedThreadPool

This article explains the five main thread‑pool types provided by Java's Executors class, detailing their constructors, underlying queue implementations, and default thread‑count behaviors, and notes why the default pools may not suit everyday development needs.

ConcurrencyExecutorServiceExecutors
0 likes · 4 min read
Understanding Java Executors Thread Pools: newCachedThreadPool, newScheduledThreadPool, newSingleThreadExecutor, newWorkStealingPool, and newFixedThreadPool
Java Backend Full-Stack
Java Backend Full-Stack
Apr 26, 2025 · Backend Development

Master ThreadLocal: Answer Interview Questions and Prevent OOM Leaks

This article explains ThreadLocal’s internal mechanism, why improper use can cause OutOfMemoryError in thread pools, demonstrates the issue with a Java example, and provides best‑practice guidance—especially calling remove()—to prevent memory leaks while preparing for interview questions.

ConcurrencyJavaOutOfMemoryError
0 likes · 11 min read
Master ThreadLocal: Answer Interview Questions and Prevent OOM Leaks
Java Tech Enthusiast
Java Tech Enthusiast
Apr 19, 2025 · Fundamentals

Understanding CPU Usage Spikes: Pipeline, Locks, and Optimization

The article explains how CPU pipelines, cache misses, branch‑prediction failures and lock contention cause non‑linear usage spikes, illustrates common pitfalls such as infinite loops, lock‑heavy spinning and catastrophic regex backtracking, and offers practical detection with perf and three rules—avoid busy‑waiting, use cache‑friendly layouts, and limit thread contention.

CPUConcurrencyOptimization
0 likes · 6 min read
Understanding CPU Usage Spikes: Pipeline, Locks, and Optimization
Python Programming Learning Circle
Python Programming Learning Circle
Apr 17, 2025 · Fundamentals

Understanding Processes, Threads, and the GIL in Python

This article explains the concepts of processes and threads, describes Python's Global Interpreter Lock (GIL) and its impact on concurrency, compares the low‑level _thread module with the higher‑level threading module, and provides example code illustrating thread creation, synchronization with locks, and common pitfalls.

ConcurrencyGILLock
0 likes · 5 min read
Understanding Processes, Threads, and the GIL in Python
FunTester
FunTester
Apr 16, 2025 · Backend Development

Mastering Go: A Curated Collection of Common Pitfalls and How to Avoid Them

This curated collection gathers eleven in‑depth articles covering the most frequent Go programming mistakes—from optimization and unit testing to concurrency, error handling, and code organization—providing practical examples, dates, and direct links for developers seeking to improve code quality and avoid common pitfalls.

Backend DevelopmentConcurrencyError handling
0 likes · 3 min read
Mastering Go: A Curated Collection of Common Pitfalls and How to Avoid Them
FunTester
FunTester
Apr 14, 2025 · Backend Development

Common Mistakes in Go Unit Testing and How to Avoid Them

This article examines nine frequent errors developers make when writing Go unit tests—such as improper test classification, neglecting the race detector, ignoring parallel and shuffle flags, avoiding table‑driven tests, using sleep, mishandling time APIs, overlooking httptest/iotest, misusing benchmarks, and skipping fuzz testing—providing analysis and concrete code‑based solutions to improve test reliability and efficiency.

ConcurrencyUnit Testingbenchmarking
0 likes · 11 min read
Common Mistakes in Go Unit Testing and How to Avoid Them
Java Tech Enthusiast
Java Tech Enthusiast
Apr 12, 2025 · Backend Development

Understanding AtomicLong vs LongAdder in Java Concurrency

In high‑concurrency Java applications, LongAdder—introduced in JDK 8 and using partitioned cells to reduce contention—generally outperforms the single‑value AtomicLong, which relies on CAS and can cause CPU waste under heavy load, so Alibaba advises LongAdder for scalable distributed counters, though memory usage and workload specifics must be considered.

CASConcurrencyJava
0 likes · 7 min read
Understanding AtomicLong vs LongAdder in Java Concurrency
Cognitive Technology Team
Cognitive Technology Team
Apr 12, 2025 · Backend Development

Using CompletableFuture with Streams for Parallel Execution in Java

The article explains how to correctly combine Java's CompletableFuture with Stream API to achieve true asynchronous parallelism, highlights common pitfalls that lead to sequential execution, and provides the proper pattern of creating a CompletableFuture stream followed by a terminal operation.

CompletableFutureConcurrencyJava
0 likes · 3 min read
Using CompletableFuture with Streams for Parallel Execution in Java
Cognitive Technology Team
Cognitive Technology Team
Apr 11, 2025 · Backend Development

Understanding Netty 4 Thread Model: Master‑Worker Multithreading and EventLoop Design

Netty 4 employs a global multithreaded, locally single‑threaded (event‑loop) architecture where a boss thread pool accepts connections and delegates them to worker thread pools, each containing NioEventLoop instances with selectors, task queues, and pipelines, ensuring lock‑free, ordered processing while avoiding thread blocking.

ConcurrencyEventLoopJava
0 likes · 5 min read
Understanding Netty 4 Thread Model: Master‑Worker Multithreading and EventLoop Design
Ma Wei Says
Ma Wei Says
Apr 5, 2025 · Backend Development

Ensuring Accurate Inventory Deduction in High‑Concurrency Sales with Redis

This article explains why simple GET‑modify‑SET inventory updates cause overselling in flash‑sale spikes and presents several Redis‑based solutions—including Lua scripts, WATCH‑based optimistic locks, distributed SETNX locks, and asynchronous queue processing—detailing their implementation, advantages, and trade‑offs.

ConcurrencyDistributed LockInventory
0 likes · 8 min read
Ensuring Accurate Inventory Deduction in High‑Concurrency Sales with Redis
21CTO
21CTO
Apr 3, 2025 · Artificial Intelligence

Can Go Outperform Python in Machine Learning? Discover Its Hidden Advantages

While Python dominates the machine learning ecosystem, Go offers compelling performance, concurrency, and static typing advantages, making it a strong contender for high‑throughput prediction services, large data pipelines, resource‑constrained environments, and custom ML components, especially when teams already leverage Go in production.

ConcurrencyML LibrariesMachine Learning
0 likes · 13 min read
Can Go Outperform Python in Machine Learning? Discover Its Hidden Advantages
Code Ape Tech Column
Code Ape Tech Column
Apr 3, 2025 · Backend Development

Implementing a FIFO Export Queue for Large Data Exports in a Spring Backend

The article describes a backend solution that uses a fixed‑size FIFO queue to throttle concurrent MySQL export operations, provides Java implementations of the ExportQueue, an abstract EasyExcel‑based exporter, a concrete ExportImpl service, and a test controller, and discusses remaining challenges and alternative approaches.

ConcurrencyEasyExcelExport
0 likes · 10 min read
Implementing a FIFO Export Queue for Large Data Exports in a Spring Backend
DaTaobao Tech
DaTaobao Tech
Apr 2, 2025 · Backend Development

Understanding Java Virtual Threads: From Traditional Thread Models to Stackful Coroutines

The article traces Java’s concurrency evolution from heavyweight thread‑per‑request and complex reactive models to JDK 21’s virtual threads, which act as stack‑ful coroutines offering lightweight, heap‑allocated threads, full stack traces, and blocking‑I/O compatibility while preserving the familiar thread API.

ConcurrencyCoroutinesJDK21
0 likes · 24 min read
Understanding Java Virtual Threads: From Traditional Thread Models to Stackful Coroutines
Architect's Guide
Architect's Guide
Apr 2, 2025 · Backend Development

Implementing High‑Concurrency SecKill (Flash Sale) in SpringBoot: Locking, Transaction, and Queue Strategies

This article demonstrates how to simulate a high‑concurrency flash‑sale scenario with SpringBoot and MySQL, analyzes why naive lock‑and‑transaction code causes overselling, and presents six refined solutions—including early locking, AOP, pessimistic and optimistic database locks, blocking queues, and Disruptor queues—along with performance observations and a concise summary.

ConcurrencyLockQueue
0 likes · 22 min read
Implementing High‑Concurrency SecKill (Flash Sale) in SpringBoot: Locking, Transaction, and Queue Strategies
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 1, 2025 · Fundamentals

Why Do Deadlocks Happen and How Can You Prevent Them?

This article explains what deadlocks are, outlines the four classic conditions that cause them, provides Java thread and MySQL transaction examples, and offers practical solutions such as consistent lock ordering, timeout settings, batch updates, and shortening transaction duration to prevent deadlocks.

ConcurrencyDatabaseDeadlock
0 likes · 5 min read
Why Do Deadlocks Happen and How Can You Prevent Them?
Java Backend Technology
Java Backend Technology
Mar 31, 2025 · Backend Development

Boost Database Query Performance with Spring AOP: Parallel IN Splitting Technique

This article explains how to improve slow PostgreSQL IN queries caused by large parameter lists by defining a custom Spring AOP annotation that automatically splits the parameter set, runs the sub‑queries concurrently in multiple threads, and merges the results back together, complete with code examples and usage guidelines.

AOPAnnotationConcurrency
0 likes · 11 min read
Boost Database Query Performance with Spring AOP: Parallel IN Splitting Technique
FunTester
FunTester
Mar 29, 2025 · Backend Development

7 Common Go Concurrency Pitfalls and How to Avoid Them

This article examines frequent mistakes developers make when writing concurrent Go programs—such as misusing context, leaking goroutines, mishandling channels, and causing data races—and provides concrete code examples, impact analyses, and best‑practice recommendations to write safer, more efficient Go concurrency code.

Best PracticesConcurrencyContext
0 likes · 9 min read
7 Common Go Concurrency Pitfalls and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Mar 28, 2025 · Backend Development

Unlocking Java’s Synchronized: How the JVM Implements Locks

This article explains the low‑level implementation of Java's synchronized keyword, covering monitorenter/monitorexit bytecode, object header structures, Mark Word layouts, and the evolution from heavyweight locks to biased and lightweight locks with lock‑upgrade mechanisms.

ConcurrencyJVMJava
0 likes · 11 min read
Unlocking Java’s Synchronized: How the JVM Implements Locks
JD Cloud Developers
JD Cloud Developers
Mar 27, 2025 · Backend Development

How Caffeine’s ReadBuffer Works: Deep Dive into getIfPresent and Eviction Mechanics

This article explains the inner workings of Caffeine's getIfPresent method, the design of its MPSC ReadBuffer and WriteBuffer, the maintenance cycle, eviction strategies, and the TinyLFU algorithm, providing Java code examples and diagrams to illustrate how caching decisions are made in high‑concurrency environments.

CaffeineConcurrencyJava
0 likes · 31 min read
How Caffeine’s ReadBuffer Works: Deep Dive into getIfPresent and Eviction Mechanics
Deepin Linux
Deepin Linux
Mar 27, 2025 · Fundamentals

Understanding Linux Memory Barriers: Concepts, Types, and Implementation

This article explains why modern multi‑core CPUs need memory barriers, describes the different kinds of barriers (full, read, write), shows how they are implemented in the Linux kernel and hardware, and illustrates their use in multithreaded and cache‑coherent programming.

CPU architectureConcurrencycache coherence
0 likes · 41 min read
Understanding Linux Memory Barriers: Concepts, Types, and Implementation
Cognitive Technology Team
Cognitive Technology Team
Mar 25, 2025 · Fundamentals

Understanding the Java Memory Model and Its Interaction with Hardware Memory Architecture

This article explains how the Java Memory Model defines the interaction between threads, thread stacks, and the heap, illustrates these concepts with diagrams and example code, and discusses how modern hardware memory architecture, caches, and CPU registers affect visibility and race conditions in concurrent Java programs.

ConcurrencyJavaMemory Model
0 likes · 11 min read
Understanding the Java Memory Model and Its Interaction with Hardware Memory Architecture
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 24, 2025 · Fundamentals

What’s New in Java 24? Explore 8 Game‑Changing Preview Features

This article announces the updated Spring Boot 3 case‑study e‑book with 108 examples and then dives into Java 24’s latest preview features—enhanced pattern matching, flexible constructors, module import, single‑file source, custom stream collectors, Vector API, scoped values, and structured concurrency—complete with code snippets and links.

ConcurrencyJavaPreviewFeatures
0 likes · 10 min read
What’s New in Java 24? Explore 8 Game‑Changing Preview Features
The Dominant Programmer
The Dominant Programmer
Mar 22, 2025 · Backend Development

Java Performance Optimization: From Basics to Mastery, Techniques to Make Your Code Fly

This article explains why Java performance matters, outlines fundamental principles, and provides concrete code, memory, concurrency, I/O, and database optimization techniques, along with profiling tools, common pitfalls, real‑world case studies, and emerging trends to help developers build faster, more stable applications.

ConcurrencyDatabase TuningJava
0 likes · 8 min read
Java Performance Optimization: From Basics to Mastery, Techniques to Make Your Code Fly
Java Captain
Java Captain
Mar 21, 2025 · Backend Development

Request Merging and Batch Processing in Java Spring Boot to Reduce Database Connections

This article explains how to merge multiple user‑detail requests into a single database query using a blocking queue, scheduled thread pool, and CompletableFuture in Spring Boot, providing code examples, a high‑concurrency test, and discussion of trade‑offs such as added latency and timeout handling.

CompletableFutureConcurrencyJava
0 likes · 13 min read
Request Merging and Batch Processing in Java Spring Boot to Reduce Database Connections
JD Cloud Developers
JD Cloud Developers
Mar 21, 2025 · Fundamentals

Master Go Basics: From Variables to Concurrency in One Guide

This article introduces Go language fundamentals for developers familiar with other object‑oriented languages, covering variable and constant declarations, zero values, methods, structs, interfaces, slices, maps, goroutines, channels, mutexes, and error handling with clear code examples and explanations.

BasicsConcurrencygo
0 likes · 25 min read
Master Go Basics: From Variables to Concurrency in One Guide
Java Backend Full-Stack
Java Backend Full-Stack
Mar 21, 2025 · Interview Experience

Only Four Interviews After a Layoff: My Takeaways

After being laid off, the author interviewed only four companies, detailing each interview’s technical questions—from Spring Cloud and MySQL to concurrency and design patterns—and reflecting on the interviewers’ professionalism, the relevance of his skill set, and the importance of matching resumes to job requirements.

ConcurrencyJavaMySQL
0 likes · 6 min read
Only Four Interviews After a Layoff: My Takeaways