BestHub
Sign in
Tagged articles
2072 articles
Page 10 of 21
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2023 · Backend Development

Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios

This article explores Java multithreading concepts, JVM safety tools, thread creation methods, coordination mechanisms, and practical scenarios such as parallel data aggregation, for‑loop conversion, map‑based processing, and multi‑threaded transaction handling, providing code examples and performance tips for backend developers.

CompletableFutureThreadPoolconcurrency
0 likes · 22 min read
Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios
Architecture Digest
Architecture Digest
Apr 21, 2023 · Backend Development

Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal

This article explains how to protect time‑consuming business operations by using Redis as a distributed lock, designing a custom @RedisLock annotation, applying Spring AOP to intercept methods, handling lock acquisition, expiration, renewal via a ScheduledExecutorService, and releasing the lock safely after execution.

Spring Bootaopconcurrency
0 likes · 12 min read
Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal
Top Architect
Top Architect
Apr 17, 2023 · Backend Development

Handling Redis Cache Pitfalls: Penetration, Avalanche, Breakdown, and Consistency with Bloom Filters and Distributed Locks

This article explains the four common Redis caching challenges—cache penetration, avalanche, breakdown, and data inconsistency—demonstrates their impact under high concurrency, and provides practical Java Spring Boot solutions including caching null objects, Bloom filters, distributed locks, random expiration, and delayed double‑delete strategies with full code examples.

BloomFilterCacheCacheInvalidation
0 likes · 28 min read
Handling Redis Cache Pitfalls: Penetration, Avalanche, Breakdown, and Consistency with Bloom Filters and Distributed Locks
IT Services Circle
IT Services Circle
Apr 10, 2023 · Fundamentals

Nine Common Pitfalls of Using Multithreading in Java Applications

Switching from single‑threaded synchronous code to multithreaded asynchronous execution can improve performance, but introduces nine major issues—including missing return values, data loss, ordering problems, thread‑safety, ThreadLocal anomalies, OOM risks, high CPU usage, transaction failures, and service crashes—each explained with Java examples and solutions.

concurrencyjavamultithreading
0 likes · 17 min read
Nine Common Pitfalls of Using Multithreading in Java Applications
JD Cloud Developers
JD Cloud Developers
Apr 5, 2023 · Backend Development

Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas

This article examines frequent mistakes when using Java thread pools—such as improper creation, unreasonable parameters, unreleased local pools, and unsafe concurrent operations—and provides detailed analysis, configuration guidelines, and best‑practice recommendations to prevent memory leaks, deadlocks, and performance issues.

Garbage CollectionThreadPoolconcurrency
0 likes · 17 min read
Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas
Architect
Architect
Apr 4, 2023 · Backend Development

Evolution of Distributed Locks with Redis and Redisson

This article walks through the step‑by‑step evolution of Redis‑based distributed lock implementations—from simple SETNX locking to atomic expiration, UUID‑based ownership, Lua‑scripted safe release, and finally using Redisson’s high‑level lock API—illustrating common pitfalls and robust solutions.

Backendconcurrencydistributed-lock
0 likes · 8 min read
Evolution of Distributed Locks with Redis and Redisson
Top Architect
Top Architect
Apr 3, 2023 · Backend Development

Lock Optimization and Escape Analysis in the JVM

This article explains how the JVM optimizes locking through spin locks, adaptive spinning, lock elimination, and lock coarsening, and describes escape analysis techniques that enable stack allocation, scalar replacement, and synchronization removal, illustrated with Java code examples and diagrams.

Escape AnalysisJVMconcurrency
0 likes · 8 min read
Lock Optimization and Escape Analysis in the JVM
IT Services Circle
IT Services Circle
Mar 20, 2023 · Fundamentals

Comprehensive Interview Review: Networking, TCP/IP, Epoll, Redis, MySQL MVCC, and C++ Concepts

This article compiles a detailed interview guide covering TCP/UDP differences, three‑way handshake and four‑way termination, flow and congestion control, select/poll/epoll mechanisms, zero‑copy techniques, Redis advantages and persistence, MySQL MVCC and repeatable‑read semantics, as well as core C++ topics and common algorithm questions.

NetworkingTCPc++
0 likes · 19 min read
Comprehensive Interview Review: Networking, TCP/IP, Epoll, Redis, MySQL MVCC, and C++ Concepts
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 17, 2023 · Operations

Understanding Synchronization Mechanisms and RCU in the Linux Kernel

Linux kernel synchronization requires protecting shared mutable state from concurrent access using primitives such as spinlocks, mutexes, read‑write locks, or lock‑less techniques like RCU, which copies data and waits for a grace period, each offering distinct performance, latency, and complexity trade‑offs.

Linux kernelRCUSpinlock
0 likes · 26 min read
Understanding Synchronization Mechanisms and RCU in the Linux Kernel
Selected Java Interview Questions
Selected Java Interview Questions
Mar 17, 2023 · Fundamentals

Double‑Checked Locking, Static Inner Class, and Enum Singleton Implementations in Java

This article explains three Java singleton implementations—double‑checked locking with volatile, static inner‑class holder, and enum singleton—detailing their thread‑safety, lazy initialization, and how they prevent issues such as instruction reordering, serialization, and reflection attacks.

Singletonconcurrencydesign pattern
0 likes · 14 min read
Double‑Checked Locking, Static Inner Class, and Enum Singleton Implementations in Java
Selected Java Interview Questions
Selected Java Interview Questions
Mar 15, 2023 · Backend Development

Java ThreadPool Creation Methods and Usage Examples

This article explains the seven ways to create Java thread pools, categorizes them by ThreadPoolExecutor and Executors, and provides detailed code examples for fixed-size, cached, scheduled, single‑thread, work‑stealing pools, as well as custom thread factories and task result handling.

ExecutorServiceScheduledExecutorThreadPool
0 likes · 12 min read
Java ThreadPool Creation Methods and Usage Examples
Java Architect Essentials
Java Architect Essentials
Mar 14, 2023 · Backend Development

Using @Async in Spring: Built‑in Thread Pools, Their Limitations, and Custom Thread‑Pool Configuration

The article explains how Spring's @Async annotation works, compares synchronous and asynchronous calls, reviews the built‑in executors such as SimpleAsyncTaskExecutor, discusses their drawbacks, and provides detailed guidance on creating custom thread pools via AsyncConfigurer, AsyncConfigurerSupport, or a TaskExecutor bean, including code examples.

AsyncCustomExecutorThreadPool
0 likes · 9 min read
Using @Async in Spring: Built‑in Thread Pools, Their Limitations, and Custom Thread‑Pool Configuration
Liangxu Linux
Liangxu Linux
Mar 7, 2023 · Fundamentals

Why 65,535 Isn’t the Real Limit for TCP Connections on Linux

The article explains that the 65,535 TCP port limit does not bound a Linux server’s concurrent connections, detailing how TCP connections are identified, the theoretical maximum of 2⁴⁸ connections for a server, and the practical constraints imposed by memory and file‑descriptor limits.

LinuxSocketTCP
0 likes · 11 min read
Why 65,535 Isn’t the Real Limit for TCP Connections on Linux
Code Ape Tech Column
Code Ape Tech Column
Mar 6, 2023 · Backend Development

Thread Creation Techniques in RocketMQ Source Code

This article explains how RocketMQ creates and manages threads, covering single‑thread creation via Runnable and Thread inheritance, the ServiceThread abstract class, ThreadPoolExecutor configuration, custom thread factories, and the importance of descriptive thread names for debugging.

BackendMessagingRocketMQ
0 likes · 9 min read
Thread Creation Techniques in RocketMQ Source Code
Selected Java Interview Questions
Selected Java Interview Questions
Mar 3, 2023 · Backend Development

Comprehensive Guide to Java CompletableFuture: Asynchronous Tasks, Callbacks, and Multi‑Future Composition

This article explains Java's CompletableFuture API introduced in JDK 8, covering how to create asynchronous tasks with supplyAsync and runAsync, use various callback methods such as thenApply, thenAccept, thenRun, whenComplete, handle, and combine multiple futures with thenCombine, allOf, anyOf, providing code examples and execution results.

AsyncCompletableFutureFutureComposition
0 likes · 16 min read
Comprehensive Guide to Java CompletableFuture: Asynchronous Tasks, Callbacks, and Multi‑Future Composition
Top Architect
Top Architect
Mar 3, 2023 · Backend Development

How to Stop a Java Thread: Methods, Code Samples, and Common Pitfalls

This article explains various ways to terminate a running Java thread, including using exit flags, interrupt(), deprecated stop()/suspend()/resume() methods, handling InterruptedException, while providing code examples and discussing the risks of forceful termination.

StopMethodThreadconcurrency
0 likes · 12 min read
How to Stop a Java Thread: Methods, Code Samples, and Common Pitfalls
Top Architect
Top Architect
Feb 28, 2023 · Fundamentals

JVM Lock Optimization, Escape Analysis, and Synchronization Elimination

This article explains how the JVM improves concurrency performance through lock optimization techniques such as spin locks, lock elimination, lock coarsening, and escape analysis, illustrating each concept with code examples and discussing related optimizations like stack allocation and scalar replacement.

Escape AnalysisJVMconcurrency
0 likes · 9 min read
JVM Lock Optimization, Escape Analysis, and Synchronization Elimination
Architect
Architect
Feb 23, 2023 · Fundamentals

How to Properly Stop a Java Thread: Methods, Examples, and Pitfalls

This article explains various ways to terminate a running Java thread, comparing safe flag‑based exit, the deprecated stop/suspend/resume methods, and the recommended interrupt approach, while demonstrating how to detect interruption status, handle exceptions, and avoid common pitfalls with code examples.

DeprecatedExceptionThread
0 likes · 12 min read
How to Properly Stop a Java Thread: Methods, Examples, and Pitfalls
JD Retail Technology
JD Retail Technology
Feb 21, 2023 · Fundamentals

Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms

This article explains the JVM object memory layout—including object header, instance data, and alignment padding—details the structure of the Mark Word and Klass Word, describes how monitors and the synchronized keyword work at the bytecode level, and covers lock states, inflation, bias revocation, and spin optimizations with practical code examples.

JVMLockMonitor
0 likes · 20 min read
Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms
58 Tech
58 Tech
Feb 21, 2023 · Backend Development

Design and Implementation of FairPushy: A Dart‑Based Dynamic Update Platform for Flutter

This article presents the architecture, technology choices, and practical implementation details of FairPushy—a Dart‑driven backend and Flutter dynamic‑update platform—covering server development, concurrency handling, ORM integration, automated build pipelines, and deployment strategies for seamless hot‑reloading of mobile applications.

BackendDARTDocker
0 likes · 17 min read
Design and Implementation of FairPushy: A Dart‑Based Dynamic Update Platform for Flutter
FunTester
FunTester
Feb 21, 2023 · Backend Development

Mastering Java ForkJoinPool: A Hands‑On Guide to Parallel Task Execution

The article introduces Java's ForkJoinPool for dividing large, compute‑intensive tasks into smaller subtasks, explains its suitability for performance testing scenarios such as high‑throughput QPS/RT data collection, and provides a complete Groovy‑based demo that defines a RecursiveTask, implements the compute method, and runs a sum calculation using a thread pool.

ForkJoinPoolParallelismPerformanceTesting
0 likes · 6 min read
Mastering Java ForkJoinPool: A Hands‑On Guide to Parallel Task Execution
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Feb 21, 2023 · Backend Development

Demystifying Go’s Built‑in RPC: From Demo to Deep Dive

This article walks through a hands‑on Go RPC demo, explains the underlying server and client mechanisms, explores registration, HTTP handling, request processing, object pooling, and the gob codec, and clarifies why Go includes RPC alongside HTTP.

RPCServerbackend-development
0 likes · 15 min read
Demystifying Go’s Built‑in RPC: From Demo to Deep Dive
Top Architect
Top Architect
Feb 9, 2023 · Backend Development

High-Concurrency Seckill Implementation in SpringBoot: Locking, Transaction, and Queue Strategies

This article demonstrates how to simulate high‑concurrency flash‑sale scenarios using SpringBoot, MySQL, and JMeter, and compares seven approaches—including lock‑based, AOP, pessimistic and optimistic locking, and queue‑based solutions such as BlockingQueue and Disruptor—to prevent overselling and improve performance.

DistributedQueueSeckill
0 likes · 19 min read
High-Concurrency Seckill Implementation in SpringBoot: Locking, Transaction, and Queue Strategies
21CTO
21CTO
Feb 8, 2023 · Backend Development

Why Go Is the Ideal Backend Language for High‑Performance Web Apps

This article explains how Go’s fast compilation, lightweight runtime, built‑in concurrency, strong type safety, and cross‑platform compatibility make it a compelling choice for building scalable, high‑performance backend services, and provides practical code examples to get started quickly.

backend-developmentconcurrencyperformance
0 likes · 8 min read
Why Go Is the Ideal Backend Language for High‑Performance Web Apps
Top Architect
Top Architect
Feb 7, 2023 · Fundamentals

Understanding Java Heavyweight Locks: ObjectMonitor vs AQS

This article explains the differences and similarities between Java's ObjectMonitor and the AbstractQueuedSynchronizer (AQS) implementations of heavyweight locks, covering their internal data structures, waiting queues, lock acquisition order, and how synchronized interacts with wait/notify mechanisms.

AQSJVMObjectMonitor
0 likes · 11 min read
Understanding Java Heavyweight Locks: ObjectMonitor vs AQS
FunTester
FunTester
Feb 7, 2023 · Backend Development

Turning Asynchronous Calls into Synchronous Responses with CompletableFuture in Java

This article demonstrates how to convert multiple asynchronous queries into a synchronous response using Java's CompletableFuture, providing step‑by‑step code examples in both Java and Groovy, explaining execution flow, timeout handling, and practical considerations for WebSocket‑like scenarios.

CompletableFutureasynchronous programmingbackend-development
0 likes · 5 min read
Turning Asynchronous Calls into Synchronous Responses with CompletableFuture in Java
IT Architects Alliance
IT Architects Alliance
Feb 3, 2023 · Backend Development

Preventing Overselling in High‑Concurrency Flash Sales: 7 Locking & Queue Strategies with SpringBoot

This article analyzes the overselling problem in high‑concurrency flash‑sale scenarios, demonstrates seven concrete solutions—including improved locks, AOP locks, pessimistic and optimistic database locks, and queue‑based approaches using BlockingQueue and Disruptor—provides full SpringBoot code, JMeter test results, and practical recommendations for reliable stock reduction.

BackendDisruptorJMeter
0 likes · 19 min read
Preventing Overselling in High‑Concurrency Flash Sales: 7 Locking & Queue Strategies with SpringBoot
Code Ape Tech Column
Code Ape Tech Column
Feb 2, 2023 · Backend Development

Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions

This article explains why tasks submitted to a Java ThreadPool via submit do not print exceptions, how to retrieve them using Future.get(), and presents three practical solutions—including try‑catch, Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread pool exceptions.

ExecutorServiceThreadPoolconcurrency
0 likes · 14 min read
Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions
Java High-Performance Architecture
Java High-Performance Architecture
Feb 1, 2023 · Backend Development

7 Proven Ways to Prevent Overselling in High‑Concurrency Flash Sales with Java

This article explores why simple @Transactional locking can still cause product overselling under high concurrency, then presents seven detailed Java/SpringBoot solutions—including improved locking, AOP, pessimistic and optimistic database locks, and queue‑based approaches—complete with code, performance tests and best‑practice recommendations.

LockSpringBootconcurrency
0 likes · 21 min read
7 Proven Ways to Prevent Overselling in High‑Concurrency Flash Sales with Java
IT Services Circle
IT Services Circle
Jan 15, 2023 · Backend Development

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

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

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

Understanding Redis: Is It Truly Single-Threaded?

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

Reactor Modelconcurrencydatabase
0 likes · 14 min read
Understanding Redis: Is It Truly Single-Threaded?
macrozheng
macrozheng
Jan 13, 2023 · Backend Development

Mastering Disruptor: Build a High‑Performance Java Message Queue in 8 Steps

This article introduces the Disruptor library, explains its core concepts such as Ring Buffer, Sequencer, and Wait Strategy, and provides a complete eight‑step Spring Boot example with code to create, publish, and consume high‑throughput messages in Java.

DisruptorMessage QueueSpring Boot
0 likes · 12 min read
Mastering Disruptor: Build a High‑Performance Java Message Queue in 8 Steps
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jan 9, 2023 · Backend Development

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

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

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

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

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

DistributedSystemsJMeterQueue
0 likes · 20 min read
Resolving Overselling in High‑Concurrency Flash Sale: Seven Locking and Queue Strategies in SpringBoot
Aikesheng Open Source Community
Aikesheng Open Source Community
Jan 3, 2023 · Backend Development

Understanding Distributed Locks and Redis RedLock Implementation

This article explains the concept of distributed locks, illustrates real‑world scenarios such as concurrent ATM transactions, and details how to implement reliable distributed locking with Redis using TTL keys, SETNX, Lua scripts, lock renewal, high‑availability considerations, and the RedLock algorithm.

BackendLuaRedlock
0 likes · 8 min read
Understanding Distributed Locks and Redis RedLock Implementation
Top Architect
Top Architect
Dec 30, 2022 · Backend Development

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

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

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

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

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

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

Pond: An Efficient Python Object Pool Library

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

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

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

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

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

How to Master High‑Performance Computing: 9 Practical Strategies

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

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

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

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

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

Understanding Go Channels: Implementation, Usage, and Performance

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

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

Unveiling Java 8 Lambda: Inside the Stream Pipeline Mechanics

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

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

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

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

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

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

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

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

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

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

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

Avoid These Common Go Pitfalls Before They Crash Your Code

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

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

Master Java Multithreading and Custom Thread Pools in One Guide

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

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

Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal

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

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

Controlling Java Async QPS with Semaphore and ThreadPool

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

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

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

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

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

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

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

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

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

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

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

Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls

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

Exception HandlingScheduledThreadPoolExecutorThreadPool
0 likes · 5 min read
Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls
Cognitive Technology Team
Cognitive Technology Team
Oct 15, 2022 · Fundamentals

Analysis of Java ThreadLocal Implementation and Usage Pitfalls

This article explains the internal workings of Java's ThreadLocal, including the ThreadLocalMap structure, weak reference handling, lazy initialization, and common pitfalls such as memory leaks in thread pools, and provides best‑practice guidelines for safe usage.

BestPracticesMemoryLeakThreadLocal
0 likes · 7 min read
Analysis of Java ThreadLocal Implementation and Usage Pitfalls
21CTO
21CTO
Oct 13, 2022 · Fundamentals

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

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

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

Understanding Transaction Isolation Levels and Concurrency Issues in MySQL

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

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

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

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

GoroutineRuntimeScheduler
0 likes · 28 min read
Inside Go’s Goroutine Scheduler: Concepts, Evolution, and Design
Cognitive Technology Team
Cognitive Technology Team
Oct 9, 2022 · Backend Development

Seven Core Parameters of ThreadPoolTaskExecutor: Detailed Explanation and Best Practices

This article explains the seven essential configuration parameters of Java's ThreadPoolTaskExecutor, covering thread creation, core and maximum pool sizes, keep‑alive policies, work queues, thread factories, rejection handlers, and practical usage tips with code examples and common pitfalls.

ThreadPoolExecutorThreadPoolTaskExecutorbest practices
0 likes · 10 min read
Seven Core Parameters of ThreadPoolTaskExecutor: Detailed Explanation and Best Practices
macrozheng
macrozheng
Sep 28, 2022 · Backend Development

Why Java 19 Virtual Threads Outperform Traditional Threads and Go Goroutines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mastering Goroutine Limits: How to Control Go Concurrency Efficiently

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

ChannelGoroutineWorker Pool
0 likes · 4 min read
Mastering Goroutine Limits: How to Control Go Concurrency Efficiently