BestHub
Sign in
Tagged articles
2072 articles
Page 13 of 21
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.

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

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

Distributed SystemsScalabilityconcurrency
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.

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

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

Distributed Systemsalgorithmconcurrency
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.

JedisSpring Bootconcurrency
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 ExamplesThreadconcurrency
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.

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

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

Happens-beforeJSR133Memory Model
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.

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

HibernateSQL Optimizationconcurrency
0 likes · 13 min read
How I Fixed Persistent Account Balance Mismatches with Pessimistic Locks and Hibernate
Selected Java Interview Questions
Selected Java Interview Questions
Nov 17, 2021 · Backend Development

Implementing Distributed Locks with Redis, Redisson, and Zookeeper in Java

This article explains the principles and practical implementations of distributed locks using Redis (SETNX and SET with expiration), Redisson's Java client, and Zookeeper's sequential ephemeral nodes, providing code examples, lock acquisition and release mechanisms, and a comparison of their advantages and drawbacks.

ZooKeeperconcurrencyjava
0 likes · 14 min read
Implementing Distributed Locks with Redis, Redisson, and Zookeeper in Java
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.

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

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

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

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

ChannelsError HandlingGo
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.

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

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

Redlockconcurrencydistributed-lock
0 likes · 32 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
FunTester
FunTester
Oct 19, 2021 · Backend Development

Mimicking Go’s ‘go’ Keyword in Java and Groovy with Thread Pools

This article explains how to achieve Go‑style asynchronous execution in Java and Groovy by leveraging closures, the java.util.function.Supplier interface, custom thread‑pool wrappers, and Phaser‑based synchronization, complete with practical code examples and a custom ThreadFactory implementation.

AsyncGroovyPhaser
0 likes · 7 min read
Mimicking Go’s ‘go’ Keyword in Java and Groovy with Thread Pools
Java Architect Essentials
Java Architect Essentials
Oct 18, 2021 · Backend Development

Understanding Synchronous and Asynchronous Calls in Spring Boot with @Async

This article explains the difference between synchronous and asynchronous method calls in Java, demonstrates a simple Spring Boot Task class with three time‑consuming methods, shows how to convert them to asynchronous execution using @Async and @EnableAsync, and illustrates how to coordinate completion with Future objects.

AsyncAsynchronousSpring Boot
0 likes · 7 min read
Understanding Synchronous and Asynchronous Calls in Spring Boot with @Async
Java Interview Crash Guide
Java Interview Crash Guide
Oct 18, 2021 · Backend Development

Why Thread Safety Fails in Java and How to Ensure It

This article explains how variable sharing in multithreaded Java programs leads to thread‑unsafe behavior, explores the JVM memory model and stack frame structure, and demonstrates practical ways to achieve thread safety by keeping variables thread‑local or using proxy objects.

JVMconcurrencyjava
0 likes · 10 min read
Why Thread Safety Fails in Java and How to Ensure It
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 10, 2021 · Databases

Understanding InnoDB Locking Mechanisms: Record Lock, Gap Lock, and Next-Key Lock

This article explains MySQL InnoDB's locking mechanisms—including record locks, gap locks, and next‑key locks—detailing how they work, their interaction with isolation levels such as Repeatable Read, and the principles, optimizations, and examples that illustrate their impact on concurrency and phantom reads.

InnoDBconcurrencydatabase
0 likes · 12 min read
Understanding InnoDB Locking Mechanisms: Record Lock, Gap Lock, and Next-Key Lock
MaGe Linux Operations
MaGe Linux Operations
Oct 9, 2021 · Fundamentals

Master Python Thread Synchronization: Locks, RLocks, Conditions, Events & Semaphores Explained

This article delves into Python's threading module, explaining thread safety, the role of various lock types—including Lock, RLock, Condition, Event, and Semaphore—along with their methods, usage patterns, common pitfalls like deadlocks, and practical code examples to illustrate proper synchronization techniques.

LocksSynchronizationconcurrency
0 likes · 25 min read
Master Python Thread Synchronization: Locks, RLocks, Conditions, Events & Semaphores Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 9, 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 JDK/JRE/JVM relationships, object creation methods, equality comparison, concurrency mechanisms, collections, thread pools, and I/O models, providing concise answers for quick reference.

CollectionsJVMThreadPool
0 likes · 14 min read
Common Java Interview Questions and Answers
DataFunTalk
DataFunTalk
Oct 7, 2021 · Big Data

Impala Architecture, Concurrency, CBO Join Optimization, and Storage Layer in Tencent Financial Big Data Scenarios

This article introduces Impala's overall architecture, storage options, key features, concurrency mechanisms, CBO‑based join optimization techniques, storage‑layer principles and data‑filtering strategies, and summarizes practical performance‑tuning experiences from Tencent's financial big‑data platform.

Big DataCBOImpala
0 likes · 12 min read
Impala Architecture, Concurrency, CBO Join Optimization, and Storage Layer in Tencent Financial Big Data Scenarios
Architect
Architect
Oct 4, 2021 · Backend Development

Common Pitfalls and Best Practices of Redis Distributed Locks

Redis distributed locks are widely used for ensuring mutual exclusion in distributed systems, but improper implementation can cause issues such as non‑atomic operations, forgotten releases, lock stealing, high contention, re‑entrancy problems, timeout handling, and master‑slave failures; this article explains each pitfall and offers practical solutions and code examples.

Lock Pitfallsconcurrencydistributed-lock
0 likes · 21 min read
Common Pitfalls and Best Practices of Redis Distributed Locks
Code Ape Tech Column
Code Ape Tech Column
Oct 4, 2021 · Backend Development

Understanding Synchronous and Asynchronous Calls in Spring Boot with @Async

This article explains the difference between synchronous and asynchronous method calls in Java, demonstrates how to implement synchronous tasks, then shows how to convert them to asynchronous execution using Spring Boot's @Async annotation, @EnableAsync configuration, and Future-based callbacks to measure total execution time.

AsyncBackendFuture
0 likes · 8 min read
Understanding Synchronous and Asynchronous Calls in Spring Boot with @Async
FunTester
FunTester
Sep 30, 2021 · Databases

Benchmarking Redis Map and INCR Operations with FunTester

This article demonstrates how to use the FunTester framework to benchmark Redis hash (map) and INCR commands, detailing the test design, Java code implementation, multithreaded execution, and summarizing the observed performance results.

Database BenchmarkFunTesterPerformance Testing
0 likes · 6 min read
Benchmarking Redis Map and INCR Operations with FunTester
Top Architect
Top Architect
Sep 29, 2021 · Backend Development

Implementing Distributed Locks with Redis and Redisson in Spring Boot

This article explains the challenges of high‑concurrency inventory deduction, demonstrates why simple synchronized locks fail in distributed environments, and walks through multiple solutions—from basic SETNX locks to Redisson’s advanced distributed lock implementation—highlighting pitfalls, expiration handling, and trade‑offs with alternatives like Zookeeper.

CAP theoremSpring Bootconcurrency
0 likes · 15 min read
Implementing Distributed Locks with Redis and Redisson in Spring Boot
Programmer DD
Programmer DD
Sep 29, 2021 · Backend Development

When and How to Use CountDownLatch and CyclicBarrier in Java

This article explains the purpose, usage, and real‑world scenarios of Java’s CountDownLatch and CyclicBarrier synchronization aids, illustrating their behavior with relatable analogies and providing guidance on when to apply each construct in multithreaded applications.

CountDownLatchCyclicBarrierconcurrency
0 likes · 4 min read
When and How to Use CountDownLatch and CyclicBarrier in Java
Architecture Digest
Architecture Digest
Sep 27, 2021 · Backend Development

Understanding Rate Limiting: Concepts, Algorithms, and Implementations

This article explains why rate limiting is needed in both physical venues and online systems, describes common limiting strategies such as circuit breaking, service degradation, delayed processing, and privileged handling, and details three major algorithms—counter, leaky bucket, and token bucket—along with practical Java and Nginx‑Lua code examples.

Distributed Systemsalgorithmconcurrency
0 likes · 13 min read
Understanding Rate Limiting: Concepts, Algorithms, and Implementations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 26, 2021 · Backend Development

Understanding Distributed Locks with Redis and Redisson: Concepts, Implementation, and RedLock Algorithm

This article explains what distributed locks are, their requirements, how to implement them using Redis commands and the Redisson library in Java, and introduces the RedLock algorithm for multi‑node fault‑tolerant locking, complete with code examples and practical considerations.

concurrencydistributed-lockjava
0 likes · 28 min read
Understanding Distributed Locks with Redis and Redisson: Concepts, Implementation, and RedLock Algorithm
Programmer DD
Programmer DD
Sep 26, 2021 · Backend Development

Mastering ThreadLocal in Java: When and How to Use It Safely

This article explains the two primary use cases of ThreadLocal in Java—providing each thread with its own exclusive object and sharing request‑scoped data across methods—while covering implementation details, memory‑leak risks, and best‑practice cleanup techniques.

ThreadLocalbackend-developmentconcurrency
0 likes · 10 min read
Mastering ThreadLocal in Java: When and How to Use It Safely
Top Architect
Top Architect
Sep 25, 2021 · Backend Development

Understanding Java ThreadPoolExecutor Rejection Policies and Their Implementations

This article explains the design of thread pools, when Java's ThreadPoolExecutor triggers rejection policies, details the four built‑in JDK policies and compares several third‑party implementations such as Dubbo, Netty, ActiveMQ and Pinpoint, helping developers choose the appropriate strategy for different scenarios.

RejectionPolicyThreadPoolExecutorconcurrency
0 likes · 13 min read
Understanding Java ThreadPoolExecutor Rejection Policies and Their Implementations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 25, 2021 · Fundamentals

Overview of Java Collection Framework and Core Concepts

This article provides a comprehensive overview of Java collections, covering the definition, characteristics, differences from arrays, advantages, common collection classes, underlying data structures, fail‑fast mechanism, detailed List, Set, Queue, and Map interfaces, as well as HashMap and ConcurrentHashMap implementations and best practices.

ArrayListCollectionsData Structures
0 likes · 30 min read
Overview of Java Collection Framework and Core Concepts
Code Ape Tech Column
Code Ape Tech Column
Sep 25, 2021 · Backend Development

Understanding Java 8 CompletionStage and CompletableFuture with Practical Examples

This article explains Java 8's CompletionStage API and its standard library implementation CompletableFuture, demonstrating its behavior through a series of concise examples that cover creation, chaining, asynchronous execution, custom executors, exception handling, cancellation, and composition of multiple stages.

BackendCompletableFutureCompletionStage
0 likes · 18 min read
Understanding Java 8 CompletionStage and CompletableFuture with Practical Examples
Python Programming Learning Circle
Python Programming Learning Circle
Sep 24, 2021 · Backend Development

Python Fundamentals, Concurrency, and Django Backend Development Essentials

This article provides a comprehensive overview of core Python concepts—including garbage collection, tuple versus list differences, process/thread/coroutine models, shallow and deep copying, the Global Interpreter Lock, sorting algorithms, closures, decorators, iterators, generators, and essential Django backend components such as WSGI, request lifecycle, middleware, ORM methods, caching, and REST framework.

BackendORMPython
0 likes · 18 min read
Python Fundamentals, Concurrency, and Django Backend Development Essentials
Programmer DD
Programmer DD
Sep 24, 2021 · Backend Development

What Happens When a Spring Boot ThreadPool Overflows? Learn Rejection Strategies

This article demonstrates how a Spring Boot thread pool behaves when its core size, max size, and queue capacity are exceeded by multiple asynchronous tasks, explains the resulting TaskRejectedException, and shows how to configure built‑in or custom rejection policies to handle such scenarios.

AsyncRejectionPolicySpring Boot
0 likes · 9 min read
What Happens When a Spring Boot ThreadPool Overflows? Learn Rejection Strategies
Top Architect
Top Architect
Sep 22, 2021 · Backend Development

Using ThreadPoolTaskExecutor and @Async for Asynchronous Processing in Spring Boot

This article explains how to configure a Spring Boot ThreadPoolTaskExecutor, enable asynchronous execution with @Async, create a custom visible executor to log pool statistics, and demonstrates the complete workflow with code examples and runtime logs for improving database insert performance.

AsyncSpring BootThreadPoolTaskExecutor
0 likes · 12 min read
Using ThreadPoolTaskExecutor and @Async for Asynchronous Processing in Spring Boot
Programmer DD
Programmer DD
Sep 18, 2021 · Backend Development

Isolating Spring @Async Thread Pools to Prevent Task Interference

This tutorial explains why the default shared thread pool for @Async tasks can cause unrelated services to block each other, and shows step‑by‑step how to configure separate thread pools for different async tasks in Spring Boot, complete with code examples and a unit test.

AsyncIsolationSpring Boot
0 likes · 10 min read
Isolating Spring @Async Thread Pools to Prevent Task Interference
Programmer DD
Programmer DD
Sep 14, 2021 · Backend Development

Boost Spring Boot Performance: Mastering Synchronous vs Asynchronous Calls

This article explains the difference between synchronous and asynchronous method calls in Spring Boot, shows how to convert blocking tasks into @Async methods, demonstrates unit‑test setups with CompletableFuture for proper coordination, and provides complete code examples to reduce overall execution time.

AsyncSpring Bootconcurrency
0 likes · 10 min read
Boost Spring Boot Performance: Mastering Synchronous vs Asynchronous Calls
Programmer DD
Programmer DD
Sep 14, 2021 · Backend Development

Why Spring MVC Controllers Are Singleton and How to Ensure Thread Safety

This article explains that Spring MVC controllers are singleton by default, illustrates the thread‑safety problems caused by shared instance variables with concrete code examples, and provides practical solutions such as avoiding state, using prototype scope, ThreadLocal, or AtomicInteger to make controllers safe under high concurrency.

ControllerSingletonSpring MVC
0 likes · 6 min read
Why Spring MVC Controllers Are Singleton and How to Ensure Thread Safety
Ops Development Stories
Ops Development Stories
Sep 13, 2021 · Backend Development

Mastering Java Locks: When to Use synchronized vs ReentrantLock

This article explains how Java locks solve concurrent access problems, compares the built‑in synchronized lock with ReentrantLock, describes their upgrade mechanisms, usage patterns, and scenarios, and offers guidance on choosing the appropriate lock for different environments.

LocksReentrantLockconcurrency
0 likes · 7 min read
Mastering Java Locks: When to Use synchronized vs ReentrantLock
MaGe Linux Operations
MaGe Linux Operations
Sep 10, 2021 · Backend Development

10 Common Go Mistakes That Kill Performance and How to Fix Them

This article lists ten typical Go programming pitfalls—from undefined enum values and misleading benchmarks to pointer misuse, slice initialization, error handling, context misuse, and goroutine closures—explaining why they hurt performance or correctness and offering concrete, idiomatic solutions.

Error HandlingGobest practices
0 likes · 17 min read
10 Common Go Mistakes That Kill Performance and How to Fix Them
ELab Team
ELab Team
Sep 10, 2021 · Frontend Development

How Browser Rendering and React Fiber Work Together to Prevent Frame Drops

This article explains the fundamentals of browser rendering, frame lifecycle, and dropped‑frame issues, then demonstrates how React Fiber and the requestIdleCallback API can be used to split heavy tasks, improve concurrency, and keep UI interactions smooth.

Browser RenderingFiberReact
0 likes · 22 min read
How Browser Rendering and React Fiber Work Together to Prevent Frame Drops
Programmer DD
Programmer DD
Sep 8, 2021 · Backend Development

How to Keep Redis Cache Consistent with Database: Strategies and Pitfalls

This article examines the consistency challenges when using Redis as a cache for database data, compares three update strategies, and presents practical solutions such as delayed double‑delete, retry mechanisms, and handling cache penetration, avalanche, and thread‑safety issues in Java.

Cache Consistencyconcurrencydatabase
0 likes · 18 min read
How to Keep Redis Cache Consistent with Database: Strategies and Pitfalls
Java Interview Crash Guide
Java Interview Crash Guide
Aug 31, 2021 · Backend Development

Mastering Java Thread Pools: Benefits, Workflow, Creation, and Tuning

This article provides a comprehensive guide to Java thread pools, covering their advantages, internal workflow, creation parameters, task submission methods, lifecycle states, shutdown procedures, performance tuning, monitoring metrics, and common pitfalls for developers seeking efficient concurrency management.

ThreadPoolconcurrencyjava
0 likes · 18 min read
Mastering Java Thread Pools: Benefits, Workflow, Creation, and Tuning
Java Tech Enthusiast
Java Tech Enthusiast
Aug 29, 2021 · Fundamentals

Java ArrayList: Constructors, add/addAll, set/get, and Iterator Mechanics

Java’s ArrayList offers a no‑arg constructor initializing an empty internal array, lazy default capacity of ten, and overloads for initial capacity or collection copying; its add/addAll methods ensure and grow capacity, set/get access elements, and its iterator tracks modCount to detect concurrent modifications.

ArrayListCollectionsDataStructure
0 likes · 16 min read
Java ArrayList: Constructors, add/addAll, set/get, and Iterator Mechanics
Top Architect
Top Architect
Aug 26, 2021 · Databases

Understanding MySQL Locks: Table, Row, and Page Locking Mechanisms

This article explains why MySQL uses locks, describes table‑level, row‑level, and page‑level locking, outlines lock types such as shared, exclusive, and intention locks, and provides practical usage examples and common troubleshooting tips for InnoDB and other storage engines.

InnoDBLocksconcurrency
0 likes · 7 min read
Understanding MySQL Locks: Table, Row, and Page Locking Mechanisms
FunTester
FunTester
Aug 24, 2021 · Backend Development

Can Async HTTP Requests Really Boost Test Performance? A Practical Java NIO Study

This article explores the practical impact of asynchronous HTTP requests in Java NIO‑based performance testing, detailing server setup with Moco, baseline measurements, various async implementations, and the trade‑offs between raw speed gains and CPU consumption.

Async HTTPHttpClientPerformance Testing
0 likes · 10 min read
Can Async HTTP Requests Really Boost Test Performance? A Practical Java NIO Study
Top Architect
Top Architect
Aug 19, 2021 · Backend Development

Understanding Spring @Async and Custom Thread Pools

This article explains how Spring's @Async annotation enables asynchronous method execution, compares synchronous and asynchronous flows, reviews the built‑in executors, highlights the drawbacks of the default SimpleAsyncTaskExecutor, and demonstrates how to configure a custom thread pool using AsyncConfigurer or TaskExecutor beans.

AsyncThreadPoolconcurrency
0 likes · 9 min read
Understanding Spring @Async and Custom Thread Pools
Wukong Talks Architecture
Wukong Talks Architecture
Aug 17, 2021 · Fundamentals

Core Java Multithreading Interview Questions and Concepts

This article compiles 16 classic Java multithreading interview questions covering high‑concurrency containers, CAS and ABA problems, volatile vs synchronized, the Java Memory Model, ThreadLocal drawbacks, AQS, thread‑pool architecture, queue types, sizing strategies, rejection policies, lifecycle management, and graceful shutdown techniques.

CASJMMThreadLocal
0 likes · 20 min read
Core Java Multithreading Interview Questions and Concepts