Tagged articles

concurrency

2269 articles · Page 12 of 23

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.

JavaThread SafetyThreadPool

0 likes · 17 min read

Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas

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.

BackendJavaRedis

0 likes · 8 min read

Evolution of Distributed Locks with Redis and Redisson

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.

JVMJavaconcurrency

0 likes · 8 min read

Lock Optimization and Escape Analysis in the JVM

Top Architect

Mar 26, 2023 · Backend Development

Implementing a Redis Distributed Lock with AOP and Automatic Renewal in Spring Boot

This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock in Spring Boot, covering annotation design, AOP pointcut definition, lock acquisition and release, automatic lock renewal with a scheduled executor, and practical testing results.

JavaSpring Bootconcurrency

0 likes · 12 min read

Implementing a Redis Distributed Lock with AOP and Automatic Renewal in Spring Boot

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.

C++MySQLNetworking

0 likes · 19 min read

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

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 kernelMutexRCU

0 likes · 26 min read

Understanding Synchronization Mechanisms and RCU in the Linux Kernel

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.

Design PatternEnumJava

0 likes · 14 min read

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

Architecture Digest

Mar 16, 2023 · Backend Development

Understanding Apache’s Three MPMs and Why Nginx Excels in High‑Concurrency Scenarios

The article explains Apache’s three processing models (prefork, worker, event), compares their resource usage with Nginx, and demonstrates how Nginx’s event‑driven, single‑threaded architecture achieves far higher concurrent connection capacity and better performance for web services.

ApacheBackend DevelopmentNginx

0 likes · 11 min read

Understanding Apache’s Three MPMs and Why Nginx Excels in High‑Concurrency Scenarios

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.

ExecutorServiceJavaScheduledExecutor

0 likes · 12 min read

Java ThreadPool Creation Methods and Usage Examples

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.

@AsyncCustomExecutorSpring

0 likes · 9 min read

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

Mike Chen's Internet Architecture

Mar 8, 2023 · Fundamentals

Deep Dive into Java synchronized: Usage, JVM Implementation, and Lock Upgrade Mechanisms

This article explains the Java synchronized keyword, its three usage forms, the underlying JVM object header and monitor structures, the lock acquisition process, and the progression from no lock through biased, lightweight, and heavyweight locks, illustrating how synchronization ensures thread safety.

JVMJavaLocks

0 likes · 6 min read

Deep Dive into Java synchronized: Usage, JVM Implementation, and Lock Upgrade Mechanisms

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

Mar 7, 2023 · Backend Development

Understanding Spring Boot's Tomcat Thread and Connection Limits: Configuration, Testing, and Concurrency Issues

This article explains how Spring Boot relies on Tomcat's thread and connection settings, demonstrates how to configure these parameters, runs a practical test to observe request handling limits, and discusses the resulting concurrency problems and their root causes.

PerformanceSpringBootTomcat

0 likes · 9 min read

Understanding Spring Boot's Tomcat Thread and Connection Limits: Configuration, Testing, and Concurrency Issues

Architect's Guide

Mar 6, 2023 · Fundamentals

Understanding the Maximum Concurrent TCP Connections on a Single Server

This article explains how TCP connections are identified, the theoretical limits for client (65,535) and server (up to 2^48) connections, and why practical concurrency is governed by system resources, port reuse, and server architecture rather than the raw port count.

LinuxServerconcurrency

0 likes · 10 min read

Understanding the Maximum Concurrent TCP Connections on a Single Server

Alibaba Cloud Developer

Mar 6, 2023 · Backend Development

Master Go Performance: Practical Optimization Tips, Tools, and Real-World Cases

This comprehensive guide walks Go developers through performance tuning fundamentals, recommended profiling tools, code-level optimizations, and real-world case studies, offering actionable insights to measure, diagnose, and improve CPU, memory, and concurrency efficiency in high‑throughput Go services.

BenchmarkingGoProfiling

0 likes · 41 min read

Master Go Performance: Practical Optimization Tips, Tools, and Real-World Cases

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.

BackendJavaRocketMQ

0 likes · 9 min read

Thread Creation Techniques in RocketMQ Source Code

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

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.

JavaStopMethodconcurrency

0 likes · 12 min read

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

Rare Earth Juejin Tech Community

Mar 2, 2023 · Backend Development

Understanding Go's Goroutine Scheduler and the GMP Model

This article explains how Go implements its own goroutine scheduler within the runtime, demonstrates it with sample code, and details the GMP (Goroutine‑M‑Processor) model, its scheduling strategies, and the evolution from the earlier GM model.

GMPGoconcurrency

0 likes · 8 min read

Understanding Go's Goroutine Scheduler and the GMP Model

Laravel Tech Community

Feb 28, 2023 · Operations

Understanding QPS, TPS, Concurrency, Throughput, and Related Performance Metrics

This article explains the definitions and differences of QPS and TPS, describes concurrency and throughput concepts, introduces related metrics such as PV, UV, DAU, MAU, and outlines key considerations for system performance testing and capacity planning.

QPSSystem DesignTPS

0 likes · 8 min read

Understanding QPS, TPS, Concurrency, Throughput, and Related Performance Metrics

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.

JVMJavaPerformance

0 likes · 9 min read

JVM Lock Optimization, Escape Analysis, and Synchronization Elimination

MaGe Linux Operations

Feb 24, 2023 · Operations

Understanding QPS vs TPS: Key Metrics for System Performance

This article explains the definitions and differences between QPS and TPS, explores related concepts such as concurrency, throughput, PV, UV, DAU, MAU, and outlines practical methods for evaluating system performance and capacity planning.

QPSTPSconcurrency

0 likes · 8 min read

Understanding QPS vs TPS: Key Metrics for System Performance

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.

DeprecatedExceptionJava

0 likes · 12 min read

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

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.

JVMJavaLock

0 likes · 20 min read

Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms

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

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.

ForkJoinPoolJavaParallelism

0 likes · 6 min read

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

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.

Backend DevelopmentClientRPC

0 likes · 15 min read

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

Su San Talks Tech

Feb 19, 2023 · Backend Development

Understanding Java Deadlocks: Causes, Example Code, and Detection Tools

This article explains what a deadlock is, demonstrates a simple Java deadlock example with code, outlines the four necessary conditions, and introduces four practical tools—jstack, jconsole, jvisualvm, and jmc—for diagnosing and resolving deadlocks in Java applications.

JConsoleJMCJVisualVM

0 likes · 9 min read

Understanding Java Deadlocks: Causes, Example Code, and Detection Tools

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.

QueueSpringBootconcurrency

0 likes · 19 min read

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

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 DevelopmentPerformanceconcurrency

0 likes · 8 min read

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

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.

AQSJVMJava

0 likes · 11 min read

Understanding Java Heavyweight Locks: ObjectMonitor vs AQS

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.

Asynchronous ProgrammingBackend DevelopmentCompletableFuture

0 likes · 5 min read

Turning Asynchronous Calls into Synchronous Responses with CompletableFuture in Java

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

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.

ExceptionHandlingExecutorServiceJava

0 likes · 14 min read

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

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.

JavaLockSpringBoot

0 likes · 21 min read

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

IT Services Circle

Jan 15, 2023 · Backend Development

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

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

InheritableThreadLocalJavaThreadLocal

0 likes · 13 min read

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

Selected Java Interview Questions

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 ModelRedisconcurrency

0 likes · 14 min read

Understanding Redis: Is It Truly Single-Threaded?

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.

DisruptorHigh PerformanceJava

0 likes · 12 min read

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

Architect's Guide

Jan 13, 2023 · Backend Development

Understanding ConcurrentHashMap Constructors, Insertion, Treeification, and Resizing in Java

This article explains the internal mechanisms of Java's ConcurrentHashMap, covering its constructors, element insertion via put and putVal, the sizeCtl variable, treeification of bins, counting operations, and the complex multi‑threaded resizing process, with detailed code examples.

ConcurrentHashMapData StructuresJava

0 likes · 21 min read

Understanding ConcurrentHashMap Constructors, Insertion, Treeification, and Resizing in Java

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

Jan 5, 2023 · Backend Development

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

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

DistributedSystemsJMeterMySQL

0 likes · 20 min read

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

政采云技术

Jan 5, 2023 · Databases

Design and Implementation of a Go-Based MySQL-to-MySQL Data Synchronization System

This article presents a Go-based MySQL-to-MySQL data synchronization solution built on go-mysql-transfer, detailing its architecture, multi‑threaded design, binlog handling, DDL/DML ordering, and code implementation for reliable, ordered, and fault‑tolerant replication.

GoMySQLconcurrency

0 likes · 20 min read

Design and Implementation of a Go-Based MySQL-to-MySQL Data Synchronization System

Tencent Cloud Developer

Jan 4, 2023 · Fundamentals

How Go’s select Statement Works Under the Hood: Compiler Optimizations and Runtime Mechanics

This article dissects Go’s select statement, explaining its I/O multiplexing purpose, compile‑time transformation via walkSelect and walkSelectCases, and the multi‑stage runtime algorithm in runtime.selectgo that handles various case patterns, lock ordering, polling randomness, and channel blocking behavior.

Gochannelcompiler

0 likes · 33 min read

How Go’s select Statement Works Under the Hood: Compiler Optimizations and Runtime Mechanics

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.

BackendLuaRedis

0 likes · 8 min read

Understanding Distributed Locks and Redis RedLock Implementation

Top Architect

Dec 30, 2022 · Backend Development

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

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

JavaSpring Bootconcurrency

0 likes · 9 min read

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

Su San Talks Tech

Dec 30, 2022 · Fundamentals

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

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

AQSConditionJava

0 likes · 30 min read

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

Code Ape Tech Column

Dec 29, 2022 · Backend Development

Batch Request Merging in Spring Boot to Reduce Database Connection Overhead

The article explains how to merge multiple user queries into a single batch request using a queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby reducing database connections and improving resource utilization while handling high‑concurrency scenarios.

Batch ProcessingCompletableFutureJava

0 likes · 13 min read

Batch Request Merging in Spring Boot to Reduce Database Connection Overhead

Spring Full-Stack Practical Cases

Dec 29, 2022 · Backend Development

Mastering Spring’s TaskExecutor and TaskScheduler: A Comprehensive Guide

This article explains Spring's TaskExecutor and TaskScheduler abstractions, their various implementations, how they decouple threading and scheduling from the deployment environment, and provides practical code examples for configuring and using them in Java applications.

JavaSpringTaskExecutor

0 likes · 10 min read

Mastering Spring’s TaskExecutor and TaskScheduler: A Comprehensive Guide

Xiao Lou's Tech Notes

Dec 23, 2022 · Backend Development

Batching Cluster Endpoint Requests in Go: Reduce Load with Minimal Code

This article explains how to batch multiple cluster endpoint requests in Go by using a token‑based queue and concurrent workers, dramatically reducing load on the registration center while requiring minimal changes to existing code.

Backend DevelopmentMicroservicesPerformance Optimization

0 likes · 7 min read

Batching Cluster Endpoint Requests in Go: Reduce Load with Minimal Code

Python Programming Learning Circle

Dec 12, 2022 · Fundamentals

Pond: An Efficient Python Object Pool Library

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

LibraryPerformanceconcurrency

0 likes · 11 min read

Pond: An Efficient Python Object Pool Library

Top Architect

Dec 10, 2022 · Backend Development

Implementing a High‑Concurrency Flash‑Sale System with Spring Boot and Redis List Queue

This article explains why common Redis‑based flash‑sale demos using WATCH or distributed locks are unreliable, and presents a simple, atomic solution that leverages Spring Boot's StringRedisTemplate with Redis list operations (LPUSH/RPOP) to achieve high‑concurrency秒杀 without explicit locking.

JavaSpring Bootconcurrency

0 likes · 8 min read

Implementing a High‑Concurrency Flash‑Sale System with Spring Boot and Redis List Queue

Code Ape Tech Column

Dec 9, 2022 · Backend Development

Disruptor: Simple Usage and Core Components of a High-Performance Lock-Free Queue in Java

This article introduces Java's Disruptor framework as a high-performance, lock-free queue, explains its core components such as RingBuffer, Sequencer, and WaitStrategy, provides sample code for producers and consumers, and discusses how it avoids lock contention and false sharing.

DisruptorJavaLock-Free

0 likes · 12 min read

Disruptor: Simple Usage and Core Components of a High-Performance Lock-Free Queue in Java

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.

CompletableFutureJavaSpring

0 likes · 16 min read

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

FunTester

Dec 8, 2022 · Backend Development

Why Random Numbers Drain CPU: Low‑Load Performance Test of Random vs Int vs AtomicInteger

A low‑load performance test compares three ways of selecting an array index—using Math.random(), a sequential int counter, and AtomicInteger—revealing that the random‑number approach consumes significantly more CPU while AtomicInteger spikes memory usage under higher loads.

CPU usageJavaatomicinteger

0 likes · 5 min read

Why Random Numbers Drain CPU: Low‑Load Performance Test of Random vs Int vs AtomicInteger

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

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

Shepherd Advanced Notes

Dec 2, 2022 · Fundamentals

Understanding Java Threads: Core Concepts, Lifecycle, and Synchronization

This article explains the fundamentals of Java threading, covering process vs thread differences, context switching, daemon and user threads, thread states, synchronization mechanisms, interruption handling, and deadlock detection with concrete code examples and visual illustrations.

JUCJavaThreadLifecycle

0 likes · 18 min read

Understanding Java Threads: Core Concepts, Lifecycle, and Synchronization

Tencent Cloud Developer

Nov 28, 2022 · Backend Development

Understanding Go Channels: Implementation, Usage, and Performance

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

GoPerformancechannel

0 likes · 29 min read

Understanding Go Channels: Implementation, Usage, and Performance

Thoughts on Knowledge and Action

Nov 27, 2022 · Fundamentals

How Java’s Memory Model Enables Thread Communication and Synchronization

The article explains Java’s concurrency mechanisms, detailing how threads communicate and synchronize via shared memory and the Java Memory Model (JMM), describing atomic actions, the MESI cache protocol, and key principles such as happens‑before, visibility, atomicity, and ordering.

Thread Synchronizationconcurrencyjmm

0 likes · 8 min read

How Java’s Memory Model Enables Thread Communication and Synchronization

Shepherd Advanced Notes

Nov 23, 2022 · Fundamentals

JUC Concurrency Basics: Java Memory Model and Its Three Key Properties—Visibility, Ordering, Atomicity

This article explains the Java Memory Model, distinguishes main memory from thread-local memory, and demonstrates how visibility, ordering, and atomicity affect concurrent programs through code examples, volatile and synchronized keywords, double‑checked locking, and the Happens‑Before rules.

AtomicityJavaVisibility

0 likes · 18 min read

JUC Concurrency Basics: Java Memory Model and Its Three Key Properties—Visibility, Ordering, Atomicity

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.

CodeExampleJavaStream

0 likes · 14 min read

Unveiling Java 8 Lambda: Inside the Stream Pipeline Mechanics

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.

ContextHttpClientconcurrency

0 likes · 15 min read

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

Tuanzi Tech Team

Nov 8, 2022 · Backend Development

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

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

DateTimeFormatterJavaSimpleDateFormat

0 likes · 10 min read

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

Java Architect Essentials

Nov 6, 2022 · Backend Development

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

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

AOPRedisScheduledExecutorService

0 likes · 12 min read

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

MaGe Linux Operations

Nov 4, 2022 · Backend Development

Mastering Go’s Context: Design, Implementation, and Best Practices

This article explains Go's context package, covering its motivation, core design (interface, implementations, methods), detailed source‑code analysis, and practical recommendations for safe and effective usage in concurrent applications.

Contextbest practicescancellation

0 likes · 12 min read

Mastering Go’s Context: Design, Implementation, and Best Practices

FunTester

Nov 4, 2022 · Backend Development

How to Implement Fixed QPS Asynchronous Tasks in Java with Semaphores and Thread Pools

This article explains a Java technique for limiting asynchronous task execution to a fixed queries‑per‑second rate using a Semaphore‑based thread pool, a LinkedBlockingQueue, and a daemon thread that manages task dispatch, shutdown, and idle waiting.

JavaQPSSemaphore

0 likes · 6 min read

How to Implement Fixed QPS Asynchronous Tasks in Java with Semaphores and Thread Pools

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.

GoMemorybest practices

0 likes · 18 min read

Avoid These Common Go Pitfalls Before They Crash Your Code

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.

ExecutorServiceFutureJava

0 likes · 9 min read

Master Java Multithreading and Custom Thread Pools in One Guide

Selected Java Interview Questions

Oct 25, 2022 · Backend Development

Implementing Inventory Deduction and Preventing Overselling in E‑commerce Projects

The article examines three approaches to handling inventory deduction in e‑commerce—single‑field MySQL, sharded MySQL rows, and Redis incrby—analyzes their concurrency drawbacks, and presents a robust Redis‑Lua script solution with distributed locking and Java implementation details.

BackendInventoryJava

0 likes · 9 min read

Implementing Inventory Deduction and Preventing Overselling in E‑commerce Projects

Cognitive Technology Team

Oct 23, 2022 · Databases

Understanding MySQL Concurrency: Read/Write Conflicts, MVCC, and Lock Strategies

This article explains MySQL's three concurrency types—read‑read, read‑write, and write‑write—describes how InnoDB uses shared/exclusive locks, MVCC snapshot reads, and ReadView metadata to ensure transaction isolation, and provides practical examples and lock‑based solutions for avoiding update loss.

InnoDBMVCCMySQL

0 likes · 7 min read

Understanding MySQL Concurrency: Read/Write Conflicts, MVCC, and Lock Strategies

Cognitive Technology Team

Oct 21, 2022 · Backend Development

Analyzing the Lost Exception Issue in ScheduledThreadPoolExecutor and Its Impact on Periodic Task Scheduling

This article examines how ScheduledThreadPoolExecutor can lose exception information and stop rescheduling periodic tasks when a task throws an exception, by walking through the source code flow, the runAndReset logic, and the resulting behavior.

ExceptionHandlingJavaScheduledThreadPoolExecutor

0 likes · 3 min read

Analyzing the Lost Exception Issue in ScheduledThreadPoolExecutor and Its Impact on Periodic Task Scheduling

Top Architect

Oct 20, 2022 · Backend Development

Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal

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

JavaRedisScheduledExecutorService

0 likes · 12 min read

Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal

FunTester

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.

BackendJavaQPS

0 likes · 6 min read

Controlling Java Async QPS with Semaphore and ThreadPool

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.

CopyOnWriteArrayListLinkedListList

0 likes · 20 min read

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

Java High-Performance Architecture

Oct 18, 2022 · Backend Development

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

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

JavaRedisScheduledExecutorService

0 likes · 13 min read

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

Top Architect

Oct 17, 2022 · Backend Development

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

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

AQSCASJava

0 likes · 11 min read

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

Cognitive Technology Team

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.

JavaScheduledThreadPoolExecutorThreadPool

0 likes · 5 min read

Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls

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.

BestPracticesJavaMemoryLeak

0 likes · 7 min read

Analysis of Java ThreadLocal Implementation and Usage Pitfalls

Aikesheng Open Source Community

Oct 15, 2022 · Databases

Weekly Tech Share Summary – Database Updates and SQL Auditing News

This weekly newsletter curates top community tech shares, featuring MySQL 8.0 updates, database localization insights, concurrency consistency strategies, a new SQL auditing tool release, development progress, upcoming plans, and invites community feedback on DBLE, DTLE, SQLE, and TXLE middleware.

MySQLSQL AuditingWeekly Summary

0 likes · 3 min read

Weekly Tech Share Summary – Database Updates and SQL Auditing News

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.

Language DesignRustconcurrency

0 likes · 10 min read

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

Top Architect

Oct 13, 2022 · Databases

Understanding Transaction Isolation Levels and Concurrency Issues in MySQL

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

ACIDDirty ReadLost Update

0 likes · 8 min read

Understanding Transaction Isolation Levels and Concurrency Issues in MySQL

MaGe Linux Operations

Oct 11, 2022 · Fundamentals

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

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

concurrencyg-p-m modelgoroutine

0 likes · 28 min read

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

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.

JavaPerformanceThreadPoolExecutor

0 likes · 10 min read

Seven Core Parameters of ThreadPoolTaskExecutor: Detailed Explanation and Best Practices

Su San Talks Tech

Oct 9, 2022 · Backend Development

Build a Self‑Sustaining Multithreaded Java Task with Graceful Shutdown

This article demonstrates how to create a perpetual multithreaded Java task using a custom thread‑pool utility, supports concurrent execution of multiple long‑running jobs, and implements an elegant shutdown that drains remaining work before terminating.

BackendGraceful ShutdownJava

0 likes · 12 min read

Build a Self‑Sustaining Multithreaded Java Task with Graceful Shutdown

MaGe Linux Operations

Oct 8, 2022 · Fundamentals

Should You Replace C/C++ with Rust? Pros, Cons, and Industry Trends

This article examines Rust's rapid rise, its safety‑focused design versus C/C++'s speed emphasis, real‑world adoption by major tech firms, and the ongoing debate about whether Rust can eventually supplant C and C++ for system‑level development.

c++concurrencylanguage adoption

0 likes · 9 min read

Should You Replace C/C++ with Rust? Pros, Cons, and Industry Trends

macrozheng

Sep 28, 2022 · Backend Development

Why Java 19 Virtual Threads Outperform Traditional Threads and Go Goroutines

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

GoJavaPerformance

0 likes · 22 min read

Why Java 19 Virtual Threads Outperform Traditional Threads and Go Goroutines

Su San Talks Tech

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.

BackendExecutorServiceJava

0 likes · 17 min read

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

Tencent Cloud Developer

Sep 23, 2022 · Backend Development

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

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

Design PatternsGoSource Code Analysis

0 likes · 18 min read

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

IT Services Circle

Sep 21, 2022 · Backend Development

Understanding HikariCP's ConcurrentBag: A Deep Dive into Lock‑Free Connection Pooling

This article explains how HikariCP's lock‑free ConcurrentBag manages database connections using ThreadLocal caches, a CopyOnWriteArrayList, AtomicInteger waiters, and a SynchronousQueue, and walks through the key code for borrowing and returning connections to improve Java multithreaded performance.

ConcurrentBagHikariCPJava

0 likes · 11 min read

Understanding HikariCP's ConcurrentBag: A Deep Dive into Lock‑Free Connection Pooling

Java Architect Essentials

Sep 19, 2022 · Backend Development

Unlocking Java Parallel Streams: When to Use, Performance Tips, and Pitfalls

This article explains Java parallel streams, shows how to replace manual thread handling with a one‑line parallelStream call, benchmarks its performance, discusses cases where it slows down, highlights shared‑variable hazards, and provides practical guidelines for effective use.

ForkJoinPoolJavaParallel Streams

0 likes · 12 min read

Unlocking Java Parallel Streams: When to Use, Performance Tips, and Pitfalls

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 SchedulingSpring Boot

0 likes · 25 min read

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

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.

@AsyncExecutorServiceJava

0 likes · 6 min read

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

Java High-Performance Architecture

Sep 18, 2022 · Backend Development

Master Java Concurrency: Synchronized, Locks, Wait vs Sleep, and Deadlock Explained

This article explains Java multithreading safety issues, demonstrates synchronized methods, blocks, static methods, mutex locks, deadlock scenarios, and the differences between wait() and sleep() with clear code examples and analysis of their effects on thread execution.

Javaconcurrencydeadlock

0 likes · 12 min read

Master Java Concurrency: Synchronized, Locks, Wait vs Sleep, and Deadlock Explained

MaGe Linux Operations

Sep 16, 2022 · Backend Development

Mastering Goroutine Limits: How to Control Go Concurrency Efficiently

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

Worker Poolchannelconcurrency

0 likes · 4 min read

Mastering Goroutine Limits: How to Control Go Concurrency Efficiently

Java High-Performance Architecture

Sep 16, 2022 · Backend Development

Mastering Asynchronous Calls in Spring Boot: From Sync to Async with @Async

This article explains the difference between synchronous and asynchronous calls, demonstrates a synchronous Task example, shows how to convert it to asynchronous execution with Spring Boot's @Async annotation, and introduces Future-based callbacks to coordinate concurrent tasks and measure total execution time.

@AsyncAsyncFuture

0 likes · 9 min read

Mastering Asynchronous Calls in Spring Boot: From Sync to Async with @Async

Top Architect

Sep 13, 2022 · Backend Development

Understanding the Three Core Issues of Java Concurrency: Division, Synchronization, and Mutual Exclusion

The article explains how to achieve million‑level concurrency in Java by focusing on three fundamental problems—task division, synchronization, and mutual exclusion—using real‑world analogies, diagrams, and concrete code examples to illustrate proper multithreaded design.

JavaThread Poolconcurrency

0 likes · 11 min read

Understanding the Three Core Issues of Java Concurrency: Division, Synchronization, and Mutual Exclusion

Sanyou's Java Diary

Sep 5, 2022 · Fundamentals

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

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

Immutableconcurrencysynchronization

0 likes · 10 min read

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

FunTester

Sep 5, 2022 · Backend Development

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

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

JavaQPSSpringBoot

0 likes · 8 min read

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

Top Architect

Sep 3, 2022 · Backend Development

Implementing Distributed Locks with Redis, Zookeeper, and etcd

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

RedisZooKeeperconcurrency

0 likes · 6 min read

Implementing Distributed Locks with Redis, Zookeeper, and etcd

MaGe Linux Operations

Sep 1, 2022 · Backend Development

Understanding Go Closures and Delayed Binding: Real‑World Cases and Experiments

This article explores Go language closures and their delayed binding behavior through seven illustrative cases, detailed experiments, and code examples, clarifying value vs reference passing, goroutine timing effects, and practical pitfalls for developers.

Goclosuresconcurrency

0 likes · 18 min read

Understanding Go Closures and Delayed Binding: Real‑World Cases and Experiments