BestHub
Sign in
Tagged articles

concurrency

2234 articles · Page 12 of 23
IT Services Circle
IT Services Circle
Jan 15, 2023 · Backend Development

Understanding ThreadLocal and InheritableThreadLocal: Causes and Solutions for Missing Client Information in Multithreaded Java Services

This article explains why client information stored in ThreadLocal becomes unavailable after switching a single‑threaded search service to multithreading, analyzes the underlying ThreadLocal and InheritableThreadLocal mechanisms, and provides two practical solutions—passing the context manually or using InheritableThreadLocal—to avoid the upgrade‑prompt bug.

InheritableThreadLocalJavaThreadLocal
0 likes · 13 min read
Understanding ThreadLocal and InheritableThreadLocal: Causes and Solutions for Missing Client Information in Multithreaded Java Services
Selected Java Interview Questions
Selected Java Interview Questions
Jan 14, 2023 · Databases

Understanding Redis: Is It Truly Single-Threaded?

This article clarifies the common misconception that Redis is purely single‑threaded by detailing its single‑threaded network I/O model, the evolution of multithreading support across versions, the client‑server request flow, and the underlying Reactor patterns that enable efficient concurrency.

DatabaseReactor ModelRedis
0 likes · 14 min read
Understanding Redis: Is It Truly Single-Threaded?
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jan 9, 2023 · Backend Development

How Go’s Built‑In HTTP Server Handles Connections and Requests

This article walks through building a minimal Go HTTP server, explains how ListenAndServe manages connections, details the internal accept‑serve loop, shows request handling, routing rules, and customization hooks, providing clear code examples and diagrams to demystify Go’s built‑in web server.

HTTP serverNetworkingRouting
0 likes · 10 min read
How Go’s Built‑In HTTP Server Handles Connections and Requests
Top Architect
Top Architect
Jan 5, 2023 · Backend Development

Resolving Overselling in High‑Concurrency Flash Sale: Seven Locking and Queue Strategies in SpringBoot

This article analyzes why simple @Transactional and lock annotations still cause overselling in flash‑sale scenarios, then presents seven backend solutions—including improved controller locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches with BlockingQueue and Disruptor—along with code samples and JMeter test results.

DistributedSystemsJMeterMySQL
0 likes · 20 min read
Resolving Overselling in High‑Concurrency Flash Sale: Seven Locking and Queue Strategies in SpringBoot
Top Architect
Top Architect
Dec 30, 2022 · Backend Development

Implementing a High‑Concurrency Flash Sale System Using Redis List Queues in Spring Boot

This article explains why common Redis‑based flash‑sale demos that rely on WATCH transactions, distributed locks, or Lua scripts are unreliable, and presents a simple, lock‑free solution using Redis list operations (LPUSH/RPOP) with Spring Boot's StringRedisTemplate, including full Java code and usage examples.

JavaSpring Bootconcurrency
0 likes · 9 min read
Implementing a High‑Concurrency Flash Sale System Using Redis List Queues in Spring Boot
Su San Talks Tech
Su San Talks Tech
Dec 30, 2022 · Fundamentals

Unlocking Java Concurrency: A Deep Dive into AQS, Locks, and Condition Queues

This article explains Java's AbstractQueuedSynchronizer (AQS) framework, covering its MESA monitor model, entry and condition wait queues, exclusive and shared lock acquisition and release, and how core concurrency utilities like ReentrantLock, ReadWriteLock, CountDownLatch, Semaphore, ThreadPoolExecutor, and CyclicBarrier are built upon it.

AQSConditionJava
0 likes · 30 min read
Unlocking Java Concurrency: A Deep Dive into AQS, Locks, and Condition Queues
Python Programming Learning Circle
Python Programming Learning Circle
Dec 12, 2022 · Fundamentals

Pond: An Efficient Python Object Pool Library

The article introduces Pond, a high‑performance Python object‑pool library that reduces memory consumption and GC pressure by reusing objects, explains its design components, automatic eviction strategy, thread‑safe borrowing and returning mechanisms, and provides detailed usage examples with code snippets.

LibraryPerformanceconcurrency
0 likes · 11 min read
Pond: An Efficient Python Object Pool Library
Su San Talks Tech
Su San Talks Tech
Dec 9, 2022 · Backend Development

Master Asynchronous Java: Threads, Futures, CompletableFuture & Spring @Async

This article introduces asynchronous programming concepts in Java, explaining the shift from synchronous to asynchronous execution, and demonstrates practical implementations using raw threads, ThreadPoolExecutor, Future, FutureTask, CompletableFuture, and Spring's @Async annotation, along with event handling and message queue integration for high‑throughput systems.

AsynchronousCompletableFutureJava
0 likes · 16 min read
Master Asynchronous Java: Threads, Futures, CompletableFuture & Spring @Async
Liangxu Linux
Liangxu Linux
Dec 6, 2022 · Fundamentals

How to Master High‑Performance Computing: 9 Practical Strategies

This article breaks down nine essential techniques—ranging from faster CPU execution and effective caching to reducing interrupts, memory copies, and lock contention—to help developers systematically improve software performance across hardware and software layers.

AlgorithmsCPUI/O
0 likes · 7 min read
How to Master High‑Performance Computing: 9 Practical Strategies
Liangxu Linux
Liangxu Linux
Dec 3, 2022 · Backend Development

Implementing a Multi-Level Timing Wheel in C for Efficient Timer Management

This article explains the design and C implementation of a five‑level hierarchical timing wheel, covering its data structures, pointer handling with bitwise operations, timer insertion, modification, deletion, cascade processing, and a demo program that highlights blocking behavior of long‑running timer callbacks.

C programmingLinked Listconcurrency
0 likes · 22 min read
Implementing a Multi-Level Timing Wheel in C for Efficient Timer Management
Tencent Cloud Developer
Tencent Cloud Developer
Nov 28, 2022 · Backend Development

Understanding Go Channels: Implementation, Usage, and Performance

The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.

GoPerformancechannel
0 likes · 29 min read
Understanding Go Channels: Implementation, Usage, and Performance
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 22, 2022 · Fundamentals

Unveiling Java 8 Lambda: Inside the Stream Pipeline Mechanics

This article delves into the internal design and execution of Java 8 lambda expressions, dissecting the Stream API pipeline—from source creation through intermediate operations like map and filter to terminal actions such as collect and sum—while illustrating each step with concrete code examples.

CodeExampleJavaLambda
0 likes · 14 min read
Unveiling Java 8 Lambda: Inside the Stream Pipeline Mechanics
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Nov 14, 2022 · Backend Development

How Go’s HttpClient Implements Timeout with Context – A Deep Dive

This article compares Java’s HttpClient timeout implementation with Go’s built‑in HttpClient, explains Go’s Context‑based timeout mechanism, walks through the underlying source code, and shows why Java cannot easily replicate the same approach due to differences in concurrency primitives.

HttpClientconcurrencycontext
0 likes · 15 min read
How Go’s HttpClient Implements Timeout with Context – A Deep Dive
Tuanzi Tech Team
Tuanzi Tech Team
Nov 8, 2022 · Backend Development

Why Does SimpleDateFormat Fail in Multithreaded Java? Solutions and Best Practices

An operation team discovered that QR code redirects returned 404 due to expired access tokens, traced to SimpleDateFormat’s thread‑unsafe parsing causing incorrect expiration dates; the article analyzes the root cause, demonstrates failing multithreaded tests, and presents four thread‑safe alternatives including local instances, synchronization, ThreadLocal, and Java 8’s DateTimeFormatter.

DateTimeFormatterJavaSimpleDateFormat
0 likes · 10 min read
Why Does SimpleDateFormat Fail in Multithreaded Java? Solutions and Best Practices
Java Architect Essentials
Java Architect Essentials
Nov 6, 2022 · Backend Development

Implementing a Distributed Redis Lock with AOP and Automatic Renewal in Java

This article explains how to design and implement a distributed lock using Redis, Spring AOP annotations, and a scheduled executor to automatically extend lock expiration, providing complete Java code examples, configuration details, testing procedures, and best‑practice recommendations for handling long‑running business operations safely.

AOPRedisScheduledExecutorService
0 likes · 12 min read
Implementing a Distributed Redis Lock with AOP and Automatic Renewal in Java
Baidu Geek Talk
Baidu Geek Talk
Nov 2, 2022 · Backend Development

Avoid These Common Go Pitfalls Before They Crash Your Code

This article compiles a series of frequent Go programming pitfalls—ranging from incorrect use of unsafe.Sizeof and variadic any parameters to slice expansion, pointer handling, closure capture, concurrency bugs, and serialization quirks—providing concrete code examples and safe alternatives to help developers write more reliable Go code.

DebuggingGoMemory
0 likes · 18 min read
Avoid These Common Go Pitfalls Before They Crash Your Code
The Dominant Programmer
The Dominant Programmer
Nov 1, 2022 · Fundamentals

Master Java Multithreading and Custom Thread Pools in One Guide

This article explains why creating threads repeatedly wastes resources, introduces Java's ExecutorService thread pool, details its configuration parameters, demonstrates how to create and use fixed thread pools with Runnable and Callable tasks, shows proper shutdown, and highlights common pitfalls with Future.get.

FutureJavaThreadPool
0 likes · 9 min read
Master Java Multithreading and Custom Thread Pools in One Guide
Top Architect
Top Architect
Oct 20, 2022 · Backend Development

Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal

This article explains how to implement a Redis-based distributed lock in Spring Boot using custom annotations, AOP interception, and a scheduled executor to automatically renew lock expiration, providing a complete design, code examples, and testing guidance for handling long-running operations safely.

JavaRedisScheduledExecutorService
0 likes · 12 min read
Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal
FunTester
FunTester
Oct 19, 2022 · Backend Development

Controlling Java Async QPS with Semaphore and ThreadPool

This article explains how to use Java's java.util.concurrent.Semaphore together with a fixed-size thread pool to enforce a precise QPS limit for asynchronous tasks, providing API details, implementation steps, and a complete test example.

JavaQPSSemaphore
0 likes · 6 min read
Controlling Java Async QPS with Semaphore and ThreadPool
Java Architect Essentials
Java Architect Essentials
Oct 18, 2022 · Fundamentals

Common Pitfalls When Using Java List Implementations and How to Avoid Them

This article systematically examines ten typical pitfalls encountered when converting arrays to lists, performing add/remove operations, using subList, handling memory consumption, and working with thread‑safe collections such as CopyOnWriteArrayList in Java, and provides concrete code‑level solutions and performance recommendations.

CopyOnWriteArrayListLinkedListarraylist
0 likes · 20 min read
Common Pitfalls When Using Java List Implementations and How to Avoid Them
Java High-Performance Architecture
Java High-Performance Architecture
Oct 18, 2022 · Backend Development

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

This article explains the design and implementation of a Redis‑based distributed lock using Spring AOP, covering annotation creation, pointcut definition, lock acquisition, automatic renewal via a scheduled thread pool, error handling, and testing to ensure safe concurrent access to critical business data.

JavaRedisScheduledExecutorService
0 likes · 13 min read
How to Implement a Robust Redis Distributed Lock with Spring AOP and Auto‑Renewal
Top Architect
Top Architect
Oct 17, 2022 · Backend Development

Understanding Java Locks: volatile, synchronized, monitor, CAS, and AQS

This article explains why locks are needed in Java, describes the fundamentals of volatile and synchronized, details the monitor‑based implementation of synchronized, introduces CAS operations, and outlines advanced lock mechanisms such as biased, lightweight, lock coarsening, elimination, and the AbstractQueuedSynchronizer framework.

AQSCASJava
0 likes · 11 min read
Understanding Java Locks: volatile, synchronized, monitor, CAS, and AQS
Cognitive Technology Team
Cognitive Technology Team
Oct 16, 2022 · Backend Development

Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls

This article explains the different delay and periodic task types supported by Java's ScheduledThreadPoolExecutor, details its constructor parameters and default settings, and highlights common pitfalls such as exception loss, inaccurate scheduling, and improper core pool size configuration.

JavaScheduledThreadPoolExecutorTask Scheduling
0 likes · 5 min read
Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls
21CTO
21CTO
Oct 13, 2022 · Fundamentals

Why Rust Is Winning Over System Programmers – Pros, Cons, and Real‑World Insights

This article explores Rust's rise in systems programming, detailing its strengths such as safe concurrency, modern language design, and strong compiler feedback, while also highlighting challenges like a steep learning curve, complex async model, and low‑level memory management concerns.

Rustconcurrencylanguage-design
0 likes · 10 min read
Why Rust Is Winning Over System Programmers – Pros, Cons, and Real‑World Insights
Top Architect
Top Architect
Oct 13, 2022 · Databases

Understanding Transaction Isolation Levels and Concurrency Issues in MySQL

The article explains why transaction isolation is needed, describes common concurrency problems such as lost updates, dirty reads, non‑repeatable reads and phantom reads, outlines the ACID properties of a transaction, and details MySQL's four isolation levels with their effects and default settings.

ACIDDirty ReadLost Update
0 likes · 8 min read
Understanding Transaction Isolation Levels and Concurrency Issues in MySQL
MaGe Linux Operations
MaGe Linux Operations
Oct 11, 2022 · Fundamentals

Inside Go’s Goroutine Scheduler: Concepts, Evolution, and Design

This article explains how Go’s goroutine scheduler works, covering the fundamentals of OS thread scheduling, the transition from the old G‑M model to the modern G‑P‑M model, pre‑emptive scheduling strategies, lifecycle details, practical debugging tools, and performance‑related design choices.

concurrencyg-p-m modelgoroutine
0 likes · 28 min read
Inside Go’s Goroutine Scheduler: Concepts, Evolution, and Design
macrozheng
macrozheng
Sep 28, 2022 · Backend Development

Why Java 19 Virtual Threads Outperform Traditional Threads and Go Goroutines

This article introduces Java 19's virtual threads, compares their performance and scheduling with traditional platform threads and Go goroutines, provides practical code examples, benchmark results, and migration guidelines, and explains the underlying M:N scheduling mechanisms that make virtual threads more efficient for high‑concurrency, I/O‑bound workloads.

GoJavaPerformance
0 likes · 22 min read
Why Java 19 Virtual Threads Outperform Traditional Threads and Go Goroutines
Su San Talks Tech
Su San Talks Tech
Sep 25, 2022 · Backend Development

Mastering Java Thread Pools: Architecture, Execution Flow, and Custom Tuning

This article explains the fundamentals of Java thread pools, covering their purpose, construction parameters, execution process, worker reuse, task retrieval with timeout, lifecycle states, shutdown methods, monitoring techniques, and practical guidelines for customizing thread pools in real-world projects.

JavaThreadPoolbackend
0 likes · 17 min read
Mastering Java Thread Pools: Architecture, Execution Flow, and Custom Tuning
Tencent Cloud Developer
Tencent Cloud Developer
Sep 23, 2022 · Backend Development

Deep Dive into Go Context Package: Source Code Analysis and Design Patterns

An in‑depth examination of Go’s compact context package reveals its core interface, internal implementations like emptyCtx, cancelCtx, timerCtx, and valueCtx, the propagation and cancellation mechanisms, and practical design patterns, concluding with essential best‑practice guidelines for passing, canceling, and using context values safely.

Design PatternsGoSource Code Analysis
0 likes · 18 min read
Deep Dive into Go Context Package: Source Code Analysis and Design Patterns
Sanyou's Java Diary
Sanyou's Java Diary
Sep 19, 2022 · Backend Development

Mastering Quartz Scheduler in Spring Boot: From Basics to Advanced Integration

This article introduces Quartz, a Java job‑scheduling library, explains its core components (Job, Trigger, Scheduler), provides step‑by‑step Maven demos, shows how to integrate it with Spring Boot, configure persistence, manage concurrency, and handle advanced features like cron expressions and calendar exclusions.

CronTriggerJob SchedulingQuartz
0 likes · 25 min read
Mastering Quartz Scheduler in Spring Boot: From Basics to Advanced Integration
Cognitive Technology Team
Cognitive Technology Team
Sep 18, 2022 · Backend Development

Avoiding Thread Hunger Locks When Submitting Dependent Tasks to a Bounded Thread Pool

The article explains how converting a serial RPC call layer to an asynchronous parallel model can cause thread pool exhaustion and hunger lock when tasks depend on each other, demonstrates the issue with Java code, and provides practical strategies such as using separate pools or CompletableFuture to avoid the problem.

DeadlockJavaThreadPool
0 likes · 6 min read
Avoiding Thread Hunger Locks When Submitting Dependent Tasks to a Bounded Thread Pool
MaGe Linux Operations
MaGe Linux Operations
Sep 16, 2022 · Backend Development

Mastering Goroutine Limits: How to Control Go Concurrency Efficiently

Learn how Go's lightweight goroutines work, why unlimited spawning can cause panics, and practical techniques—using sync.WaitGroup, buffered channels, and worker pools—to limit concurrent goroutine numbers safely and efficiently while preserving program correctness and performance.

Worker Poolchannelconcurrency
0 likes · 4 min read
Mastering Goroutine Limits: How to Control Go Concurrency Efficiently
Sanyou's Java Diary
Sanyou's Java Diary
Sep 5, 2022 · Fundamentals

Mastering Java Thread Safety: Levels, Strategies, and Best Practices

This article explains Java thread‑safety concepts, classifies five safety levels from immutable to thread‑hostile, and details synchronization techniques—including mutual exclusion, non‑blocking CAS, and no‑sync approaches like reentrant code and thread‑local storage—to help developers write safe concurrent code.

Immutableconcurrencysynchronization
0 likes · 10 min read
Mastering Java Thread Safety: Levels, Strategies, and Best Practices
FunTester
FunTester
Sep 5, 2022 · Backend Development

How Many QPS Are Needed to Reveal Thread‑Unsafe Bugs? A Hands‑On SpringBoot Test

This article explores the QPS threshold required to expose thread‑unsafe operations such as i++ by designing a SpringBoot service, running controlled load tests with both fixed‑thread and precise‑QPS models, and presenting detailed results that show how error rates increase with higher request rates.

JavaQPSSpringBoot
0 likes · 8 min read
How Many QPS Are Needed to Reveal Thread‑Unsafe Bugs? A Hands‑On SpringBoot Test
Top Architect
Top Architect
Sep 3, 2022 · Backend Development

Implementing Distributed Locks with Redis, Zookeeper, and etcd

The article explains how to build reliable distributed locks using Redis, Zookeeper, and etcd, describing the essential concepts of mutual exclusion, safety, and liveness, showing code examples, highlighting common issues, and comparing each solution's advantages and drawbacks.

RedisZookeeperconcurrency
0 likes · 6 min read
Implementing Distributed Locks with Redis, Zookeeper, and etcd
政采云技术
政采云技术
Aug 30, 2022 · Fundamentals

Understanding Lucene Document Writing Process: Core Classes, Workflow, and Flush Strategies

This article explains the key Lucene classes involved in document indexing, outlines the end‑to‑end write workflow—including preUpdate, obtainAndLock, updateDocument, exception handling, and post‑update flush logic—and discusses the strategies and thresholds that control when in‑memory buffers are flushed to disk.

Document WritingIndexingJava
0 likes · 16 min read
Understanding Lucene Document Writing Process: Core Classes, Workflow, and Flush Strategies
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 29, 2022 · Mobile Development

Optimizing iOS App Startup by Adjusting GCD Queue QoS and Reducing Main Thread Preemption

By analyzing thread preemption on low‑end iPhones, this article demonstrates how selecting appropriate GCD queue QoS levels—favoring Utility or Background over User‑Initiated—reduces main‑thread contention, improves launch screen rendering by ~100 ms, and accelerates message list first‑load by up to 1.5 s without altering business logic.

GCDQoSconcurrency
0 likes · 10 min read
Optimizing iOS App Startup by Adjusting GCD Queue QoS and Reducing Main Thread Preemption
Su San Talks Tech
Su San Talks Tech
Aug 29, 2022 · Databases

Why Redis Added Multithreading in 6.0: Design Rationale and Trade‑offs

This article explains why Redis, originally designed as a single‑threaded in‑memory database, introduced a multithreaded network layer in version 6.0, covering the historical design, the limits of CPU vs I/O utilization, the role of I/O multiplexing, and the benefits and drawbacks of the new model.

I/O multiplexingRedisconcurrency
0 likes · 11 min read
Why Redis Added Multithreading in 6.0: Design Rationale and Trade‑offs
IT Architects Alliance
IT Architects Alliance
Aug 27, 2022 · Backend Development

Understanding ReentrantLock and the AQS Framework in Java

This article explains how Java's ReentrantLock works, detailing the role of the AbstractQueuedSynchronizer framework, the lock's internal architecture, the FIFO wait‑queue implementation, lock acquisition and release processes, and how these mechanisms avoid the herd effect in multithreaded environments.

AQSJavaReentrantLock
0 likes · 11 min read
Understanding ReentrantLock and the AQS Framework in Java
Tuanzi Tech Team
Tuanzi Tech Team
Aug 25, 2022 · Fundamentals

Unlocking Java’s Memory Model: CPU Caches, Cache Coherence, and Thread Safety

This article explains the hardware memory hierarchy, CPU multi‑level caches, cache coherence protocols, and how Java’s memory model abstracts these concepts to ensure thread safety, covering local and main memory, synchronization primitives, and the three core properties of atomicity, visibility, and ordering.

CPUCacheJavaMemoryModel
0 likes · 17 min read
Unlocking Java’s Memory Model: CPU Caches, Cache Coherence, and Thread Safety
21CTO
21CTO
Aug 24, 2022 · Fundamentals

Why Rust Is Shaping the Future of Safe System Programming

An interview with Rust creator Graydon Hoare explores the language's origins, its emphasis on speed, memory safety and concurrency, its adoption by major tech firms, and his perspective on the current state and future challenges of system programming security.

RustSystem Programmingconcurrency
0 likes · 6 min read
Why Rust Is Shaping the Future of Safe System Programming
Xingsheng Youxuan Technology Community
Xingsheng Youxuan Technology Community
Aug 24, 2022 · Backend Development

Mastering Sliding Window Rate Limiting: Sentinel Implementation Explained

This article explains the sliding window rate‑limiting algorithm, its advantages over fixed windows, and provides a detailed step‑by‑step implementation using Sentinel’s data structures, including window partitioning, bucket management, concurrency handling, and calculation of request counts within a moving time interval.

SentinelSliding Windowbackend
0 likes · 8 min read
Mastering Sliding Window Rate Limiting: Sentinel Implementation Explained
Top Architect
Top Architect
Aug 23, 2022 · Backend Development

Understanding the Implementation of synchronized in Java and Its Differences with Lock

This article explains how Java's synchronized keyword works at the JVM level, detailing monitorenter/monitorexit bytecode, the role of object monitors, differences between synchronized methods and blocks, and compares its behavior and performance with explicit Lock implementations such as ReentrantLock, including code examples and practical considerations.

JVMJavaLock
0 likes · 8 min read
Understanding the Implementation of synchronized in Java and Its Differences with Lock
FunTester
FunTester
Aug 22, 2022 · Backend Development

How to Build a High‑Performance Log Replay Engine with Java DelayQueue

This article explains the design and implementation of a timestamp‑based log replay engine that replays HTTP traffic using Java's DelayQueue, thread pools, and custom data structures, and provides performance test results demonstrating its ability to handle hundreds of thousands of requests per second.

DelayQueueJavaconcurrency
0 likes · 10 min read
How to Build a High‑Performance Log Replay Engine with Java DelayQueue
Python Programming Learning Circle
Python Programming Learning Circle
Aug 20, 2022 · Fundamentals

Understanding Python Asyncio: Core Concepts, Event Loop Mechanics, and Performance Comparison

This article introduces Python's asyncio library, explains the fundamentals of coroutines, tasks, and the event loop, compares synchronous and asynchronous code execution with practical examples, and demonstrates how asynchronous programming can significantly improve performance in I/O‑bound scenarios.

Asynchronous Programmingconcurrencyevent loop
0 likes · 10 min read
Understanding Python Asyncio: Core Concepts, Event Loop Mechanics, and Performance Comparison
Dada Group Technology
Dada Group Technology
Aug 19, 2022 · Backend Development

Improving High‑Concurrency System Performance with Coroutines and the Quasar Framework

The article analyzes the high load and low CPU utilization problems of a Java service, compares various I/O models, introduces coroutine fundamentals and the Quasar library, demonstrates practical migration steps with code examples, and evaluates the performance gains and risks of adopting coroutine‑based concurrency.

Quasarbackendconcurrency
0 likes · 19 min read
Improving High‑Concurrency System Performance with Coroutines and the Quasar Framework
Su San Talks Tech
Su San Talks Tech
Aug 19, 2022 · Fundamentals

Master Java Concurrency: 60+ Interview Q&A on Threads, Locks & Thread Pools

This comprehensive guide explores Java concurrency fundamentals, covering thread creation, lifecycle, synchronization mechanisms, lock implementations, thread-local storage, memory model, atomic classes, common concurrency utilities, and detailed explanations of thread pools, their configurations, states, and best practices, accompanied by over sixty interview-style questions and code examples.

JavaLockThreadPool
0 likes · 81 min read
Master Java Concurrency: 60+ Interview Q&A on Threads, Locks & Thread Pools
Java Architect Essentials
Java Architect Essentials
Aug 18, 2022 · Backend Development

Batch Processing with Multithreading in Java: Splitting Large Collections and Using Thread Pools

This article explains how to efficiently handle massive data batch updates in Java by splitting large collections into smaller chunks, processing them concurrently with a configurable ThreadPoolExecutor, and controlling execution order, while providing reusable utility code and practical implementation examples.

ApacheCommonsBatchProcessingGuava
0 likes · 8 min read
Batch Processing with Multithreading in Java: Splitting Large Collections and Using Thread Pools
21CTO
21CTO
Aug 18, 2022 · Cloud Native

Why Go (Golang) Is the Go‑To Language for Cloud‑Native Development

This article explores Go's concise design, strong concurrency model, fast compilation, static binaries, and broad ecosystem, highlighting its ideal fit for cloud‑native applications, distributed services, and command‑line tools while also addressing its limitations and future direction.

GoStatic Binariescloud native
0 likes · 12 min read
Why Go (Golang) Is the Go‑To Language for Cloud‑Native Development
Su San Talks Tech
Su San Talks Tech
Aug 14, 2022 · Backend Development

9 Hidden Pitfalls When Converting Synchronous Code to Multithreaded Execution

Switching from single‑threaded synchronous calls to multithreaded asynchronous execution can boost performance, but it also introduces nine common problems—including missing return values, data loss, ordering issues, thread‑safety bugs, ThreadLocal anomalies, OOM, high CPU usage, transaction failures, and service crashes—that developers must understand and mitigate.

JavaThreadLocalThreadPool
0 likes · 19 min read
9 Hidden Pitfalls When Converting Synchronous Code to Multithreaded Execution
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Aug 12, 2022 · Fundamentals

Understanding Linux rwsem: Mechanisms, Data Structures, and Optimistic Spinning

Linux rwsem is a read‑write semaphore that lets multiple readers or a single writer hold the lock, using a count field, owner pointer, optimistic‑spin queue (osq), and protected wait list; it provides fast, medium, and slow acquisition paths with handoff and optimistic spinning to reduce sleep latency compared to mutexes and spinlocks.

Linux kernelconcurrencyoptimistic spinning
0 likes · 16 min read
Understanding Linux rwsem: Mechanisms, Data Structures, and Optimistic Spinning
Python Crawling & Data Mining
Python Crawling & Data Mining
Aug 11, 2022 · Fundamentals

Why Python Multiprocessing Needs target=func Without Parentheses

This article explains a common Python multiprocessing pitfall, showing how using target=function_name without parentheses correctly launches a new process, and illustrates the difference between passing a function object versus calling the function, accompanied by screenshots of the discussion, runtime output, and a concise solution.

concurrencymultiprocessingthreading
0 likes · 3 min read
Why Python Multiprocessing Needs target=func Without Parentheses
Code Ape Tech Column
Code Ape Tech Column
Aug 4, 2022 · Backend Development

Understanding Redisson Distributed Lock Implementation

This article provides a comprehensive, step‑by‑step analysis of Redisson’s distributed lock implementation, covering its architecture, Lua scripts for lock acquisition, re‑entrancy, watchdog renewal, unlocking, fair lock mechanisms, and code examples, enabling developers to grasp and apply robust Redis‑based locking in Java applications.

JavaLuaRedisson
0 likes · 31 min read
Understanding Redisson Distributed Lock Implementation
ITPUB
ITPUB
Jul 31, 2022 · Fundamentals

What Really Happens Inside Java’s synchronized? A Deep Dive into JVM Lock Mechanisms

This article examines the inner workings of Java’s synchronized keyword by analyzing HotSpot 1.8 source code, revealing how lightweight, heavyweight, biased, and adaptive spin locks operate, how lock inflation occurs, and how the JVM manages monitor objects, CAS operations, and thread queues to implement synchronization.

JVMJavaconcurrency
0 likes · 17 min read
What Really Happens Inside Java’s synchronized? A Deep Dive into JVM Lock Mechanisms
Selected Java Interview Questions
Selected Java Interview Questions
Jul 29, 2022 · Backend Development

Seven Directions of Code Performance Optimization for Java Backend

This article outlines seven major areas of Java backend performance optimization—including reuse, computation, result‑set, resource‑conflict, algorithm, efficient implementation, and JVM tuning—explaining concepts, techniques, and practical examples to help developers improve application speed and resource utilization.

AlgorithmJavaOptimization
0 likes · 11 min read
Seven Directions of Code Performance Optimization for Java Backend
Top Architect
Top Architect
Jul 29, 2022 · Fundamentals

Understanding TCP Connection Limits and the Role of Port Numbers

The article explains how TCP connections are identified by a four‑tuple, why the 65535 port limit does not directly cap concurrent connections, the theoretical maximum connections for client and server roles, and how real‑world limits are governed by memory, file descriptors, and port reuse on Linux systems.

TCPconcurrencyport limits
0 likes · 11 min read
Understanding TCP Connection Limits and the Role of Port Numbers
Su San Talks Tech
Su San Talks Tech
Jul 28, 2022 · Backend Development

Asynchronous Java Programming: Threads, Futures, CompletableFuture & Spring @Async

This article introduces asynchronous programming concepts in Java, explaining how multithreading, Future, FutureTask, CompletableFuture, and Spring's @Async annotation can transform synchronous workflows into high‑throughput, low‑latency solutions, with code examples and practical guidance for implementing each technique.

Asynchronous ProgrammingCompletableFutureJava
0 likes · 17 min read
Asynchronous Java Programming: Threads, Futures, CompletableFuture & Spring @Async
FunTester
FunTester
Jul 27, 2022 · Backend Development

How Java’s DelayQueue Handles Million‑QPS Loads: Performance Test Insights

This article examines the implementation of java.util.concurrent.DelayQueue for high‑throughput performance testing, presents a custom Delayed object, shares benchmark code and results across various thread counts, and concludes that DelayQueue can sustain several million QPS when properly tuned.

DelayQueueJavaQueue
0 likes · 7 min read
How Java’s DelayQueue Handles Million‑QPS Loads: Performance Test Insights
Top Architect
Top Architect
Jul 25, 2022 · Backend Development

Using @Scheduled in Spring Boot for Task Scheduling: Configuration, Parameters, and Multi‑threading

This article explains how to create and configure Spring Boot scheduled tasks with @Scheduled, covering property‑based settings, cron expressions, fixed‑rate and fixed‑delay options, the required @EnableScheduling annotation, and how to switch from the default single‑thread executor to a multi‑threaded pool for concurrent execution.

CronJavaScheduled Tasks
0 likes · 9 min read
Using @Scheduled in Spring Boot for Task Scheduling: Configuration, Parameters, and Multi‑threading
Cognitive Technology Team
Cognitive Technology Team
Jul 24, 2022 · Fundamentals

Introduction to ThreadLocal in Java

ThreadLocal provides thread confinement in Java, allowing each thread to hold its own independent variable, which is useful for scenarios such as database connection isolation, transaction storage, lock-free concurrency, implicit parameter passing across functions, and highlights common pitfalls like information loss in thread pools and OOM risks.

Implicit ParametersJavaThread Safety
0 likes · 5 min read
Introduction to ThreadLocal in Java
Cognitive Technology Team
Cognitive Technology Team
Jul 23, 2022 · Backend Development

Understanding FutureTask: Features, Implementation, and Common Pitfalls

FutureTask acts as a proxy for asynchronous tasks in Java, providing result retrieval with optional timeout, completion checks, cancellation, and repeat execution, while managing task state, outcomes, and exceptions; the article illustrates usage, internal fields, and common pitfalls such as missed exceptions and indefinite blocking.

AsynchronousExceptionHandlingFutureTask
0 likes · 5 min read
Understanding FutureTask: Features, Implementation, and Common Pitfalls
Top Architect
Top Architect
Jul 22, 2022 · Backend Development

Understanding ExecutorCompletionService: Root Cause Analysis and Best Practices

This article analyzes a production outage caused by misuse of ExecutorCompletionService, explains the underlying Java concurrency mechanisms, compares it with ExecutorService, provides correct code examples, and offers practical guidelines to avoid memory leaks and improve backend reliability.

ExecutorCompletionServiceJavaOOM
0 likes · 12 min read
Understanding ExecutorCompletionService: Root Cause Analysis and Best Practices