BestHub
Sign in
Tagged articles

concurrency

2269 articles · Page 4 of 23
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 18, 2025 · Backend Development

Master Java Concurrency: Choose ReentrantLock, ReadWriteLock, StampedLock, or Semaphore

This article explores Java’s advanced lock mechanisms—ReentrantLock, ReentrantReadWriteLock, StampedLock, and Semaphore—detailing their core features, practical code examples, and ideal usage scenarios, helping developers decide which synchronization tool best fits their performance and concurrency requirements.

JavaLocksReadWriteLock
0 likes · 9 min read
Master Java Concurrency: Choose ReentrantLock, ReadWriteLock, StampedLock, or Semaphore
ITPUB
ITPUB
Oct 17, 2025 · Databases

Why Some Companies Switch MySQL from Repeatable Read to Read Committed

The article explains MySQL's default Repeatable Read isolation level, how its lock and binlog mechanisms affect consistency and replication, and why many high‑traffic internet firms change to Read Committed to boost concurrency and reduce deadlocks despite the need to handle phantom reads.

Isolation LevelMySQLRead Committed
0 likes · 8 min read
Why Some Companies Switch MySQL from Repeatable Read to Read Committed
Data STUDIO
Data STUDIO
Oct 17, 2025 · Fundamentals

Python 3.14 (π) Released: Cool New Features You Should Try

Python 3.14, released on October 7 2025, brings a revamped REPL with real‑time syntax highlighting and smarter auto‑completion, new syntax such as t‑strings and optional parentheses in exception handling, lazy‑evaluated type annotations, sub‑interpreter parallelism, free‑threading, an experimental JIT, tail‑call interpreter support, and an incremental garbage collector, all of which improve developer ergonomics and performance.

PerformancePythonPython 3.14
0 likes · 44 min read
Python 3.14 (π) Released: Cool New Features You Should Try
macrozheng
macrozheng
Oct 15, 2025 · Databases

Why PostgreSQL Beats MySQL in High‑Performance Scenarios

This article examines why PostgreSQL is often a better choice than MySQL for high‑performance workloads, covering architectural differences, indexing capabilities, query optimization, data types, concurrency control, benchmark results, and migration considerations, and provides code examples to illustrate each point.

MySQLPostgreSQLconcurrency
0 likes · 13 min read
Why PostgreSQL Beats MySQL in High‑Performance Scenarios
DeWu Technology
DeWu Technology
Oct 13, 2025 · Backend Development

TTL Agent Pitfalls: Memory Leaks & CPU Spikes in Java – Cases & Fixes

This article explains how the Transmittable ThreadLocal (TTL) Java agent works, why improper usage can cause context contamination, memory leaks, and CPU spikes, and provides real production cases, code examples, and practical recommendations to avoid these pitfalls.

Java AgentMemory LeakPerformance
0 likes · 15 min read
TTL Agent Pitfalls: Memory Leaks & CPU Spikes in Java – Cases & Fixes
Code Wrench
Code Wrench
Oct 11, 2025 · Backend Development

Master Go Concurrency with sync: Mutex, RWMutex, WaitGroup, Once, Cond & Pool

Learn how Go's sync package provides essential concurrency primitives—Mutex, RWMutex, WaitGroup, Once, Cond, and Pool—through clear examples and best‑practice patterns that prevent data races, deadlocks, and performance pitfalls, enabling safe, elegant, and efficient goroutine coordination.

GoMutexOnce
0 likes · 7 min read
Master Go Concurrency with sync: Mutex, RWMutex, WaitGroup, Once, Cond & Pool
Code Mala Tang
Code Mala Tang
Oct 10, 2025 · Fundamentals

Why async/await Doesn’t Give You Concurrency – And How to Make It Work

Although Python’s async/await syntax lets you pause and resume functions, it alone doesn’t run tasks concurrently; you must explicitly schedule coroutines with tools like asyncio.create_task(), gather(), or TaskGroup, and understand when to use sequential versus concurrent execution to avoid common pitfalls.

async/awaitasyncioconcurrency
0 likes · 10 min read
Why async/await Doesn’t Give You Concurrency – And How to Make It Work
BirdNest Tech Talk
BirdNest Tech Talk
Oct 9, 2025 · Fundamentals

What’s New in Go’s sync Package? A Deep Dive into APIs, Performance, and Safety

Over the past two years, Go’s sync and sync/atomic packages have introduced new APIs like WaitGroup.Go, enhanced Map methods, modernized atomic types, restructured internal implementations, and added developer‑friendly safeguards such as noCopy, all aimed at improving usability, safety, and performance for concurrent Go programs.

APIGoPerformance
0 likes · 12 min read
What’s New in Go’s sync Package? A Deep Dive into APIs, Performance, and Safety
Su San Talks Tech
Su San Talks Tech
Oct 9, 2025 · Databases

Why PostgreSQL Beats MySQL in High‑Performance Scenarios

This article compares PostgreSQL and MySQL across architecture, indexing, complex query optimization, data‑type support, transaction handling, and real‑world benchmark results, showing why PostgreSQL is generally the better choice for high‑concurrency, data‑intensive applications.

MySQLPostgreSQLconcurrency
0 likes · 13 min read
Why PostgreSQL Beats MySQL in High‑Performance Scenarios
Rust High-Frequency Quantitative Trading
Rust High-Frequency Quantitative Trading
Oct 3, 2025 · Backend Development

Uncovering Rust’s Hidden Concurrency Powerhouse: park and unpark

This article explains Rust’s std::thread::park/unpark primitives, demonstrates their lost‑wake‑up pitfall, introduces crossbeam’s Parker/Unparker with a token‑based memory feature that eliminates the issue, and provides multiple code examples and usage guidelines for high‑performance thread synchronization.

CrossbeamParkerRust
0 likes · 17 min read
Uncovering Rust’s Hidden Concurrency Powerhouse: park and unpark
Python Programming Learning Circle
Python Programming Learning Circle
Sep 30, 2025 · Fundamentals

How to Supercharge Your Python Code: Proven Performance Optimization Techniques

This comprehensive guide walks you through Python performance optimization, covering profiling, algorithmic improvements, data‑structure choices, code‑level tricks, concurrency, memory management, third‑party libraries and a practical checklist to ensure your programs run faster and more efficiently.

Performance OptimizationProfilingPython
0 likes · 18 min read
How to Supercharge Your Python Code: Proven Performance Optimization Techniques
Deepin Linux
Deepin Linux
Sep 27, 2025 · Fundamentals

Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency

Lock‑free queues replace costly mutexes with atomic operations, eliminating lock contention, deadlocks, and scalability limits, and this article explains their principles, classic implementations, C++ code examples, performance testing, and real‑world applications such as game engines and high‑throughput servers.

C++CASLock-Free
0 likes · 38 min read
Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency
php Courses
php Courses
Sep 23, 2025 · Backend Development

Coroutines vs Fibers in PHP: Which Concurrency Model Wins?

This article explains the fundamental differences between coroutines and fibers in modern PHP, covering their concepts, implementation layers, scheduling, stack management, integration, and practical code examples, helping developers choose the right concurrency approach for high‑performance applications.

FiberPHPasynchronous
0 likes · 10 min read
Coroutines vs Fibers in PHP: Which Concurrency Model Wins?
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 23, 2025 · Backend Development

Spring Boot 3 Concurrency: Locks, Optimistic & Pessimistic Updates

This article explains common problems of concurrent database updates in Spring Boot 3 and demonstrates five practical solutions—including database locks, optimistic and pessimistic locking, transaction isolation levels, and application‑level locks—accompanied by complete code examples and test results.

Optimistic LockPessimistic LockSpring Boot
0 likes · 10 min read
Spring Boot 3 Concurrency: Locks, Optimistic & Pessimistic Updates
Java Architecture Diary
Java Architecture Diary
Sep 22, 2025 · Backend Development

Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps

Java 25 introduces major upgrades to virtual threads, offering dramatically lower memory usage, near‑zero creation cost, and efficient I/O handling, and this guide explains their advantages, compares them with traditional thread pools and @Async, provides Spring Boot 3.5 configuration examples, and highlights pitfalls and best‑practice tips.

SpringThread PoolVirtual Threads
0 likes · 8 min read
Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps
Java Architecture Diary
Java Architecture Diary
Sep 19, 2025 · Backend Development

Why ScopedValues Outperform ThreadLocal for Safe Context Management in Java

ScopedValues provide a more efficient, memory‑safe, and virtual‑thread‑friendly alternative to ThreadLocal for managing per‑thread context in Java, eliminating manual cleanup, reducing memory leaks, and simplifying context propagation across threads, as demonstrated by code examples and performance benchmarks.

PerformanceScopedValuesThreadLocal
0 likes · 6 min read
Why ScopedValues Outperform ThreadLocal for Safe Context Management in Java
FunTester
FunTester
Sep 17, 2025 · Backend Development

20 Proven Go Performance Optimization Techniques Every Backend Engineer Should Know

This article presents 20 production‑validated Go performance optimization tips, covering profiling, benchmarking, memory management, concurrency, and build‑time strategies, with clear principles and practical code examples to help engineers systematically improve Go application performance.

MemoryOptimizationProfiling
0 likes · 24 min read
20 Proven Go Performance Optimization Techniques Every Backend Engineer Should Know
Java Architecture Diary
Java Architecture Diary
Sep 17, 2025 · Fundamentals

What’s New in Java 25? Explore the Game‑Changing Features and Performance Boosts

Java 25, released on September 16 2025 as the next long‑term support version, introduces a suite of language, runtime, and security enhancements—including compact source files, pattern matching for primitive types, scoped values, a new Shenandoah GC, and a powerful vector API—aimed at improving developer productivity, application performance, and sustainability.

JEPVector APIconcurrency
0 likes · 11 min read
What’s New in Java 25? Explore the Game‑Changing Features and Performance Boosts
php Courses
php Courses
Sep 16, 2025 · Fundamentals

Mastering std::mutex in C++: Prevent Data Races with Simple Examples

Learn why mutexes are essential for safe multithreaded C++ programming, explore the basic std::mutex API, see practical code examples, and discover advanced lock management with std::lock_guard and other mutex types to avoid data races and deadlocks.

C++Mutexconcurrency
0 likes · 9 min read
Mastering std::mutex in C++: Prevent Data Races with Simple Examples
JavaScript
JavaScript
Sep 16, 2025 · Frontend Development

Boost JavaScript Async Performance: Up to 80% Faster Than async/await

This article explains why async/await can cause performance bottlenecks in JavaScript and introduces optimized Promise‑based techniques—such as chain optimization, Promise.all parallelism, batch processing, and pooling—that can improve async execution speed by up to 80% in specific scenarios.

JavaScriptParallelismPerformance Optimization
0 likes · 4 min read
Boost JavaScript Async Performance: Up to 80% Faster Than async/await
Python Programming Learning Circle
Python Programming Learning Circle
Sep 15, 2025 · Fundamentals

Processes vs Threads: Key Differences, Pros, Cons, and When to Use Them

This article explains the fundamental concepts of processes and threads, compares their definitions, lifecycles, advantages and disadvantages, and provides practical guidelines for choosing between multi‑processing and multi‑threading based on factors such as resource usage, performance, reliability, and application requirements.

concurrencymultithreadingprocess
0 likes · 19 min read
Processes vs Threads: Key Differences, Pros, Cons, and When to Use Them
php Courses
php Courses
Sep 15, 2025 · Fundamentals

Mastering std::thread: Create, Manage, and Synchronize C++ Threads

This tutorial explains the fundamentals of C++11 std::thread, covering thread creation with functions and lambdas, the use of join() and detach(), argument passing techniques, and essential best practices for safe and portable multithreaded programming.

C++JOINconcurrency
0 likes · 10 min read
Mastering std::thread: Create, Manage, and Synchronize C++ Threads
Raymond Ops
Raymond Ops
Sep 14, 2025 · Operations

Mastering Concurrency: Optimize Nginx, HAProxy & Keepalived for High‑Performance Servers

This article explains the fundamentals of concurrency, distinguishes connections from requests, shows how to calculate and tune maximum concurrent connections for Nginx and HAProxy, covers system resource limits, demonstrates real‑time monitoring with stub_status, and provides practical load‑testing and Prometheus monitoring guidance.

AB TestingHAProxyKeepalived
0 likes · 15 min read
Mastering Concurrency: Optimize Nginx, HAProxy & Keepalived for High‑Performance Servers
Go Programming World
Go Programming World
Sep 7, 2025 · Backend Development

Mastering Go’s sync.Pool: Deep Dive into Object Pooling and Performance

This article explains how Go's sync.Pool works, shows practical usage examples, walks through its source code, and details the underlying implementation, including Put/Get methods, pinning, and garbage‑collection interaction, helping developers efficiently reuse objects in concurrent programs.

Goconcurrencyobject-pooling
0 likes · 20 min read
Mastering Go’s sync.Pool: Deep Dive into Object Pooling and Performance
Code Wrench
Code Wrench
Sep 7, 2025 · Backend Development

Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns

Discover how Go transforms massive concurrency challenges into elegant communication using goroutines, channels, select, and the GMP scheduler, and learn practical patterns such as producer-consumer, pub/sub, worker pools, pipelines, and a prime sieve, complete with runnable code snippets and engineering tips for robust backend systems.

Backend DevelopmentGoParallel Programming
0 likes · 12 min read
Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns
Go Programming World
Go Programming World
Sep 5, 2025 · Backend Development

How to Test Concurrent Go Code with the New testing/synctest Package

Go’s built‑in concurrency primitives make parallel programming easy, but testing such code is tricky; this article explains the experimental testing/synctest package introduced in Go 1.24/1.25, shows how to rewrite flaky, slow tests into fast, reliable ones, and demonstrates its use with real‑world examples.

Goconcurrencygoroutine
0 likes · 15 min read
How to Test Concurrent Go Code with the New testing/synctest Package
Code Wrench
Code Wrench
Sep 3, 2025 · Backend Development

Master Go: From Beginner Basics to Advanced Concurrency and Runtime

This guide outlines a structured roadmap for learning Go, covering entry‑level syntax, essential concurrency primitives, project‑based practice, engineering best‑practices, and deep runtime and ecosystem exploration, with recommended resources and practical project ideas for each stage.

GoLearning Pathconcurrency
0 likes · 5 min read
Master Go: From Beginner Basics to Advanced Concurrency and Runtime
Tencent Technical Engineering
Tencent Technical Engineering
Sep 1, 2025 · Backend Development

Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance

This article explains Go's memory management mechanisms—including GC fundamentals, stop‑the‑world marking, tri‑color marking with write barriers, hybrid write barriers, and practical optimization techniques such as reducing heap allocations, using caches, concurrency patterns, and profiling tools—to help developers identify and eliminate performance bottlenecks.

GoPerformance OptimizationProfiling
0 likes · 20 min read
Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 29, 2025 · Databases

Why MySQL Returns Old Values After Update: Inside InnoDB Snapshot Reads

This article investigates a puzzling MySQL behavior where a row updated within a transaction sometimes returns its previous value, explains the role of InnoDB's snapshot reads and ReadView, reproduces the issue, and offers practical ways to prevent the “update disappearance” scenario.

InnoDBMySQLUpdate Anomaly
0 likes · 18 min read
Why MySQL Returns Old Values After Update: Inside InnoDB Snapshot Reads
Java Tech Enthusiast
Java Tech Enthusiast
Aug 24, 2025 · Backend Development

Master Java Interview Essentials: OOP, Spring Beans, Redis, DB Indexes & More

This article compiles a comprehensive Java interview guide covering object‑oriented fundamentals, method overloading vs overriding, core collection implementations, Spring bean lifecycle, composite index usage, process/thread/coroutine distinctions, Linux IPC methods, design‑pattern principles, Redis roles and data types, relational vs NoSQL trade‑offs, QR‑code login design, and a classic 15‑minute brain teaser.

Design PatternsRedisSpring
0 likes · 17 min read
Master Java Interview Essentials: OOP, Spring Beans, Redis, DB Indexes & More
AndroidPub
AndroidPub
Aug 20, 2025 · Fundamentals

Why Blocking vs Non‑Blocking in Kotlin Coroutines Matters: Live Experiments

This article demystifies the difference between blocking and non‑blocking coroutine work in Kotlin by providing runnable examples, measuring sequential, concurrent, and asynchronous execution, and revealing how thread usage, jobs, and dispatchers affect performance and true parallelism.

CoroutinesKotlinasynchronous
0 likes · 10 min read
Why Blocking vs Non‑Blocking in Kotlin Coroutines Matters: Live Experiments
Tech Freedom Circle
Tech Freedom Circle
Aug 18, 2025 · Interview Experience

How to Hand‑Write a Simple AbstractQueuedSynchronizer (AQS) for High‑Pay Java Interviews

This article walks through the fundamentals of Java's AbstractQueuedSynchronizer, covering lock‑queue relationships, CLH lock internals, dummy head nodes, state management, and step‑by‑step implementations of acquire, addWaiter, acquireQueued, shouldParkAfterFailedAcquire, and release methods, complete with runnable example code.

AQSAbstractQueuedSynchronizerJava
0 likes · 29 min read
How to Hand‑Write a Simple AbstractQueuedSynchronizer (AQS) for High‑Pay Java Interviews
NetEase LeiHuo Testing Center
NetEase LeiHuo Testing Center
Aug 15, 2025 · Operations

How to Spot Performance Issues Early in Functional Testing

This article explains how integrating concurrency checks into functional testing can uncover performance bottlenecks before load testing, using real game scenarios such as team creation overload, redemption code over‑issuance, and Redis limits, and outlines practical strategies like client behavior analysis, throttling, and early API stress validation to reduce later testing effort.

Load Testingconcurrencyfunctional testing
0 likes · 15 min read
How to Spot Performance Issues Early in Functional Testing
Tech Freedom Circle
Tech Freedom Circle
Aug 14, 2025 · Backend Development

10 Proven Techniques to Optimize API Latency from 11 s to 170 ms – A Meituan Interview Case

The article presents a step‑by‑step analysis of how to shrink a 11‑second API response to 170 ms by applying batch database writes, Redis pipeline, asynchronous processing, thread‑pool design, local‑memory buffering, MQ integration, and other performance‑tuning patterns, backed by real‑world benchmarks and code samples.

@AsyncAPI optimizationJava
0 likes · 48 min read
10 Proven Techniques to Optimize API Latency from 11 s to 170 ms – A Meituan Interview Case
ITPUB
ITPUB
Aug 12, 2025 · Backend Development

Why Microsoft Rewrote TypeScript in Go for a 10× Speed Boost

Microsoft’s TypeScript team migrated the compiler from JavaScript to Go, achieving up to ten‑fold performance gains, halving memory usage, and enabling shared‑memory concurrency, while preserving compatibility and exploring future AI‑driven code analysis and language‑service APIs.

GoLanguage DesignPerformance
0 likes · 35 min read
Why Microsoft Rewrote TypeScript in Go for a 10× Speed Boost
Liangxu Linux
Liangxu Linux
Aug 5, 2025 · Fundamentals

Master C++11 Condition Variables: From Basics to Thread‑Pool Mastery

This article explains what C++11 condition variables are, why they are essential for efficient multithreading, shows their basic usage with std::condition_variable and std::mutex, walks through a producer‑consumer example, demonstrates a thread‑pool implementation, and lists crucial best‑practice tips.

C++C++11Thread Pool
0 likes · 15 min read
Master C++11 Condition Variables: From Basics to Thread‑Pool Mastery
dbaplus Community
dbaplus Community
Jul 29, 2025 · Backend Development

9 Proven Techniques to Supercharge Service Performance in Backend Systems

Learn nine practical methods—caching, parallel processing, batch handling, compression, lock‑free design, sequential writes, sharding, pooling, and asynchronous execution—to dramatically improve backend service latency and throughput, illustrated with Redis, MySQL, Kafka, and Go examples, and backed by real‑world performance gains.

Performancecachingconcurrency
0 likes · 29 min read
9 Proven Techniques to Supercharge Service Performance in Backend Systems
Architect's Guide
Architect's Guide
Jul 24, 2025 · Backend Development

7 Proven Strategies to Prevent Overselling in High‑Concurrency Flash Sales (SpringBoot)

This article explores high‑concurrency flash‑sale scenarios, demonstrates why naïve @Transactional and lock usage can still cause overselling, and presents seven concrete implementations—including improved lock, AOP lock, two pessimistic‑lock variants, optimistic lock, a blocking queue, and a Disruptor queue—complete with SpringBoot code, JMeter testing results, and performance analysis.

SpringBootconcurrencydistributed systems
0 likes · 23 min read
7 Proven Strategies to Prevent Overselling in High‑Concurrency Flash Sales (SpringBoot)
Go Development Architecture Practice
Go Development Architecture Practice
Jul 23, 2025 · Backend Development

Scaling Go Backend: From Simple Goroutine to Job/Worker Pools

This article walks through three Go server‑side scaling techniques—starting a goroutine per request, using a buffered channel queue, and implementing a full job/worker pool with separate task and worker channels—complete with code examples and practical considerations for high‑traffic applications.

BackendWorker Poolchannel
0 likes · 9 min read
Scaling Go Backend: From Simple Goroutine to Job/Worker Pools
Cognitive Technology Team
Cognitive Technology Team
Jul 21, 2025 · Fundamentals

Java Happens‑Before Explained: Volatile, Synchronized & Instruction Reordering

This article explains Java’s happens‑before guarantees, covering instruction reordering, the visibility guarantees of volatile variables and synchronized blocks, and demonstrates how improper reordering can cause stale data or wasted resources through detailed code examples such as FrameExchanger and ValueExchanger.

Javaconcurrencyinstruction reordering
0 likes · 17 min read
Java Happens‑Before Explained: Volatile, Synchronized & Instruction Reordering
Cognitive Technology Team
Cognitive Technology Team
Jul 20, 2025 · Fundamentals

Unlock Java’s Memory Model: How Threads See Shared Data

This article explains the Java Memory Model, how the JVM organizes memory into thread stacks and heap, how threads interact with shared variables, the impact of hardware memory architecture, and practical techniques like volatile and synchronized to ensure visibility and avoid race conditions.

Javaconcurrencymemory model
0 likes · 14 min read
Unlock Java’s Memory Model: How Threads See Shared Data
Cognitive Technology Team
Cognitive Technology Team
Jul 20, 2025 · Fundamentals

How False Sharing Slows Java Programs and How to Eliminate It

This article explains what false sharing is in Java, how cache lines and cache‑line invalidation cause performance penalties, and provides concrete code examples and @Contended annotation techniques to detect and fix false sharing for faster multithreaded applications.

ContendedFalse sharingJava
0 likes · 10 min read
How False Sharing Slows Java Programs and How to Eliminate It
JavaScript
JavaScript
Jul 18, 2025 · Frontend Development

Why Does async/await Appear to Block Page Rendering? The Real Reason Explained

This article explains why using async/await inside a loop can make a page seem frozen, clarifies that await itself does not block the main thread, and shows how to replace serial awaits with Promise.all and other concurrency tools for truly non‑blocking UI updates.

JavaScriptPromiseasync/await
0 likes · 8 min read
Why Does async/await Appear to Block Page Rendering? The Real Reason Explained
FunTester
FunTester
Jul 15, 2025 · Backend Development

How to Use JMH for Precise Java Microbenchmarking and Performance Optimization

This article explains microbenchmarking concepts, demonstrates how to use the Java Microbenchmark Harness (JMH) to accurately measure and compare the performance of specific code snippets such as synchronized methods, and provides practical guidance for integrating JMH into Java projects for reliable performance testing and regression analysis.

JMHJavaMicrobenchmarking
0 likes · 11 min read
How to Use JMH for Precise Java Microbenchmarking and Performance Optimization
Su San Talks Tech
Su San Talks Tech
Jul 15, 2025 · Databases

Unlock MySQL Performance: 8 Lock Types, Deadlock Solutions, and Optimization Tips

This article explains MySQL's eight lock mechanisms, their purposes and classifications, demonstrates row‑level, gap, next‑key, table and metadata locks with code examples, discusses deadlock scenarios and detection, and provides practical monitoring and optimization strategies to improve concurrency and reliability.

MySQLconcurrencydatabase optimization
0 likes · 10 min read
Unlock MySQL Performance: 8 Lock Types, Deadlock Solutions, and Optimization Tips
FunTester
FunTester
Jul 13, 2025 · Backend Development

Master Go Concurrency: Goroutines, Channels, and Real-World Examples

Learn how Go’s built‑in concurrency model using goroutines and channels can transform sequential code into responsive, high‑performance applications, with clear explanations of concurrency vs parallelism, practical code samples, synchronization techniques, and best practices for building scalable web servers.

MutexParallelismchannel
0 likes · 10 min read
Master Go Concurrency: Goroutines, Channels, and Real-World Examples
Programmer Null's Self-Cultivation
Programmer Null's Self-Cultivation
Jul 13, 2025 · Backend Development

Unlocking the Secrets of Java’s ConcurrentHashMap: From JDK 7 to JDK 8

This article provides a comprehensive, step‑by‑step analysis of Java's ConcurrentHashMap, covering its evolution from JDK 7’s segment‑lock design to JDK 8’s bucket‑level CAS and synchronized approach, complete with macro diagrams, microscopic source‑code walkthroughs, hash calculations, resizing mechanisms, and practical usage tips.

ConcurrentHashMapHashMapJDK7
0 likes · 16 min read
Unlocking the Secrets of Java’s ConcurrentHashMap: From JDK 7 to JDK 8
Cognitive Technology Team
Cognitive Technology Team
Jul 12, 2025 · Backend Development

Mastering Apache HttpClient Connection Pool: Limits, Pitfalls, and Optimization

This article explores Apache HttpClient’s connection pool mechanism, detailing key parameters such as maxConnTotal, maxConnPerRoute, and timeToLive, explains how connections are allocated and reused, highlights common misconfigurations, and provides best‑practice tuning recommendations for high‑concurrency Java applications.

Apache HttpClientJavaconcurrency
0 likes · 9 min read
Mastering Apache HttpClient Connection Pool: Limits, Pitfalls, and Optimization
Lin is Dream
Lin is Dream
Jul 10, 2025 · Fundamentals

Understanding Sync, Async, Blocking, and Non‑Blocking: A Clear Guide

This article demystifies the four core concurrency concepts—synchronous, asynchronous, blocking, and non‑blocking—explaining their meanings, relationships, and practical implications with clear examples and a comparison table, helping developers choose the right model for high‑performance, scalable systems.

asynchronousblockingconcurrency
0 likes · 7 min read
Understanding Sync, Async, Blocking, and Non‑Blocking: A Clear Guide
The Dominant Programmer
The Dominant Programmer
Jul 9, 2025 · Fundamentals

Understanding Java Memory Model (JMM): Core Concepts and Guarantees

This article explains the Java Memory Model (JMM), detailing its purpose, the distinction from JVM memory structure, the eight memory interaction operations, the happens‑before principle, memory barriers, and common pitfalls such as double‑checked locking and visibility bugs, with concrete code examples.

Happens-BeforeJavaMemory Barriers
0 likes · 12 min read
Understanding Java Memory Model (JMM): Core Concepts and Guarantees
The Dominant Programmer
The Dominant Programmer
Jul 9, 2025 · Fundamentals

Mastering Java Thread Communication: volatile, synchronized, wait/notify, and Piped Streams

This article explains how Java threads interact using volatile for visibility, synchronized blocks for mutual exclusion, wait/notify (and Condition) for coordination, piped streams for one‑way byte communication, as well as Thread.join and ThreadLocal utilities, providing concrete code examples, best‑practice guidelines, and performance considerations.

JavaPipedStreamThreadLocal
0 likes · 23 min read
Mastering Java Thread Communication: volatile, synchronized, wait/notify, and Piped Streams
Top Architect
Top Architect
Jul 8, 2025 · Backend Development

How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal

This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock implemented with a custom annotation, Spring AOP interception, automatic lock renewal via a scheduled executor, and proper lock release, ensuring data consistency across concurrent requests.

AOPRedisSpring
0 likes · 14 min read
How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal
Tech Freedom Circle
Tech Freedom Circle
Jul 8, 2025 · Backend Development

How to Diagnose and Prevent Java Deadlocks (Alibaba & Other Big‑Company Interviews)

This article explains what a deadlock is, the four necessary conditions that cause it, demonstrates classic synchronized‑based and Lock‑based deadlock examples in Java, shows how to detect deadlocks with tools such as Arthas, jstack, jvisualvm and JMC, and provides practical strategies—including lock ordering, timeout locks, and two‑phase locking—to break each condition and avoid deadlocks in production code.

ArthasJavaLock
0 likes · 24 min read
How to Diagnose and Prevent Java Deadlocks (Alibaba & Other Big‑Company Interviews)
Java Backend Technology
Java Backend Technology
Jul 8, 2025 · Backend Development

ThreadLocal vs ScopedValue: Why ScopedValue Is the New King in Java Concurrency

ThreadLocal has long served as Java’s go‑to tool for thread‑local data, but its memory‑leak risks and performance penalties become pronounced with virtual threads, while the newer ScopedValue offers automatic cleanup, immutable safety, and superior efficiency, making it a compelling replacement in high‑concurrency scenarios.

ScopedValueThreadLocalVirtual Threads
0 likes · 12 min read
ThreadLocal vs ScopedValue: Why ScopedValue Is the New King in Java Concurrency
Lobster Programming
Lobster Programming
Jul 7, 2025 · Backend Development

Boost Order Processing Speed with Segmented Locks and Redis

This article explains how to use segmented (sharded) locks and Redis‑based routing strategies to parallelize inventory deduction and order creation, dramatically increasing orders processed per second while maintaining atomicity and fault tolerance.

RedisSegmented Lockconcurrency
0 likes · 7 min read
Boost Order Processing Speed with Segmented Locks and Redis
JakartaEE China Community
JakartaEE China Community
Jul 7, 2025 · Backend Development

Key Updates in Jakarta EE 11

Jakarta EE 11 adds record support in persistence and validation, maps java.time types, deprecates legacy date APIs, enables CDI injection for EntityManager, introduces virtual‑thread support, expands query syntax, allows Java‑based persistence unit configuration, and removes several outdated specifications such as SOAP with Attachments, XML Binding, CORBA, ManagedBean, and SecurityManager dependencies.

Jakarta EEJavaPersistence
0 likes · 3 min read
Key Updates in Jakarta EE 11
Su San Talks Tech
Su San Talks Tech
Jul 6, 2025 · Backend Development

Mastering Disruptor: High‑Performance In‑Memory Queue for Low‑Latency Java Apps

This article introduces the Disruptor in‑memory message queue—its architecture, core concepts such as Ring Buffer, Sequence, Sequencer and Wait Strategies, key features like multicast and gating, tuning options for producers and wait strategies, and provides a complete Java example to help developers build ultra‑low‑latency systems.

DisruptorIn-Memory QueueJava
0 likes · 10 min read
Mastering Disruptor: High‑Performance In‑Memory Queue for Low‑Latency Java Apps
Architect
Architect
Jul 5, 2025 · Backend Development

Implementing a Robust Redis Distributed Lock with AOP and Auto-Extension in Java

Learn how to design and implement a Redis-based distributed lock in Java using custom annotations, AOP interception, and a scheduled executor to automatically extend lock expiration, ensuring safe concurrent access to critical resources while handling timeouts, retries, and thread interruptions.

AOPJavaRedis
0 likes · 12 min read
Implementing a Robust Redis Distributed Lock with AOP and Auto-Extension in Java
21CTO
21CTO
Jul 4, 2025 · Fundamentals

Why Rust Is Revolutionizing Industrial Automation: Speed, Safety, and Scalability

This article explains how Rust’s high performance, strict memory safety, and modern concurrency model are reshaping industrial automation—from embedded controllers and IoT devices to robotics—by eliminating common C/C++ bugs, improving reliability, and enabling scalable, secure systems.

IoTRustconcurrency
0 likes · 8 min read
Why Rust Is Revolutionizing Industrial Automation: Speed, Safety, and Scalability
FunTester
FunTester
Jul 1, 2025 · Backend Development

How to Test Java ExecutorService Without Thread.sleep(): Reliable Strategies

This article explains why using Thread.sleep() in Java ExecutorService unit tests is unreliable and inefficient, and introduces three robust alternatives—Future.get(), CountDownLatch, and shutdown/awaitTermination—to ensure stable, performant testing of asynchronous WebSocket query scenarios.

CountDownLatchExecutorServiceFuture
0 likes · 13 min read
How to Test Java ExecutorService Without Thread.sleep(): Reliable Strategies
Architect
Architect
Jun 30, 2025 · Backend Development

Boost Java Performance: 12 Proven Techniques for Faster, Scalable Backend Systems

This article presents twelve practical strategies for optimizing Java backend performance—including parallel processing with CompletableFuture, minimizing transaction scope, effective caching, proper thread‑pool configuration, service warm‑up, cache‑line alignment, reducing object creation, asynchronous execution, loop optimization, shrinking network payloads, and decreasing inter‑service dependencies—each illustrated with code examples and benchmark results.

@AsyncJavaMicroservices
0 likes · 33 min read
Boost Java Performance: 12 Proven Techniques for Faster, Scalable Backend Systems
IT Services Circle
IT Services Circle
Jun 30, 2025 · Backend Development

What Makes Java Interviews Tough? A Deep Dive into Concurrency, JVM, MySQL, and More

This article analyzes 58.com’s recent business struggles and layoffs, then presents a comprehensive set of Java interview questions covering synchronized vs. Lock, JVM memory layout, garbage collection, TCP connection teardown, MySQL indexing pitfalls, and common sorting algorithms, providing detailed explanations and code examples.

JVMJavaMySQL
0 likes · 18 min read
What Makes Java Interviews Tough? A Deep Dive into Concurrency, JVM, MySQL, and More
JD Cloud Developers
JD Cloud Developers
Jun 30, 2025 · Backend Development

Unveiling Guava Cache Internals: Why It Lags Behind Caffeine

This article dissects Guava Cache's source code, explaining its segment‑based locking, data structures, put/get implementations, cleanup and eviction mechanisms, and then contrasts its performance and design choices with the more modern Caffeine cache, highlighting why Guava falls short.

CaffeineGuavaJava
0 likes · 39 min read
Unveiling Guava Cache Internals: Why It Lags Behind Caffeine
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.

Jakarta EEJakarta 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.

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

Cloud NativeDockerGo
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.

GoPerformance Optimizationconcurrency
0 likes · 6 min read
Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained