BestHub
Sign in
Tagged articles

concurrency

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

GoLock-FreeOptimization
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 modelGoconcurrency
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.

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

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

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

JVMJavabackend development
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.

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

JavaThread Safetyconcurrency
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.

Design PrinciplesSoftware Architecturebackend development
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.

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

PerformanceThread Safetybest practices
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.

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

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

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

PerformanceRefactoringbackend
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 LockingJVMJava
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.

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

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

CoroutinesKotlinSource Code Analysis
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.

ConfigurationJavaScheduled Tasks
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.

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

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

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

QPSSystem Designcapacity planning
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.

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

JavaThread Synchronizationconcurrency
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.

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

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

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

Securityconcurrencydistributed systems
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.

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

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

JavaRedisSpring Boot
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 examplesconcurrencymultiprocessing
0 likes · 11 min read
Master Python Multiprocessing: From Basics to Real-World File Copying
Senior Brother's Insights
Senior Brother's Insights
Nov 28, 2021 · Backend Development

Why @Transactional Fails with parallelStream and How to Fix It

An Excel import that partially succeeds reveals a hidden bug where Spring’s @Transactional annotation doesn’t roll back when using Java 8’s parallelStream, and the article explains the underlying thread‑local transaction mechanics, demonstrates the issue with code, and offers practical solutions and best‑practice guidelines.

Javabugconcurrency
0 likes · 8 min read
Why @Transactional Fails with parallelStream and How to Fix It
IT Architects Alliance
IT Architects Alliance
Nov 26, 2021 · Fundamentals

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS

This article explains the challenges of mutual exclusion and idempotency in distributed environments, compares thread‑level and process‑level solutions, describes the principles and typical implementations of distributed locks (Zookeeper, Redis, Tair, Cerberus), and introduces GTIS as a reliable idempotency framework.

JavaRedisZookeeper
0 likes · 34 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS
JD Tech
JD Tech
Nov 19, 2021 · Fundamentals

Understanding the Java Memory Model (JMM) and JSR‑133: Concepts, Guarantees, and Memory Barriers

This article explains the Java Memory Model (JMM) defined by JSR‑133, covering its core theory, the role of keywords like volatile, synchronized, and final, the underlying hardware memory models, cache‑coherence protocols, happens‑before rules, memory barriers, and how they ensure atomicity, visibility, and ordering in multithreaded Java programs.

JSR133Memory ModelVolatile
0 likes · 21 min read
Understanding the Java Memory Model (JMM) and JSR‑133: Concepts, Guarantees, and Memory Barriers
Java Tech Enthusiast
Java Tech Enthusiast
Nov 18, 2021 · Fundamentals

Pessimistic and Optimistic Locks in Java: Theory and Code Examples

The article compares Java's pessimistic locking mechanisms such as synchronized blocks and ReentrantLock with optimistic approaches like version checks, CAS‑based AtomicInteger and custom spin locks, illustrating each method through counter examples and discussing their performance trade‑offs and limitations.

CASJavaLocks
0 likes · 11 min read
Pessimistic and Optimistic Locks in Java: Theory and Code Examples
Senior Brother's Insights
Senior Brother's Insights
Nov 17, 2021 · Databases

How I Fixed Persistent Account Balance Mismatches with Pessimistic Locks and Hibernate

After repeatedly encountering account balance discrepancies in a financial system, I traced the issue to improper use of pessimistic locks and Hibernate caching, then resolved it by correcting lock placement, optimizing SQL queries, and switching to native SQL, sharing the detailed debugging steps and lessons learned.

MySQLSQL optimizationconcurrency
0 likes · 13 min read
How I Fixed Persistent Account Balance Mismatches with Pessimistic Locks and Hibernate
php Courses
php Courses
Nov 16, 2021 · Backend Development

Understanding PHP 8.1 Fibers: Theory, Practical Use, and Limitations

This article explains the concept of PHP 8.1 Fibers, compares synchronous and parallel HTTP request handling, shows how to implement simple asynchronous workflows with sockets or ReactPHP, and discusses why Fibers are low‑level building blocks rather than a complete async solution.

FibersPHPPHP8.1
0 likes · 8 min read
Understanding PHP 8.1 Fibers: Theory, Practical Use, and Limitations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 11, 2021 · Fundamentals

Understanding and Implementing the CLH Spin Lock in Java

This article explains the concepts of spin locks and mutexes, introduces the CLH lock as a fair spin lock used in Java's AbstractQueuedSynchronizer, and provides a detailed step‑by‑step walkthrough of its initialization, lock acquisition, release, testing, and common pitfalls with illustrative code and diagrams.

AQSCLHLockJava
0 likes · 17 min read
Understanding and Implementing the CLH Spin Lock in Java
FunTester
FunTester
Nov 5, 2021 · Backend Development

Master Java ReentrantLock: Simple Thread‑Safe Coding Without synchronized

This article introduces Java's ReentrantLock as an easy-to‑use alternative to synchronized, explains its core lock() and unlock() methods, demonstrates practical code examples, and covers advanced APIs such as tryLock, getQueueLength, isLocked, and getHoldCount for robust multithreaded programming.

JavaReentrantLockThread Safety
0 likes · 5 min read
Master Java ReentrantLock: Simple Thread‑Safe Coding Without synchronized
Programmer DD
Programmer DD
Nov 2, 2021 · Backend Development

Top Nginx Interview Questions: Master High‑Concurrency Web Server Concepts

This article compiles essential Nginx interview questions covering its definition, key features, differences from Apache, request handling mechanisms, master‑worker architecture, proxy types, module usage, and common configuration directives, providing a comprehensive guide for backend engineers preparing for technical interviews.

Interviewbackendconcurrency
0 likes · 14 min read
Top Nginx Interview Questions: Master High‑Concurrency Web Server Concepts
Wukong Talks Architecture
Wukong Talks Architecture
Nov 1, 2021 · Fundamentals

Go Language Overview: Features, Concurrency, Types, and Development Tools

This article presents an interview‑style overview of the Go programming language, covering its distinguishing features, typical use cases, concurrency model with goroutines and channels, basic syntax, data types, variable and constant declarations, error handling, and recommended development tools, all illustrated with code examples.

ChannelsGoconcurrency
0 likes · 13 min read
Go Language Overview: Features, Concurrency, Types, and Development Tools
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 1, 2021 · Backend Development

Understanding Java Concurrency Utilities: CyclicBarrier, CountDownLatch, Semaphore, and Exchanger

This article provides a comprehensive overview of Java's core concurrency utilities—CyclicBarrier, CountDownLatch, Semaphore, and Exchanger—explaining their purposes, internal mechanisms, constructors, usage patterns, and code examples to help developers master multithreaded programming.

CountDownLatchCyclicBarrierExchanger
0 likes · 11 min read
Understanding Java Concurrency Utilities: CyclicBarrier, CountDownLatch, Semaphore, and Exchanger
Wukong Talks Architecture
Wukong Talks Architecture
Oct 28, 2021 · Backend Development

Common Java Interview Questions and Answers

This article compiles a comprehensive list of frequently asked Java interview questions, covering topics such as the relationship between JDK/JRE/JVM, object creation methods, differences between == and equals, hashCode, String variants, synchronization mechanisms, lock implementations, collections, concurrency utilities, thread pools, and I/O models, providing concise explanations for each.

CollectionsInterviewJDK
0 likes · 14 min read
Common Java Interview Questions and Answers
Top Architect
Top Architect
Oct 27, 2021 · Databases

Understanding MySQL InnoDB Deadlocks: Types, Causes, and Prevention Strategies

This article explains MySQL InnoDB lock types, analyzes common deadlock scenarios with detailed SQL examples, describes the underlying locking mechanisms such as next‑key and gap locks, and provides practical prevention and resolution techniques for developers working with transactional databases.

DatabaseDeadlockInnoDB
0 likes · 13 min read
Understanding MySQL InnoDB Deadlocks: Types, Causes, and Prevention Strategies
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 23, 2021 · Backend Development

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

This article thoroughly examines how Redis distributed locks work, the safety challenges they face—including deadlocks, lock expiration, and node failures—explores the Redlock algorithm and its controversies, compares Redis with Zookeeper implementations, and offers practical guidelines and best‑practice solutions for reliable distributed locking.

RedisRedlockconcurrency
0 likes · 32 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
MaGe Linux Operations
MaGe Linux Operations
Oct 22, 2021 · Backend Development

Mastering Go’s sync Package: When and How to Use Its Locks

This article explains the different lock types provided by Go's sync package—including Mutex, RWMutex, Cond, WaitGroup, Once, Map, and Pool—detailing their use cases, code examples, and how they help manage concurrency safely and efficiently.

PoolRWMutexconcurrency
0 likes · 14 min read
Mastering Go’s sync Package: When and How to Use Its Locks