BestHub
Sign in
Tagged articles

concurrency

2156 articles · Page 13 of 22
Cognitive Technology Team
Cognitive Technology Team
Apr 25, 2022 · Backend Development

Preventing ThreadLocal Information Loss in Multithreaded Java Applications by Implementing Custom Runnable and Callable (Hystrix Example)

This article explains why ThreadLocal variables can lose their values when used across thread pools, and demonstrates how to create custom Runnable and Callable wrappers that propagate HystrixRequestContext to ensure reliable ThreadLocal transmission in multithreaded Java environments.

ContextPropagationHystrixJava
0 likes · 8 min read
Preventing ThreadLocal Information Loss in Multithreaded Java Applications by Implementing Custom Runnable and Callable (Hystrix Example)
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2022 · Backend Development

Deep Dive into Java ForkJoinPool: Design, Implementation, and Usage

This article explains the divide‑and‑conquer principle, the internal design of Java's ForkJoinPool, its core classes (ForkJoinTask, ForkJoinWorkerThread, WorkQueue), key methods for task submission, work stealing, thread management, and provides practical code examples to illustrate how to implement and use fork/join parallelism effectively.

ForkJoinPoolJavaWorkStealing
0 likes · 48 min read
Deep Dive into Java ForkJoinPool: Design, Implementation, and Usage
Cognitive Technology Team
Cognitive Technology Team
Apr 24, 2022 · Backend Development

Pitfalls of Using ThreadLocal for User Context in Java Applications

Using ThreadLocal to store user information in Java web applications can lead to hidden failures such as loss of context and memory leaks, especially when thread pools are involved, so developers should restrict its usage to controller threads and employ static analysis tools to detect improper usage.

JavaMemoryLeakThreadLocal
0 likes · 4 min read
Pitfalls of Using ThreadLocal for User Context in Java Applications
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Apr 22, 2022 · Fundamentals

Understanding Linux Kernel Mutex: Mechanism, Data Structures, and APIs

The Linux kernel’s mutex is a sleeping lock that serializes access by sleeping threads, enforces strict ownership rules, uses a state flag with a wait list and per‑CPU optimistic spin queue, offers APIs like mutex_init, lock, unlock and trylock, and employs handoff and MCS‑style spinning to improve performance, with OPPO’s team optimizing it to reduce UI jank.

Linux kernelSynchronizationconcurrency
0 likes · 16 min read
Understanding Linux Kernel Mutex: Mechanism, Data Structures, and APIs
Top Architect
Top Architect
Apr 22, 2022 · Backend Development

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Distributed Locks, ReentrantLock, Zookeeper, Redis, and GTIS

This article explains the mutual‑exclusion and idempotency challenges in distributed environments, analyzes multi‑thread and multi‑process solutions, introduces the principles and implementations of distributed locks (including ReentrantLock, synchronized, Zookeeper, Redis, Tair, and the Cerberus framework), and presents GTIS as a reliable idempotency guard.

Distributed LockJavaRedis
0 likes · 32 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Distributed Locks, ReentrantLock, Zookeeper, Redis, and GTIS
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 20, 2022 · Backend Development

Transaction Middleware: FSM and Concurrency Model Practices and Exploration

This article examines the challenges faced by a transaction middleware platform, introduces a finite‑state‑machine (FSM) solution for order state flows, and compares traditional serial processing with future‑based staged concurrency and event‑driven concurrency models, highlighting their benefits and trade‑offs.

BackendFinite State MachineFuture
0 likes · 11 min read
Transaction Middleware: FSM and Concurrency Model Practices and Exploration
Selected Java Interview Questions
Selected Java Interview Questions
Apr 19, 2022 · Backend Development

Implementing Distributed Locks in Java: Database, Redis, and Zookeeper Solutions

This article explains the concept of distributed locks, compares three common implementation schemes—database unique indexes, Redis SETNX, and Zookeeper temporary sequential nodes—and provides complete Java code examples for each, along with analysis of re‑entrancy, lock release timing, and single‑point failures.

BackendDistributed LockZookeeper
0 likes · 13 min read
Implementing Distributed Locks in Java: Database, Redis, and Zookeeper Solutions
macrozheng
macrozheng
Apr 19, 2022 · Backend Development

Why Java Virtual Threads Are a Game-Changer for High-Concurrency Backends

Java virtual threads, introduced in JEP 425, provide a lightweight, low‑cost alternative to traditional platform threads, enabling massive concurrency without the overhead of OS threads, improving throughput for server‑side applications while preserving familiar APIs and enhancing observability.

JEP425JavaThread API
0 likes · 9 min read
Why Java Virtual Threads Are a Game-Changer for High-Concurrency Backends
Python Programming Learning Circle
Python Programming Learning Circle
Apr 15, 2022 · Fundamentals

Why Python Struggles with Large Projects: Variable Declarations, Module Management, Dependencies, and Concurrency

The article examines the challenges of using Python for large-scale projects, highlighting issues such as implicit variable declarations, complex module dependencies, version conflicts, the Global Interpreter Lock, and concurrency limitations, while comparing Python to languages like C, Go, and Java.

GILModulesPython
0 likes · 13 min read
Why Python Struggles with Large Projects: Variable Declarations, Module Management, Dependencies, and Concurrency
Java High-Performance Architecture
Java High-Performance Architecture
Apr 13, 2022 · Backend Development

Mastering Asynchronous Execution in Spring Boot: From @Async to CompletableFuture

This article explains multiple ways to implement asynchronous processing in Spring Boot, covering @Async annotation, CompletableFuture, supplyAsync, runAsync, WebAsyncTask, DeferredResult, custom interceptors, and server configuration tweaks such as Tomcat connection limits and switching to Undertow.

CompletableFutureJavaSpring Boot
0 likes · 11 min read
Mastering Asynchronous Execution in Spring Boot: From @Async to CompletableFuture
MaGe Linux Operations
MaGe Linux Operations
Apr 12, 2022 · Backend Development

Understanding Go’s CSP Model: Goroutine, Channel, Scheduler

This article explains Go’s concurrency fundamentals, distinguishing concurrency from parallelism, describing the CSP model built on goroutines and channels, and detailing the underlying M‑P‑G scheduler architecture—including thread models, runqueues, and load balancing—providing a comprehensive overview for developers.

CSPGoScheduler
0 likes · 11 min read
Understanding Go’s CSP Model: Goroutine, Channel, Scheduler
Baidu Geek Talk
Baidu Geek Talk
Apr 12, 2022 · Backend Development

Five Practical Go Tips: Ballast Optimization, Benchmark & pprof, Testing Stubs, OOM Caused by Locks, and Memory Synchronization in Concurrency

This guide presents five practical Go techniques—using a large ballast slice to control GC timing, leveraging benchmark and pprof for performance profiling, applying the monkey library for test stubbing, avoiding unreleased locks that cause OOM, and employing proper synchronization primitives to prevent stale memory reads.

GoTestingconcurrency
0 likes · 12 min read
Five Practical Go Tips: Ballast Optimization, Benchmark & pprof, Testing Stubs, OOM Caused by Locks, and Memory Synchronization in Concurrency
Java High-Performance Architecture
Java High-Performance Architecture
Apr 10, 2022 · Backend Development

Mastering Redis Distributed Locks with Jedis: Build a 100k-User Flash Sale Simulation

This article demonstrates how to implement Redis distributed locks using Jedis in Java, covering lock creation with SETNX, lock release via Lua scripts, and a high‑concurrency flash‑sale simulation with 100,000 virtual users, illustrating key concepts such as lock expiration, atomic operations, and performance testing.

Distributed LockJavaJedis
0 likes · 10 min read
Mastering Redis Distributed Locks with Jedis: Build a 100k-User Flash Sale Simulation
Cognitive Technology Team
Cognitive Technology Team
Apr 9, 2022 · Backend Development

When Does ThreadPoolExecutor’s RejectedExecutionHandler Trigger and How to Use Its Implementations in Java

This article explains the conditions that cause ThreadPoolExecutor’s RejectedExecutionHandler to fire, reviews the built‑in policies such as DiscardOldestPolicy, AbortPolicy, CallerRunsPolicy and DiscardPolicy, provides their source code, and offers practical advice on selecting and avoiding pitfalls when handling rejected tasks in Java concurrency.

Backend DevelopmentJavaRejectedExecutionHandler
0 likes · 5 min read
When Does ThreadPoolExecutor’s RejectedExecutionHandler Trigger and How to Use Its Implementations in Java
Baidu Geek Talk
Baidu Geek Talk
Apr 8, 2022 · Artificial Intelligence

Golang Object Pool for Reducing GC Pressure, FFmpeg Concurrency Control, and Paddle Static vs. Dynamic Graphs

The article explains how Go's lock‑free sync.Pool can cut garbage‑collection overhead, shows practical FFmpeg thread‑parameter tuning that balances CPU use and latency for video filtering versus encoding, and compares PaddlePaddle's static and dynamic graph modes, including debugging tips and conversion to static.

Dynamic GraphStatic Graphconcurrency
0 likes · 13 min read
Golang Object Pool for Reducing GC Pressure, FFmpeg Concurrency Control, and Paddle Static vs. Dynamic Graphs
Efficient Ops
Efficient Ops
Apr 6, 2022 · Operations

How Many TCP Connections Can One Server Really Handle? A Deep Dive

This article demystifies the common confusion about a server’s maximum concurrent TCP connections, explaining the theoretical limits of the TCP four‑tuple, Linux file‑descriptor restrictions, kernel buffer settings, and demonstrates achieving one million active connections through careful configuration and tuning.

Server TuningTCPconcurrency
0 likes · 7 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive
IT Architects Alliance
IT Architects Alliance
Apr 5, 2022 · Backend Development

Understanding Java Timers, DelayQueue, ScheduledThreadPoolExecutor, and Time‑Wheel Algorithms

This article explains the concepts, use cases, and internal implementations of Java's Timer, DelayQueue, and ScheduledThreadPoolExecutor, compares their performance characteristics, and introduces the time‑wheel scheduling algorithm—including hierarchical wheels—to address scalability challenges in high‑volume timed‑task systems.

DelayQueueJavaScheduledThreadPoolExecutor
0 likes · 12 min read
Understanding Java Timers, DelayQueue, ScheduledThreadPoolExecutor, and Time‑Wheel Algorithms
IT Services Circle
IT Services Circle
Apr 3, 2022 · Backend Development

Four Ways to Determine When a Java ThreadPool Has Completed All Tasks

This article explains four practical techniques—using isTerminated, comparing task counts, CountDownLatch, and CyclicBarrier—to reliably detect when a Java ThreadPoolExecutor has finished executing all submitted tasks, including code examples, advantages, disadvantages, and a summary of each method.

CountDownLatchCyclicBarrierJava
0 likes · 12 min read
Four Ways to Determine When a Java ThreadPool Has Completed All Tasks
Tencent Cloud Developer
Tencent Cloud Developer
Mar 30, 2022 · Backend Development

Go High-Performance Programming: Concurrency Optimization Techniques

This article, the second in a Go high‑performance series, details concurrency optimizations including lock‑free data structures versus locked lists, sharding and RWMutex to cut lock contention, controlling goroutine creation with pooling, using sync.Once for cheap one‑time initialization, and employing sync.Cond for efficient goroutine notification.

BenchmarkGoOptimization
0 likes · 30 min read
Go High-Performance Programming: Concurrency Optimization Techniques
FunTester
FunTester
Mar 28, 2022 · Backend Development

Why LongAdder Beats AtomicLong in High‑Concurrency Java Performance Tests

This article explains how Java's LongAdder works, compares its API and performance to AtomicLong, provides usage examples and a benchmark showing its superior throughput under high thread contention, while noting its higher memory cost and appropriate scenarios for adoption.

Javaatomiclongconcurrency
0 likes · 7 min read
Why LongAdder Beats AtomicLong in High‑Concurrency Java Performance Tests
High Availability Architecture
High Availability Architecture
Mar 24, 2022 · Backend Development

Understanding Go's Goroutine Scheduling: Design Principles, GMP Model, and Optimizations

The article reviews Dmitry Vyukov's 2019 talk on Go's goroutine scheduler, explains the GMP (goroutine‑M‑Processor) model, walks through its evolution from naive thread‑per‑goroutine to thread pools and work‑stealing, and discusses fairness, pre‑emptive scheduling, and possible future improvements.

GMP modelGoScheduler
0 likes · 14 min read
Understanding Go's Goroutine Scheduling: Design Principles, GMP Model, and Optimizations
vivo Internet Technology
vivo Internet Technology
Mar 23, 2022 · Backend Development

Understanding the Time Wheel Mechanism in Dubbo and Redisson

The article explains why a time‑wheel scheduler outperforms traditional timers, describes single‑ and multi‑layer wheel designs, and walks through Apache Dubbo’s HashedWheelTimer implementation—including TimerTask, Timeout, bucket and worker components—showing its use in Dubbo heartbeats and Redisson lock renewal.

DubboJavaScheduling
0 likes · 23 min read
Understanding the Time Wheel Mechanism in Dubbo and Redisson
Top Architect
Top Architect
Mar 22, 2022 · Backend Development

Cache Update Strategies: Consistency, Concurrency, and Failure Handling

The article analyzes various cache update strategies—including delete‑then‑write, write‑then‑delete, and asynchronous binlog subscription—examining their impact on system throughput, concurrency safety, failure scenarios, and fault detection to ensure data consistency between cache and database.

BackendCacheStrategy
0 likes · 6 min read
Cache Update Strategies: Consistency, Concurrency, and Failure Handling
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 18, 2022 · Backend Development

13 Crucial Java Practices Every Developer Should Follow

This article examines fifteen common Java pitfalls and best‑practice guidelines—ranging from property copying and date formatting to HashMap sizing, thread‑pool creation, collection handling, logging, and serialization—explaining why each recommendation exists and how it impacts performance and safety.

CollectionsJavaLogging
0 likes · 9 min read
13 Crucial Java Practices Every Developer Should Follow
Tencent Cloud Developer
Tencent Cloud Developer
Mar 17, 2022 · Fundamentals

Understanding Go's Goroutine Scheduler: Design, GMP Model, and Optimizations

The article explains Go’s GMP‑based goroutine scheduler, detailing how logical processors, thread‑local queues, and work‑stealing replace a naïve one‑goroutine‑per‑thread model, and discusses fairness, cooperative preemption, current limitations, and future optimizations compared with custom coroutine frameworks.

GMP modelGoconcurrency
0 likes · 14 min read
Understanding Go's Goroutine Scheduler: Design, GMP Model, and Optimizations
政采云技术
政采云技术
Mar 17, 2022 · Databases

InnoDB Lock System: Types, Modes, Structures, and Compatibility

This article explains InnoDB's lock system in MySQL, covering lock granularity, intent, shared, exclusive and auto‑increment locks, row‑lock types, the underlying C++ structures, lock mode and type encoding, and the compatibility and strength matrices that govern lock acquisition and waiting.

C++DatabaseInnoDB
0 likes · 13 min read
InnoDB Lock System: Types, Modes, Structures, and Compatibility
FunTester
FunTester
Mar 16, 2022 · Backend Development

Why Disruptor’s Default ExceptionHandler Crashes Your QPS and How to Fix It

When using the Disruptor library for high‑throughput testing, the default FatalExceptionHandler can repeatedly abort consumer threads on exceptions, causing QPS to drop to zero, but replacing it with an ignore handler or a custom implementation restores stability.

BackendDisruptorExceptionHandler
0 likes · 4 min read
Why Disruptor’s Default ExceptionHandler Crashes Your QPS and How to Fix It
Programmer DD
Programmer DD
Mar 15, 2022 · Backend Development

Essential Java Books Every Backend Engineer Should Read

This guide highlights the most influential Java books—from core language fundamentals and JVM internals to concurrency and effective coding practices—explaining why each title is vital for building a solid backend development skill set.

Backend DevelopmentJavaconcurrency
0 likes · 8 min read
Essential Java Books Every Backend Engineer Should Read
Ziru Technology
Ziru Technology
Mar 15, 2022 · Backend Development

Unlocking Java Concurrency: How CountDownLatch Works Inside JDK 1.8

This article explores the inner workings of Java’s CountDownLatch from JDK 1.8, detailing its core concepts such as the counter, thread synchronization, shared mode, and AQS mechanisms, and demonstrates practical usage through step‑by‑step code analysis and examples.

AQSBackend DevelopmentCountDownLatch
0 likes · 5 min read
Unlocking Java Concurrency: How CountDownLatch Works Inside JDK 1.8
Code Ape Tech Column
Code Ape Tech Column
Mar 10, 2022 · Backend Development

10 Common Pitfalls in Java Concurrency and How to Avoid Them

This article outlines ten typical concurrency pitfalls in Java—including SimpleDateFormat thread‑safety, double‑checked locking flaws, volatile atomicity limits, deadlocks, lock release issues, HashMap race conditions, default thread‑pool misuse, @Async thread explosion, spin‑lock CPU waste, and ThreadLocal memory leaks—providing explanations, code examples, and practical solutions for each.

Javaconcurrencymultithreading
0 likes · 20 min read
10 Common Pitfalls in Java Concurrency and How to Avoid Them
Architects' Tech Alliance
Architects' Tech Alliance
Mar 8, 2022 · Backend Development

30 Architectural Principles for Software Engineers

The article presents thirty practical architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, and ROI to server concurrency, distributed system design, user experience, and configuration management—aimed at guiding engineers and teams toward robust, scalable, and maintainable software solutions.

Backend DevelopmentSoftware Architectureconcurrency
0 likes · 10 min read
30 Architectural Principles for Software Engineers
Java Backend Technology
Java Backend Technology
Mar 8, 2022 · Operations

Avoid Common Redis Distributed‑Lock Pitfalls and Fix Them

This article explains why naive Redis lock usage can cause non‑atomic operations, forgotten releases, lock‑stealing, re‑entrancy, read‑write contention, segmentation, timeout, master‑slave failures, and offers practical Java/Redisson/Lua solutions to make distributed locks reliable.

Distributed LockJavaLua
0 likes · 20 min read
Avoid Common Redis Distributed‑Lock Pitfalls and Fix Them
IT Services Circle
IT Services Circle
Mar 7, 2022 · Backend Development

10 Common Java Concurrency Pitfalls and How to Avoid Them

This article outlines ten frequent Java concurrency pitfalls—including unsafe SimpleDateFormat usage, double‑checked locking flaws, volatile limitations, deadlocks, HashMap memory leaks, thread‑pool misuse, @Async traps, spin‑lock inefficiencies, and ThreadLocal memory leaks—providing explanations, code examples, and practical solutions for each.

Best PracticesPerformanceconcurrency
0 likes · 21 min read
10 Common Java Concurrency Pitfalls and How to Avoid Them
Java Backend Technology
Java Backend Technology
Mar 5, 2022 · Fundamentals

Uncovering Thread.Sleep: How Sleep Affects CPU Scheduling and App Performance

Thread.Sleep pauses a thread for a specified duration, signaling the OS to exclude it from CPU competition, and Thread.Sleep(0) forces an immediate rescheduling, which can improve UI responsiveness by yielding control to other threads; the article explains these behaviors using time‑slice and preemptive scheduling analogies.

CPU schedulingOS fundamentalsconcurrency
0 likes · 10 min read
Uncovering Thread.Sleep: How Sleep Affects CPU Scheduling and App Performance
Su San Talks Tech
Su San Talks Tech
Feb 23, 2022 · Fundamentals

Why Does synchronized Fail with Integer Locks? Deep Dive into Java Concurrency

This article examines why Java's synchronized keyword can become ineffective when locking on an Integer object, explores how autoboxing and Integer caching cause lock objects to change, and presents reliable alternatives such as class‑level locks or explicit lock maps for safe multithreaded programming.

IntegerLockingconcurrency
0 likes · 18 min read
Why Does synchronized Fail with Integer Locks? Deep Dive into Java Concurrency
ByteDance Terminal Technology
ByteDance Terminal Technology
Feb 22, 2022 · Fundamentals

Optimizing CPython for True Parallel Execution: Implementing a Multi-Interpreter Architecture

This article details a novel approach to overcoming CPython's Global Interpreter Lock by implementing a multi-interpreter architecture that isolates execution states, manages shared variables through thread-specific data, and introduces a subinterpreter pool to significantly enhance multi-core CPU utilization and algorithm execution performance.

CPythonGIL OptimizationMulti-Interpreter Architecture
0 likes · 15 min read
Optimizing CPython for True Parallel Execution: Implementing a Multi-Interpreter Architecture
政采云技术
政采云技术
Feb 22, 2022 · Backend Development

Understanding Java ThreadPoolExecutor: Implementation Principles, Creation, Usage, and Parameter Tuning

This article explains the core principles of Java's ThreadPoolExecutor, details its internal state management, demonstrates how to create and configure thread pools with various parameters and rejection policies, and provides practical recommendations for sizing and applying thread pools in backend applications.

JavaPerformanceThreadPoolExecutor
0 likes · 18 min read
Understanding Java ThreadPoolExecutor: Implementation Principles, Creation, Usage, and Parameter Tuning
Sanyou's Java Diary
Sanyou's Java Diary
Feb 14, 2022 · Backend Development

Is Redis Redlock Really Safe? Uncovering the Truth Behind Distributed Locks

This article thoroughly examines the safety of Redis-based distributed locks, from basic SETNX implementations to advanced Redlock algorithms, compares them with Zookeeper locks, discusses common pitfalls like deadlocks, clock drift, and network delays, and presents expert debates and practical solutions for robust lock management.

RedisRedlockSafety
0 likes · 32 min read
Is Redis Redlock Really Safe? Uncovering the Truth Behind Distributed Locks
Yiche Technology
Yiche Technology
Jan 27, 2022 · Backend Development

C++ Multithreaded Service Architecture for High‑Throughput AI Inference

The article explains how to design a C++‑based multithreaded service that uses Pthreads, channels, and TensorRT to parallelize deep‑learning inference tasks, thereby reducing latency and dramatically increasing throughput for AI applications such as facial‑recognition access control systems.

AI inferenceC++Performance
0 likes · 11 min read
C++ Multithreaded Service Architecture for High‑Throughput AI Inference
Selected Java Interview Questions
Selected Java Interview Questions
Jan 25, 2022 · Fundamentals

Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods

This article examines how Java's synchronized keyword and ReentrantLock behave when multiple threads invoke two synchronized methods of the same class, exploring scenarios with the same instance, different instances, and Runnable run methods, and summarizing the resulting concurrency rules.

JavaReentrantLockSynchronization
0 likes · 15 min read
Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods
Architecture Digest
Architecture Digest
Jan 24, 2022 · Fundamentals

Understanding Python Threads, Processes, GIL, and the multiprocessing & concurrent.futures Modules

This article explains the fundamental differences between threads and processes, the role of Python's Global Interpreter Lock, and provides a comprehensive guide to using the multiprocessing and concurrent.futures modules—including their main classes, synchronization primitives, and practical code examples—for effective concurrent programming in Python.

GILMultiprocessingPython
0 likes · 40 min read
Understanding Python Threads, Processes, GIL, and the multiprocessing & concurrent.futures Modules
Java Backend Technology
Java Backend Technology
Jan 16, 2022 · Backend Development

Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips

This article presents a comprehensive guide to building maintainable, extensible backend systems by covering coding conventions, branch naming, commit messages, comment standards, result‑wrapping patterns, database normalization, algorithmic improvements, concurrency handling, service layering, and practical code examples.

BackendDatabase DesignPerformance
0 likes · 20 min read
Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips
FunTester
FunTester
Jan 10, 2022 · Backend Development

Performance Testing of Java and Go High‑Performance Message Queues Using LinkedBlockingQueue

This article presents a detailed performance evaluation of Java and Go high‑throughput message queues, focusing on LinkedBlockingQueue, exploring test scenarios based on message size and thread count, analyzing producer and consumer results, providing benchmark data, and sharing Groovy test cases for reproducibility.

JavaLinkedBlockingQueueMessage Queue
0 likes · 27 min read
Performance Testing of Java and Go High‑Performance Message Queues Using LinkedBlockingQueue
Programmer DD
Programmer DD
Jan 6, 2022 · Fundamentals

Why Java’s Biased Locking Matters—and Why It’s Being Deprecated

This article explains the evolution of Java synchronization mechanisms from the classic synchronized keyword to lightweight, biased, and heavyweight locks, explores how lock states transition, the impact of hashCode and wait, and why biased locking is being phased out in modern JDKs.

Biased LockingJavaSynchronization
0 likes · 26 min read
Why Java’s Biased Locking Matters—and Why It’s Being Deprecated
Java High-Performance Architecture
Java High-Performance Architecture
Jan 6, 2022 · Backend Development

Mastering Redis Distributed Locks: Strategies, Pitfalls, and Redisson Watchdog

Redis distributed locks rely on a key-value marker with unique client IDs, expiration times, and careful release checks; the article explores lock timeout challenges, automatic renewal via watchdog mechanisms, Redisson's tryLock implementation, Lua‑based renewal scripts, and best practices to avoid deadlocks and resource waste.

Distributed LockJavaRedis
0 likes · 11 min read
Mastering Redis Distributed Locks: Strategies, Pitfalls, and Redisson Watchdog
FunTester
FunTester
Jan 6, 2022 · Backend Development

A Simple Custom Wait Method for Java/Groovy Multithreaded Tests

The article explains how to create a lightweight custom waiting utility in Java (using Groovy syntax) that repeatedly checks a condition every 0.5 seconds, simplifying thread synchronization for performance testing of multithreaded code.

CustomWaitGroovyJava
0 likes · 5 min read
A Simple Custom Wait Method for Java/Groovy Multithreaded Tests
Sohu Tech Products
Sohu Tech Products
Jan 5, 2022 · Backend Development

Implementing Distributed Locks with Redis and Redisson

This article explains how to implement a distributed lock using Redis, discusses challenges with lock expiration, describes automatic renewal techniques such as watchdog mechanisms, and provides detailed Java code examples of Redisson's tryLock and renewal processes.

Distributed LockJavaRedis
0 likes · 12 min read
Implementing Distributed Locks with Redis and Redisson
Sohu Tech Products
Sohu Tech Products
Jan 5, 2022 · Fundamentals

Source Code Analysis – Suspension and Resumption of Kotlin Coroutines

This article dissects the Kotlin coroutine implementation by decompiling a simple coroutine, explaining how the compiler transforms suspend functions into state‑machine classes, how launch creates an AbstractCoroutine, how the dispatcher intercepts and schedules execution, and how the coroutine is suspended and later resumed through Continuation mechanisms.

CoroutinesKotlinSuspend
0 likes · 16 min read
Source Code Analysis – Suspension and Resumption of Kotlin Coroutines
Code Ape Tech Column
Code Ape Tech Column
Jan 4, 2022 · Backend Development

How to Enable Multithreaded Scheduled Tasks in Spring Boot

This article explains why Spring Boot's default scheduled tasks run on a single thread and demonstrates three practical ways to configure multithreaded scheduling using SchedulingConfigurer, application properties, and the @Async annotation with a custom thread pool.

JavaSpring Bootconcurrency
0 likes · 4 min read
How to Enable Multithreaded Scheduled Tasks in Spring Boot
21CTO
21CTO
Jan 1, 2022 · Fundamentals

Master Python Concurrency: Threads, Processes, GIL, and Multiprocessing Explained

This article provides a comprehensive guide to Python concurrency, covering the fundamental differences between threads and processes, the impact of the Global Interpreter Lock, and detailed usage of the multiprocessing module with its various components and synchronization primitives.

GILMultiprocessingconcurrency
0 likes · 38 min read
Master Python Concurrency: Threads, Processes, GIL, and Multiprocessing Explained
Top Architect
Top Architect
Jan 1, 2022 · Backend Development

Understanding ThreadLocalRandom and Unsafe in Java: Performance, Implementation, and Pitfalls

This article examines Java's Random performance limitations, explains how ThreadLocalRandom leverages the Unsafe class for per‑thread seed management, analyzes the underlying native methods, discusses safety concerns and memory layout, and shares practical code examples and insights for high‑concurrency applications.

JDKThreadLocalRandomUnsafe
0 likes · 10 min read
Understanding ThreadLocalRandom and Unsafe in Java: Performance, Implementation, and Pitfalls
FunTester
FunTester
Dec 28, 2021 · Backend Development

Using LMAX Disruptor for High‑Performance Event Processing in Java

This article explains how to replace Java's LinkedBlockingQueue with the high‑throughput LMAX Disruptor library, covering dependency setup, event definition, Disruptor creation, producer and consumer implementations, handler configuration, startup/shutdown procedures, and provides both Java and Groovy demo code.

BackendDisruptorJava
0 likes · 8 min read
Using LMAX Disruptor for High‑Performance Event Processing in Java
Architecture Digest
Architecture Digest
Dec 27, 2021 · Fundamentals

System Capacity Design and Evaluation: Concepts, Metrics, and Practical Steps

This article explains how to design and evaluate system capacity by defining key metrics such as QPS, TPS and concurrency, describing when capacity assessment is needed, and outlining a step‑by‑step methodology—including traffic analysis, peak estimation, stress testing and redundancy planning—to ensure reliable performance under varying load conditions.

QPScapacity planningconcurrency
0 likes · 11 min read
System Capacity Design and Evaluation: Concepts, Metrics, and Practical Steps
DeWu Technology
DeWu Technology
Dec 26, 2021 · Fundamentals

Java Synchronized Mechanism Overview

Java's synchronized keyword provides mutual exclusion by using object monitors, offering class‑method, static‑method, and block locking patterns, while the JVM optimizes performance through biased, lightweight, and heavyweight lock strategies, making it essential knowledge for efficient concurrent programming.

JavaSynchronizationconcurrency
0 likes · 29 min read
Java Synchronized Mechanism Overview
FunTester
FunTester
Dec 25, 2021 · Backend Development

Java Thread Synchronization Utilities: CountDownLatch, CyclicBarrier, and Phaser

An overview of Java’s three primary thread‑synchronization tools—CountDownLatch, CyclicBarrier, and Phaser—explaining their placement in java.util.concurrent, typical use‑cases such as coordinating multi‑threaded tasks in performance testing, and the advantages of each, complemented by illustrative diagrams.

CountDownLatchCyclicBarrierJava
0 likes · 7 min read
Java Thread Synchronization Utilities: CountDownLatch, CyclicBarrier, and Phaser
ITPUB
ITPUB
Dec 23, 2021 · Fundamentals

Understanding Deadlocks: Causes, Conditions, and Prevention Strategies

The article provides a comprehensive overview of deadlocks, explaining what they are, the resources and ordering issues that cause them, the four necessary conditions, and detailed prevention, detection, and recovery techniques including lock ordering, timeout strategies, and the banker’s algorithm.

Javaconcurrencyresource allocation
0 likes · 11 min read
Understanding Deadlocks: Causes, Conditions, and Prevention Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Dec 22, 2021 · Backend Development

Performance Analysis of Go map Concurrency: sync.Map vs map+RWLock vs concurrent‑map

The article compares Go’s native map (which crashes under concurrent access), a map protected by sync.RWMutex, the lock‑free read‑optimized sync.Map introduced in Go 1.9, and the sharded orcaman/concurrent‑map, showing that sync.Map excels in read‑heavy workloads while sharded maps better handle frequent inserts, and suggesting other cache libraries for eviction or expiration needs.

Goconcurrencysync.Map
0 likes · 20 min read
Performance Analysis of Go map Concurrency: sync.Map vs map+RWLock vs concurrent‑map
FunTester
FunTester
Dec 22, 2021 · Backend Development

Java Multithreading Tutorial: Simulating Ticket Booking with Runnable

This article explains how to implement Java multithreading using the Runnable interface through a ticket‑booking example, demonstrates common pitfalls like calling run() directly, shows code with and without Thread.sleep, and discusses concurrency issues such as thread‑unsafe ticket duplication.

JavaRunnableconcurrency
0 likes · 10 min read
Java Multithreading Tutorial: Simulating Ticket Booking with Runnable
Architect's Tech Stack
Architect's Tech Stack
Dec 21, 2021 · Backend Development

Using @Async Annotation in Spring: Application Scenarios, Built‑in Thread Pools, and Custom Thread‑Pool Configuration

This article explains the @Async annotation in Spring, how it enables asynchronous method execution, compares the built‑in executors, shows how to configure custom thread pools via AsyncConfigurer or AsyncConfigurerSupport, and provides code examples for void, Future and CompletableFuture based async methods.

Javaasyncconcurrency
0 likes · 12 min read
Using @Async Annotation in Spring: Application Scenarios, Built‑in Thread Pools, and Custom Thread‑Pool Configuration
Python Programming Learning Circle
Python Programming Learning Circle
Dec 11, 2021 · Fundamentals

Understanding Python Threads, Processes, GIL, and Multiprocessing

This article explains the fundamental differences between threads and processes, the role of Python's Global Interpreter Lock (GIL), and how to use the multiprocessing package—including Process, Pool, Queue, Pipe, and synchronization primitives—as well as an overview of concurrent.futures for high‑level concurrent programming in Python.

GILMultiprocessingPython
0 likes · 38 min read
Understanding Python Threads, Processes, GIL, and Multiprocessing
New Oriental Technology
New Oriental Technology
Dec 10, 2021 · Backend Development

Implementing a Concurrent-Safe Queue in Go

This article explains Go's concurrency safety mechanisms, demonstrates how to build a thread‑safe queue using mutexes, sync.Cond, and context cancellation, and provides complete example code and tests to illustrate proper synchronization and resource management.

ContextQueueconcurrency
0 likes · 10 min read
Implementing a Concurrent-Safe Queue in Go
Architects Research Society
Architects Research Society
Dec 9, 2021 · Fundamentals

Key Challenges in Designing Distributed Systems

Designing a distributed system involves overcoming major challenges such as heterogeneity, transparency, openness, concurrency, security, scalability, and fault tolerance, each of which must be addressed to build a reliable, extensible, and performant system.

concurrencydistributed systemsfault tolerance
0 likes · 7 min read
Key Challenges in Designing Distributed Systems
Cloud Native Technology Community
Cloud Native Technology Community
Dec 9, 2021 · Backend Development

Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices

This article thoroughly examines how Redis distributed locks work, the pitfalls of simple SETNX‑based locks such as deadlocks and premature expiration, presents robust solutions using expiration, unique identifiers, Lua scripts, discusses the Redlock algorithm and its controversy, compares Zookeeper locks, and offers practical guidance for safe lock usage.

Distributed LockLuaRedis
0 likes · 31 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
Code Ape Tech Column
Code Ape Tech Column
Dec 8, 2021 · Backend Development

Understanding Java 8 Stream API, Parallel Streams, and ForkJoinPool

This article explains Java 8 Stream API fundamentals, its composition, pipelining and internal iteration, details parallel stream execution using ForkJoinPool, discusses performance considerations, and provides practical code examples for creating and managing streams in backend development.

ForkJoinPoolJavaStream API
0 likes · 19 min read
Understanding Java 8 Stream API, Parallel Streams, and ForkJoinPool
BaiPing Technology
BaiPing Technology
Dec 6, 2021 · Mobile Development

Master Kotlin Coroutines: Simplify Async Code in Android

This article provides a comprehensive introduction to Kotlin Coroutines, covering their history, core concepts like CoroutineContext, Dispatchers, Job, Deferred, and suspend functions, and demonstrates practical Android usage with code examples for launching coroutines, handling concurrency, networking, Room database operations, timeouts, exception handling, and Flow-based timers.

AndroidCoroutinesFlow
0 likes · 21 min read
Master Kotlin Coroutines: Simplify Async Code in Android
Open Source Linux
Open Source Linux
Dec 2, 2021 · Backend Development

Mastering Rate Limiting: Strategies, Algorithms, and Real-World Implementations

This article explains why rate limiting is essential for system stability, outlines common throttling patterns such as circuit breaking, degradation, delayed processing, and privilege handling, and dives into popular algorithms like counter, leaky bucket, and token bucket with concrete Java and Nginx examples.

algorithmconcurrencydistributed systems
0 likes · 13 min read
Mastering Rate Limiting: Strategies, Algorithms, and Real-World Implementations
Programmer DD
Programmer DD
Nov 30, 2021 · Backend Development

Mastering Redis Distributed Locks with Jedis: A Hands‑On Guide

This tutorial demonstrates how to implement Redis distributed locks in Java using Jedis, covering lock creation with SETNX, expiration handling, safe unlocking via Lua scripts, and a high‑concurrency simulation of 100,000 users competing for limited stock.

Distributed LockJavaJedis
0 likes · 9 min read
Mastering Redis Distributed Locks with Jedis: A Hands‑On Guide
Python Crawling & Data Mining
Python Crawling & Data Mining
Nov 30, 2021 · Fundamentals

Master Python Multiprocessing: From Basics to Real-World File Copying

This article explains the differences between processes and threads, the advantages of using multiple processes in Python, and provides step‑by‑step code examples—including basic process creation, subclassing Process, inter‑process communication with queues, process pools, and a practical file‑copying case study—to help readers master multiprocessing for efficient concurrent programming.

Code examplesMultiprocessingconcurrency
0 likes · 11 min read
Master Python Multiprocessing: From Basics to Real-World File Copying