BestHub
Sign in
Tagged articles

concurrency

2234 articles · Page 6 of 23
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.

OptimizationProgramming Languagesbenchmark
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.

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

Goclosureconcurrency
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 BoundParallelismPython
0 likes · 9 min read
Unlock Full CPU Power in Python: A Hands‑On Guide to Multiprocessing
Programmer1970
Programmer1970
Feb 13, 2025 · Backend Development

Deep Dive into Java’s Exchanger: How It Works and When to Use It

This article explains Java's Exchanger class, detailing its synchronization mechanism, internal source‑code structure, practical usage examples, and how it compares with other concurrency utilities such as CyclicBarrier, Semaphore, and SynchronousQueue.

ExchangerJUCJava
0 likes · 10 min read
Deep Dive into Java’s Exchanger: How It Works and When to Use It
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.

Helper APIJavaThread Coordination
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.

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

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

Design PatternsPerformance OptimizationSecurity
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.

Zookeeperbackendconcurrency
0 likes · 7 min read
How to Choose the Right Distributed Lock: DB, Redis, or ZooKeeper?
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 10, 2025 · Backend Development

Master Java Asynchronous Programming: 7 Powerful Techniques with Code Samples

This article explains why asynchronous programming boosts Java application performance and walks through seven practical methods—Thread, FutureTask, CompletableFuture, Guava ListenableFuture, EA‑Async, Cactoos, and Jcabi‑Aspects—each illustrated with complete, runnable code examples.

Asynchronous ProgrammingCompletableFutureJava
0 likes · 14 min read
Master Java Asynchronous Programming: 7 Powerful Techniques with Code Samples
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.

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

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

Javacode reviewconcurrency
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.

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

JavaPerformanceSpring Boot
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.

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

Asynchronous ProgrammingCompletableFutureFuture
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.

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

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

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

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

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

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

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

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

JavaReentrantLockThread Safety
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.

JavaPerformanceSpring Boot
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.

Data RaceGoatomic
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.

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

AQSJavaLock
0 likes · 10 min read
How Java’s AQS Powers ReentrantLock – A Deep Dive into the Source
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 FeaturesPythonconcurrency
0 likes · 11 min read
Advanced Python Features and Their Use Cases
Architecture Digest
Architecture Digest
Jan 10, 2025 · Backend Development

Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal

This article explains how to protect time‑consuming business operations and critical data by designing a Redis‑based distributed lock using custom annotations, Spring AOP, and a ScheduledExecutorService that automatically extends the lock’s expiration to avoid premature release.

JavaScheduledExecutorServiceSpring AOP
0 likes · 11 min read
Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal
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.

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

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

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

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

Gobackend developmentconcurrency
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.

CompletableFutureJavaScheduledExecutorService
0 likes · 9 min read
Replacing Thread.sleep Loops with Proper Scheduling in Java
Programmer1970
Programmer1970
Jan 6, 2025 · Backend Development

Understanding StampedLock in Java 8: Principles and Practical Use

This article explains Java 8's StampedLock—its optimistic and pessimistic read/write modes, internal state handling, source‑code walkthrough, typical usage scenarios, and a performance comparison with ReentrantLock and ReentrantReadWriteLock—providing concrete code examples and detailed analysis for developers.

JUCJavaJava8
0 likes · 12 min read
Understanding StampedLock in Java 8: Principles and Practical Use
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.

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

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

DivideAndConquerForkJoinPoolJava
0 likes · 25 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java
BirdNest Tech Talk
BirdNest Tech Talk
Jan 1, 2025 · Fundamentals

Master Rust: From Basics to Advanced Concepts in One Comprehensive Guide

This article outlines a Rust programming book that starts with fundamental syntax, variables, and memory management, then progressively explores ownership, lifetimes, error handling, concurrency, async programming, traits, macros, and practical examples, providing code snippets and core concepts for each topic.

Advanced ConceptsMacrosRust
0 likes · 16 min read
Master Rust: From Basics to Advanced Concepts in One Comprehensive Guide
FunTester
FunTester
Dec 31, 2024 · Backend Development

Mastering Java ReentrantLock: Blocking, Interruptible, and Timeout Locks Explained

This article explains the Java java.util.concurrent.locks.Lock interface and its ReentrantLock implementation, detailing the advantages of reentrancy, interruptibility, and timeout features, and provides practical code examples for blocking, interruptible, and timed lock acquisition along with best‑practice recommendations.

LockReentrantLockconcurrency
0 likes · 12 min read
Mastering Java ReentrantLock: Blocking, Interruptible, and Timeout Locks Explained
Go Programming World
Go Programming World
Dec 30, 2024 · Backend Development

Understanding and Using sync.Cond in Go: Source Code Analysis and Practical Examples

This article explains the purpose, internal implementation, and correct usage patterns of Go's sync.Cond concurrency primitive, walks through its source code, demonstrates simple and advanced examples—including a custom concurrent waiting queue—and provides test cases to illustrate its behavior in real-world scenarios.

Queueconcurrencycondition variable
0 likes · 20 min read
Understanding and Using sync.Cond in Go: Source Code Analysis and Practical Examples
Architecture Digest
Architecture Digest
Dec 26, 2024 · Backend Development

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

This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.

JavaJava 21Performance
0 likes · 7 min read
Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
FunTester
FunTester
Dec 26, 2024 · Fundamentals

Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword

This chapter introduces advanced Java multithreading concepts, explaining thread safety, the synchronized keyword, various synchronization techniques, and practical code examples such as object‑level, class‑level, method‑level synchronization and double‑checked locking to help solve concurrency problems in performance testing.

Javaconcurrencyperformance-testing
0 likes · 15 min read
Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword
Programmer1970
Programmer1970
Dec 25, 2024 · Fundamentals

A Comprehensive Deep Dive into the Java Collections Framework

This article provides an in‑depth overview of Java’s Collections Framework, detailing the core interfaces (List, Set, Queue, Deque, Map), their major implementations, performance characteristics, thread‑safety considerations, iterator usage, utility classes, and concurrent collection options, illustrated with code examples and diagrams.

Collections FrameworkIteratorJava
0 likes · 23 min read
A Comprehensive Deep Dive into the Java Collections Framework
Tencent Cloud Developer
Tencent Cloud Developer
Dec 24, 2024 · Backend Development

From Java to Go: Key Differences Every Developer Must Know

This article compares Java and Go across syntax simplicity, type systems, object‑oriented features, pointers, error handling, concurrency, reflection, and community culture, providing concrete code examples and practical insights to help Java developers transition smoothly to Go.

GoJavaLanguage comparison
0 likes · 14 min read
From Java to Go: Key Differences Every Developer Must Know
Radish, Keep Going!
Radish, Keep Going!
Dec 23, 2024 · Backend Development

Speed Up Go Cache Expiration Tests with testing/synctest

This article explains how Go's testing/synctest experiment speeds up cache expiration tests by using a virtual clock and bubble isolation, providing code examples that reduce a five‑second wait to milliseconds while ensuring reliable concurrent test execution.

Goconcurrencygo-cache
0 likes · 7 min read
Speed Up Go Cache Expiration Tests with testing/synctest
JD Cloud Developers
JD Cloud Developers
Dec 23, 2024 · Backend Development

How to Add Asynchronous Timeout to CompletableFuture in JDK 8

This article explains why JDK 8's CompletableFuture lacks built‑in timeout interruption, analyzes common usage patterns and their limitations, and presents a custom asynchronous timeout solution that works in both JDK 8 and JDK 9 environments, complete with reusable utility code.

Async TimeoutCompletableFutureJDK8
0 likes · 13 min read
How to Add Asynchronous Timeout to CompletableFuture in JDK 8
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 23, 2024 · Backend Development

Unlocking High‑Performance C++ Concurrency: Memory Model, Atomics, and Lock‑Free Techniques

This article explains C++11’s memory model and atomic types, demonstrating how lock‑free concurrency, memory ordering, and synchronization primitives such as fences can be used to achieve high‑performance, race‑free multithreaded code for demanding backend systems like game servers.

C++Lock-Free ProgrammingMemory Model
0 likes · 26 min read
Unlocking High‑Performance C++ Concurrency: Memory Model, Atomics, and Lock‑Free Techniques
Java Tech Enthusiast
Java Tech Enthusiast
Dec 22, 2024 · Backend Development

Common Java ThreadPool Pitfalls and How to Avoid Them

Java developers should avoid ten common thread‑pool mistakes—such as using unbounded queues, misconfiguring thread counts, neglecting shutdown, ignoring rejection policies, swallowing task exceptions, submitting blocking work, overusing pools, lacking monitoring, and missing dynamic tuning—by configuring bounded queues, proper sizes, explicit policies, exception handling, and runtime adjustments.

JavaPerformanceThreadPool
0 likes · 8 min read
Common Java ThreadPool Pitfalls and How to Avoid Them
macrozheng
macrozheng
Dec 20, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common mistakes when using Java thread pools—such as unbounded queues, wrong thread counts, missing shutdown, and ignored exceptions—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

JavaThreadPoolbackend
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
FunTester
FunTester
Dec 19, 2024 · Backend Development

Mastering Custom Thread Pools: Choosing the Right Queue in Java

This article walks through Java thread‑pool queue options—LinkedBlockingQueue, SynchronousQueue, LinkedBlockingDeque, and PriorityBlockingQueue—explaining their characteristics, demonstrating code examples, and showing how to build multi‑priority executors with concrete output analysis.

BlockingQueueJavaLinkedBlockingDeque
0 likes · 12 min read
Mastering Custom Thread Pools: Choosing the Right Queue in Java
JD Tech Talk
JD Tech Talk
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article experimentally compares how a Java ExecutorService thread pool reacts to uncaught exceptions when tasks are submitted via execute versus submit, showing that execute removes the faulty thread and creates a new one while submit retains the thread and stores the exception in a Future.

JavaThreadPoolconcurrency
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
JD Cloud Developers
JD Cloud Developers
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article examines how Java's ExecutorService thread pool reacts when a task throws an uncaught exception, comparing the behaviors of execute and submit methods, analyzing source code, and summarizing the impact on thread removal, creation, and exception retrieval.

ExceptionHandlingJavaThreadPool
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
FunTester
FunTester
Dec 17, 2024 · Backend Development

Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques

This article examines why uncaught exceptions in Java thread pools cause runaway thread creation, then walks through five concrete strategies—try‑catch wrappers, Callable, afterExecute overrides, custom ThreadFactory, and a global default handler—each illustrated with runnable code and detailed analysis.

JavaThreadPoolbackend development
0 likes · 13 min read
Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques
BirdNest Tech Talk
BirdNest Tech Talk
Dec 16, 2024 · Backend Development

Five Ways to Build a Broadcast Notifier in Go

This article examines five Go implementations of a broadcast notifier—using sync.Cond, channels, context, sync.WaitGroup, and sync.RWMutex—detailing their code, execution flow, and trade‑offs so readers can understand how each primitive achieves notification broadcasting.

BroadcastGochannel
0 likes · 9 min read
Five Ways to Build a Broadcast Notifier in Go
Su San Talks Tech
Su San Talks Tech
Dec 14, 2024 · Backend Development

Mastering CompletableFuture: From Basics to RocketMQ Integration

This article explains the limitations of Java's Future, introduces CompletableFuture with its rich API for non‑blocking asynchronous programming, demonstrates practical usage including task creation, result retrieval, chaining, exception handling, and shows how RocketMQ leverages CompletableFuture to coordinate disk flush and replica sync tasks efficiently.

CompletableFutureFutureJava
0 likes · 16 min read
Mastering CompletableFuture: From Basics to RocketMQ Integration
macrozheng
macrozheng
Dec 13, 2024 · Backend Development

How to Implement a FIFO Export Queue in Spring Boot to Prevent Performance Bottlenecks

To avoid performance degradation caused by simultaneous large‑scale data exports, this guide demonstrates building a fixed‑size FIFO export queue in Spring Boot, integrating EasyExcel for million‑row exports, handling asynchronous processing, and providing sample code for the queue, export service, and controller.

EasyExcelExport QueueFIFO
0 likes · 12 min read
How to Implement a FIFO Export Queue in Spring Boot to Prevent Performance Bottlenecks
Su San Talks Tech
Su San Talks Tech
Dec 13, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common Java thread‑pool pitfalls—such as using Executors shortcuts, misconfiguring thread counts, ignoring queue choices, and neglecting shutdown or monitoring—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

JavaThreadPoolbest practices
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
Java Tech Enthusiast
Java Tech Enthusiast
Dec 12, 2024 · Backend Development

Java CompletableFuture: Asynchronous Programming Guide

Java's CompletableFuture, introduced in Java 8, replaces the blocking Future with a rich, non‑blocking API that supports asynchronous task creation, result retrieval via get/join, chaining callbacks, exception handling, task combination (AND/OR, allOf/anyOf), and recommends custom executors, timeouts, and proper saturation policies.

Asynchronous ProgrammingCompletableFutureJava
0 likes · 16 min read
Java CompletableFuture: Asynchronous Programming Guide
Programmer XiaoFu
Programmer XiaoFu
Dec 12, 2024 · Backend Development

4 Elegant Ways to Transfer Data Between Async Threads in Spring Boot

The article compares four techniques—manual ThreadLocal copying, TaskDecorator, InheritableThreadLocal, and Alibaba's TransmittableThreadLocal—for passing user context and other data from parent to child threads in Spring Boot async execution, recommending the TaskDecorator and TransmittableThreadLocal approaches for production use.

JavaSpring BootTaskDecorator
0 likes · 13 min read
4 Elegant Ways to Transfer Data Between Async Threads in Spring Boot
php Courses
php Courses
Dec 11, 2024 · Backend Development

Debunking Common Misconceptions About PHP

This article systematically dispels ten widespread myths about PHP—covering threading, project scale, security, modern relevance, usage scope, code quality, performance, object‑oriented support, learning depth, and scalability—showing that modern PHP remains a powerful, secure, and versatile backend technology.

PHPPerformanceSecurity
0 likes · 8 min read
Debunking Common Misconceptions About PHP
Architecture Digest
Architecture Digest
Dec 10, 2024 · Backend Development

Understanding Java Virtual Threads and Their Use in Spring Boot

This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.

JavaJava 21Performance
0 likes · 7 min read
Understanding Java Virtual Threads and Their Use in Spring Boot
Java Tech Enthusiast
Java Tech Enthusiast
Dec 10, 2024 · Backend Development

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

The article demonstrates how to implement a bounded FIFO export queue in a Spring Boot application, using synchronized wait/notify methods to limit concurrent large‑data exports to ten threads, integrating with an abstract EasyExcel exporter and a controller that spawns export tasks, while noting future enhancements such as persistent storage and Redis‑based queues.

EasyExcelExport QueueJava
0 likes · 11 min read
Implementing a FIFO Export Queue in Spring Boot for Large Data Exports
Go Programming World
Go Programming World
Dec 10, 2024 · Backend Development

Deep Dive into Go's Context Package: Design, Implementation, and Usage

This article thoroughly explains the design and implementation of Go's context package, covering its core interfaces, various concrete types, cancellation propagation, deadline handling, value storage, and the internal mechanisms that enable concurrent-safe control flow and data passing across context trees.

cancellationconcurrencycontext
0 likes · 30 min read
Deep Dive into Go's Context Package: Design, Implementation, and Usage
FunTester
FunTester
Dec 4, 2024 · Backend Development

Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools

This article explains why the standard Executors factory methods may be insufficient, details each ThreadPoolExecutor constructor parameter, demonstrates how to configure a custom pool for performance testing, and walks through multiple code examples that illustrate thread creation, queue behavior, and rejection policies.

JavaJava concurrencyThreadPool
0 likes · 14 min read
Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 2, 2024 · Fundamentals

Understanding Fair and Unfair Locks in Java's ReentrantLock

This article explains the concepts, creation methods, usage examples, and internal implementation details of fair and unfair locks in Java's ReentrantLock, comparing their performance characteristics and providing guidance on when to choose each type in multithreaded applications.

FairLockJavaReentrantLock
0 likes · 23 min read
Understanding Fair and Unfair Locks in Java's ReentrantLock
php Courses
php Courses
Dec 2, 2024 · Backend Development

Understanding PHP 8.1 Fibers: How They Work and Their Limitations

This article explains PHP 8.1 Fibers, describing their cooperative multitasking mechanism, how suspension and resumption affect the main script, why they do not provide true asynchronous execution, and how they can be combined with event loops for more efficient non‑blocking code in backend development.

AsynchronousFibersPHP
0 likes · 7 min read
Understanding PHP 8.1 Fibers: How They Work and Their Limitations
FunTester
FunTester
Dec 2, 2024 · Fundamentals

Mastering Java Thread Pools: Fixed vs. Cached Executors Explained

This article explains Java thread pools, their performance benefits, and how to create and use FixedThreadPool and CachedThreadPool via the Executors utility, providing code examples, execution results, and guidance on selecting the appropriate pool for different concurrency scenarios.

CachedThreadPoolFixedThreadPoolJava
0 likes · 12 min read
Mastering Java Thread Pools: Fixed vs. Cached Executors Explained
JD Cloud Developers
JD Cloud Developers
Nov 29, 2024 · Mobile Development

Cangjie for HarmonyOS: Fast Setup, Key Features, and ArkTS Interop

This article introduces Cangjie, a lightweight, high‑performance programming language for HarmonyOS, detailing its core advantages, rapid environment configuration, distinctive language features such as flow expressions, lightweight threads, extensions, synchronization primitives, and demonstrates seamless interoperation with ArkTS, concluding with future development outlook.

CangjieHarmonyOSInterop
0 likes · 13 min read
Cangjie for HarmonyOS: Fast Setup, Key Features, and ArkTS Interop