BestHub
Sign in
Tagged articles

concurrency

2269 articles · Page 10 of 23
LouZai
LouZai
Jan 22, 2024 · Backend Development

8 Interface Retry Mechanisms – Which One Should You Choose?

This article compares eight ways to implement retry logic for remote API calls—including simple loops, recursion, Apache HttpClient settings, Spring Retry, Resilience4j, a custom utility, thread‑pool asynchronous retries, and message‑queue based retries—while outlining best‑practice guidelines such as idempotency, retry limits, and concurrency control.

HTTP ClientJavaResilience4j
0 likes · 17 min read
8 Interface Retry Mechanisms – Which One Should You Choose?
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 22, 2024 · Backend Development

Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide

This comprehensive article explains Java thread lifecycle, state transitions, blocking and wake‑up mechanisms, differences between wait and sleep, various ways to create threads, thread‑pool architecture and rejection policies, lock implementations including synchronized, ReentrantLock, optimistic CAS, as well as ThreadLocal, concurrent collections, immutability, and the Java Memory Model, providing practical code examples and optimization tips for robust multithreaded programming.

ThreadPoolconcurrencysynchronization
0 likes · 23 min read
Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide
Selected Java Interview Questions
Selected Java Interview Questions
Jan 15, 2024 · Backend Development

Preventing Inventory Overselling in High‑Concurrency Scenarios: Java, Redis Distributed Lock, MySQL Row Lock, Optimistic Lock, and SQL Solutions

The article analyzes the inventory oversell problem caused by concurrent purchase requests and presents four backend solutions—including a Redis distributed lock, MySQL row lock, optimistic locking with version fields, and conditional SQL updates—illustrated with Java code and SQL examples to ensure data consistency.

JavaOptimistic LockRedis
0 likes · 10 min read
Preventing Inventory Overselling in High‑Concurrency Scenarios: Java, Redis Distributed Lock, MySQL Row Lock, Optimistic Lock, and SQL Solutions
FunTester
FunTester
Jan 14, 2024 · Backend Development

How to Build a More Flexible Java Phaser: Introducing FunPhaser

This article explains the limitations of java.util.concurrent.Phaser for large‑scale asynchronous tasks, presents a custom FunPhaser implementation that removes the party‑count ceiling, details its design, API, and usage examples, and compares it with the original Phaser approach.

Custom SynchronizerJavaPhaser
0 likes · 8 min read
How to Build a More Flexible Java Phaser: Introducing FunPhaser
Test Development Learning Exchange
Test Development Learning Exchange
Jan 14, 2024 · Fundamentals

Python Concurrency Techniques: Threads, Processes, Async, and Pools

This article introduces Python concurrency programming, explaining how to use multithreading, multiprocessing, thread and process pools, async/await, coroutines, and producer‑consumer models with code examples, helping developers improve performance and responsiveness for time‑consuming tasks and concurrent network requests.

asyncioconcurrencymultiprocessing
0 likes · 5 min read
Python Concurrency Techniques: Threads, Processes, Async, and Pools
Architect
Architect
Jan 13, 2024 · Backend Development

Mastering API Retry Strategies in Java: 8 Proven Techniques

This article walks through eight practical ways to implement retry mechanisms for remote API calls in Java, covering simple loops, recursion, Apache HttpClient settings, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries, while highlighting trade‑offs and best‑practice guidelines.

HttpClientJavaResilience4j
0 likes · 18 min read
Mastering API Retry Strategies in Java: 8 Proven Techniques
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 12, 2024 · Backend Development

Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development

This article explores Spring 5.3.23’s core utility classes—including ID generators, concurrent LRU cache, concurrency throttling, StopWatch timing, digest calculation, method invocation, reflection helpers, route matching, collection utilities, and placeholder parsing—providing code examples, usage guidelines, and best practices to boost backend development efficiency.

ID GeneratorJavaSpring
0 likes · 12 min read
Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development
MaGe Linux Operations
MaGe Linux Operations
Jan 7, 2024 · Backend Development

How Zookeeper Guarantees Reliable Session Management with Heartbeats

This article explains Zookeeper's session management mechanism, detailing why TCP alone is insufficient for client liveness detection, how Zookeeper implements its own heartbeat protocol, and the internal data structures and algorithms—including expiryMap and SessionTracker—that efficiently track and expire sessions.

JavaSession ManagementZooKeeper
0 likes · 12 min read
How Zookeeper Guarantees Reliable Session Management with Heartbeats
Shepherd Advanced Notes
Shepherd Advanced Notes
Jan 5, 2024 · Fundamentals

Master Java Collections: Avoid Common Pitfalls in Real-World Development

This article provides a comprehensive overview of the Java Collections Framework, explains frequent mistakes such as modifying collections during iteration or using toMap with null values, and introduces practical utility libraries like Hutool, Apache Commons Collections, and Guava to help developers write safer and more efficient code.

Apache CommonsCollectionsGuava
0 likes · 16 min read
Master Java Collections: Avoid Common Pitfalls in Real-World Development
php Courses
php Courses
Jan 4, 2024 · Backend Development

Using Swoole Coroutines to Achieve High Concurrency in PHP Applications

This article explains how to boost PHP application performance by installing the Swoole extension and using its coroutine API to run concurrent tasks such as HTTP requests and database queries, providing code examples and configuration steps for effective backend concurrency.

CoroutinesPHPSwoole
0 likes · 4 min read
Using Swoole Coroutines to Achieve High Concurrency in PHP Applications
FunTester
FunTester
Jan 3, 2024 · Backend Development

Design and Implementation of a Java Virtual Thread Asynchronous Task Framework

This article introduces a Java virtual‑thread based asynchronous task framework, detailing its design constraints, a thread‑safe task queue, daemon thread management, and overloaded execute methods for Runnable and Groovy Closure, along with code examples and performance testing considerations.

Daemon ThreadJavaTask Queue
0 likes · 9 min read
Design and Implementation of a Java Virtual Thread Asynchronous Task Framework
Nullbody Notes
Nullbody Notes
Dec 30, 2023 · Backend Development

Building a Simple In-Memory Redis Clone with Go

This article walks through the third part of an eleven‑article series that implements a functional Redis‑compatible in‑memory database in Go, detailing how the PING, AUTH, SELECT, SET and GET commands are parsed, routed and executed with concrete code examples.

BackendData StructuresGo
0 likes · 12 min read
Building a Simple In-Memory Redis Clone with Go
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 26, 2023 · Backend Development

Understanding Java Thread Pools: Creation, Execution Flow, Advantages, and Common Implementations

This article introduces Java thread pools, explaining their purpose, creation using ThreadPoolExecutor, execution flow, advantages such as resource reuse and management, common blocking queues, rejection policies, and provides multiple code examples of various pool types and a comprehensive monitoring example.

BlockingQueueExecutorServiceJava
0 likes · 11 min read
Understanding Java Thread Pools: Creation, Execution Flow, Advantages, and Common Implementations
IT Niuke
IT Niuke
Dec 24, 2023 · Fundamentals

Unveiling HashMap's Inner Mechanics: Design, Source Code Walkthrough, and Best Practices

This article dissects Java's HashMap by first explaining the collection framework's design goals—generality, scalability, performance, interoperability, readability, and thread safety—then walks through the core source code of HashMap (hash, put, resize, get, remove, treeify, etc.), illustrates LRU cache implementation, and finally offers practical usage tips, performance considerations, and version‑specific changes up to JDK 9.

Data StructuresHashMapJDK
0 likes · 28 min read
Unveiling HashMap's Inner Mechanics: Design, Source Code Walkthrough, and Best Practices
IT Services Circle
IT Services Circle
Dec 23, 2023 · Fundamentals

Java Multithreading: Processes, Threads, Creation Methods, and Common Controls

This article explains the fundamental concepts of processes and threads, uses a gaming analogy to illustrate their relationship, and details three ways to create threads in Java—extending Thread, implementing Runnable, and implementing Callable—along with common thread control methods such as sleep, join, and setDaemon.

JavaRunnablecallable
0 likes · 9 min read
Java Multithreading: Processes, Threads, Creation Methods, and Common Controls
IT Services Circle
IT Services Circle
Dec 21, 2023 · Backend Development

Comprehensive Backend Interview Guide: MySQL, Redis, Java Collections, Concurrency, and TCP

This article compiles essential backend interview questions and answers covering MySQL storage engines and indexes, Redis persistence modes, Java collection frameworks and HashMap internals, thread‑safe ConcurrentHashMap implementations, as well as HTTP message structure and TCP reliability mechanisms, providing a thorough review for candidates preparing for backend positions.

JavaMySQLRedis
0 likes · 26 min read
Comprehensive Backend Interview Guide: MySQL, Redis, Java Collections, Concurrency, and TCP
Java Captain
Java Captain
Dec 19, 2023 · Fundamentals

An Introduction to Java Multithreading: Basics, Techniques, and Applications

This article introduces Java multithreading, covering core concepts such as thread lifecycle, creation via Thread subclass and Runnable, synchronization mechanisms, thread pools, and practical applications in web, Android, game, and big data development, helping readers fully grasp multithreaded programming in Java.

JavaProgramming FundamentalsThreadPool
0 likes · 4 min read
An Introduction to Java Multithreading: Basics, Techniques, and Applications
FunTester
FunTester
Dec 12, 2023 · Backend Development

Understanding ResultSet Resource Release and Statement Concurrency in MySQL JDBC

This article examines how MySQL's JDBC driver manages ResultSet resource release, the internal close mechanisms, and the concurrency limitations of Statement objects, illustrated with code excerpts and a Groovy virtual‑thread demo that reveals runtime exceptions when ResultSets are accessed after implicit closure.

JDBCJavaMySQL
0 likes · 8 min read
Understanding ResultSet Resource Release and Statement Concurrency in MySQL JDBC
Nullbody Notes
Nullbody Notes
Dec 12, 2023 · Backend Development

Build a High‑Performance Go Cache Library (EasyCache) from Scratch

This article walks through implementing EasyCache, a Go‑based in‑memory cache with sharding, lock‑free concurrency, LRU eviction, and configurable expiration, explaining the underlying data structures, goroutine cleanup logic, and key handling with concrete code examples.

BackendGoLRU
0 likes · 9 min read
Build a High‑Performance Go Cache Library (EasyCache) from Scratch
macrozheng
macrozheng
Dec 12, 2023 · Backend Development

Mastering Retry Strategies in Java: 8 Proven Methods for Reliable API Calls

This article explains why retry mechanisms are essential for distributed Java applications and walks through eight practical implementations—including loop, recursion, Apache HttpClient, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries—plus best‑practice guidelines to avoid common pitfalls.

HttpClientJavaResilience4j
0 likes · 17 min read
Mastering Retry Strategies in Java: 8 Proven Methods for Reliable API Calls
ITPUB
ITPUB
Dec 11, 2023 · Backend Development

Go vs Rust in 2024: Which Language Should Power Your Projects?

This article compares Go and Rust across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers decide which language best fits their specific project requirements in 2024.

GoLanguage comparisonPerformance
0 likes · 12 min read
Go vs Rust in 2024: Which Language Should Power Your Projects?
Bitu Technology
Bitu Technology
Dec 8, 2023 · Backend Development

Why Every Java Developer Should Learn Scala – Key Advantages and Insights from the Scala Meetup

The article reviews a Scala meetup where experts compare Java and Scala, highlighting Scala's stronger expressiveness, type inference, pattern matching, safety, and concurrency features, and discusses real‑world adoption, developer experiences, and a recruitment opportunity for a Scala‑focused big‑data team.

Functional ProgrammingJavaPattern Matching
0 likes · 13 min read
Why Every Java Developer Should Learn Scala – Key Advantages and Insights from the Scala Meetup
360 Smart Cloud
360 Smart Cloud
Dec 7, 2023 · Fundamentals

Understanding Asynchronous and Event Mechanisms in Frontend and Backend Development

This article explains how asynchronous programming and event‑driven mechanisms work in both frontend JavaScript and backend Golang, covering the JavaScript event loop, macro‑ and micro‑tasks, goroutine‑based concurrency, and the kernel‑level epoll architecture that together enable efficient, non‑blocking execution.

BackendEpollasynchronous
0 likes · 17 min read
Understanding Asynchronous and Event Mechanisms in Frontend and Backend Development
Senior Brother's Insights
Senior Brother's Insights
Dec 3, 2023 · Backend Development

Rust vs Go in 2024: Which Language Wins Your Next Project?

This article compares Rust and Go across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers choose the most suitable language for their 2024 projects.

GoLanguage comparisonRust
0 likes · 13 min read
Rust vs Go in 2024: Which Language Wins Your Next Project?
IT Services Circle
IT Services Circle
Nov 28, 2023 · Backend Development

Comprehensive Java Interview Guide: Basics, Collections, Concurrency, Spring Boot, MySQL, and Network Concepts

This article provides a thorough overview of Java interview topics, covering core language fundamentals, collection frameworks, concurrency mechanisms, Spring Boot transaction handling, database indexing strategies, and network protocol comparisons, all presented in clear English with code examples and diagrams.

JavaMySQLNetworking
0 likes · 19 min read
Comprehensive Java Interview Guide: Basics, Collections, Concurrency, Spring Boot, MySQL, and Network Concepts
Nullbody Notes
Nullbody Notes
Nov 27, 2023 · Backend Development

Build a Simple Go RPC Framework – A Beginner-Friendly Project

This article walks Go beginners through designing and implementing a lightweight RPC framework called easyrpc, covering protocol design, message serialization, network communication, graceful server shutdown, client stub generation with reflect.MakeFunc, and concurrent request handling, with full source code on GitHub.

Code ExampleGoRPC
0 likes · 16 min read
Build a Simple Go RPC Framework – A Beginner-Friendly Project
Test Development Learning Exchange
Test Development Learning Exchange
Nov 23, 2023 · Backend Development

Python Multithreading Techniques for Concurrent API Calls, File Downloads, Test Execution, and Database Inserts

This article explains Python's multithreading model, covering thread creation, synchronization, data sharing, and provides practical code examples for sending concurrent API requests, downloading files, running test cases, reading files, and inserting records into a SQLite database.

APIFile DownloadPython
0 likes · 6 min read
Python Multithreading Techniques for Concurrent API Calls, File Downloads, Test Execution, and Database Inserts
Architecture Digest
Architecture Digest
Nov 23, 2023 · Backend Development

Using Redisson Distributed Locks with Custom Annotations in Java

This article explains how to apply Redisson's distributed lock in Java, demonstrates the basic lock and tryLock APIs, shows how to create a custom @DistributedLock annotation and an AOP aspect to handle locking automatically, and provides a practical usage example with two services.

AOPJavaRedisson
0 likes · 8 min read
Using Redisson Distributed Locks with Custom Annotations in Java
Top Architect
Top Architect
Nov 22, 2023 · Backend Development

Solving Product Overselling in High‑Concurrency Scenarios: Seven Implementation Methods

This article analyzes the overselling problem that occurs during high‑concurrency flash‑sale (seckill) operations and presents seven concrete solutions—including improved lock placement, AOP‑based locking, three types of database locks, optimistic locking, a blocking‑queue approach, and a Disruptor queue—complete with SpringBoot 2.5.7 code samples, performance test results, and practical recommendations.

DistributedSystemsSpringBootconcurrency
0 likes · 20 min read
Solving Product Overselling in High‑Concurrency Scenarios: Seven Implementation Methods
Architect
Architect
Nov 22, 2023 · Backend Development

Mastering CompletableFuture: Boosting Asynchronous Performance in Java

This article walks through the limitations of Java's Future, introduces CompletableFuture's richer asynchronous API, and demonstrates step‑by‑step how to refactor a shop‑detail page using parallel tasks, custom thread pools, and composition patterns to cut response time from seconds to under two.

CompletableFutureJavaPerformance
0 likes · 14 min read
Mastering CompletableFuture: Boosting Asynchronous Performance in Java
Liangxu Linux
Liangxu Linux
Nov 21, 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 internally binds, listens, and accepts connections, details the server’s main loop, request handling, routing logic, and shows how to customize connection and state hooks with concrete code examples.

BackendGoNetworking
0 likes · 8 min read
How Go’s Built‑in HTTP Server Handles Connections and Requests
政采云技术
政采云技术
Nov 21, 2023 · Backend Development

Why Do We Need Thread Pools?

Thread pools are essential for managing concurrent tasks efficiently, reducing resource overhead by reusing threads instead of creating new ones for each task, which is crucial for handling high-volume operations like exporting large datasets to Excel.

Backend DevelopmentJavaThread Pools
0 likes · 13 min read
Why Do We Need Thread Pools?
Cognitive Technology Team
Cognitive Technology Team
Nov 19, 2023 · Backend Development

Resolving Task Overlap and Scheduling Issues in Quartz with DisallowConcurrentExecution and Distributed Locks

This article explains why Quartz jobs can overlap when their execution time exceeds the trigger interval, demonstrates how to prevent concurrent execution with the @DisallowConcurrentExecution annotation, discusses distributed lock and idempotency solutions for clusters, and covers thread‑pool limits, exception handling, and a complete Java demo.

DisallowConcurrentExecutionJavaJob Scheduling
0 likes · 5 min read
Resolving Task Overlap and Scheduling Issues in Quartz with DisallowConcurrentExecution and Distributed Locks
Java High-Performance Architecture
Java High-Performance Architecture
Nov 19, 2023 · Backend Development

Boost Java Performance with Disruptor: A Hands‑On Guide to High‑Throughput Queues

This article introduces the high‑performance Java library Disruptor, explains its core concepts such as Ring Buffer, Sequence, and Wait Strategy, and provides a step‑by‑step demo with Maven configuration, code examples, and test results to help developers implement fast, lock‑free producer‑consumer queues.

DisruptorHigh PerformanceJava
0 likes · 12 min read
Boost Java Performance with Disruptor: A Hands‑On Guide to High‑Throughput Queues
Selected Java Interview Questions
Selected Java Interview Questions
Nov 18, 2023 · Backend Development

A Comprehensive Guide to Java CompletableFuture: Replacing Future and CountDownLatch with Elegant Asynchronous Patterns

This article explains Java's Future and CompletableFuture APIs, demonstrates how to replace blocking Future.get() and CountDownLatch patterns with CompletableFuture, shows creation methods, result retrieval options, callback chains, exception handling, task composition techniques, and provides best‑practice recommendations for thread‑pool usage.

CompletableFutureExceptionHandlingFuture
0 likes · 22 min read
A Comprehensive Guide to Java CompletableFuture: Replacing Future and CountDownLatch with Elegant Asynchronous Patterns
Code Ape Tech Column
Code Ape Tech Column
Nov 18, 2023 · Backend Development

Understanding ThreadLocal, ScopedValue, and StructuredTaskScope in Java

This article explains the ThreadLocal mechanism, its memory‑leak pitfalls, introduces the new ScopedValue feature in JDK 20 as a safer alternative, and demonstrates practical Spring and virtual‑thread examples using StructuredTaskScope for modern Java backend concurrency.

JavaScopedValueStructuredTaskScope
0 likes · 22 min read
Understanding ThreadLocal, ScopedValue, and StructuredTaskScope in Java
AI Illustrated Series
AI Illustrated Series
Nov 16, 2023 · Fundamentals

Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives

This article provides a comprehensive, step‑by‑step analysis of Go’s core concepts—including nil handling, the context package, string and rune internals, unsafe pointers, memory alignment, WaitGroup, semaphores, channels, slices, map implementations, sync.Map, garbage collection, and reflection—illustrated with concrete code examples and detailed reasoning.

ContextGoMemory
0 likes · 30 min read
Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives
MaGe Linux Operations
MaGe Linux Operations
Nov 15, 2023 · Backend Development

Mastering Go’s Context: How to Control Goroutine Lifecycles and Cancel Operations

This article explains the purpose and design of Go’s Context, how it propagates cancellation, deadlines, and values across goroutine trees, and demonstrates using the context package’s functions such as Background, WithCancel, WithDeadline, WithTimeout, and WithValue to manage request‑scoped state effectively.

Contextcancellationconcurrency
0 likes · 11 min read
Mastering Go’s Context: How to Control Goroutine Lifecycles and Cancel Operations
JD Tech
JD Tech
Nov 13, 2023 · Databases

Analysis of MySQL Lock Mechanisms and Deadlock Scenarios

This article examines MySQL's various lock types—including shared, exclusive, gap, next‑key, and insert‑intention locks—illustrates how they interact during concurrent transactions, analyzes a real‑world deadlock incident, and provides recommendations for preventing similar concurrency issues in high‑traffic systems.

LocksMySQLconcurrency
0 likes · 19 min read
Analysis of MySQL Lock Mechanisms and Deadlock Scenarios
dbaplus Community
dbaplus Community
Nov 9, 2023 · Fundamentals

Mastering Java Locks: From Pessimistic to Distributed and Optimizations

This article explains the full spectrum of Java locking mechanisms—including pessimistic, optimistic, distributed, reentrant, spin, read/write, fair vs. non‑fair, JVM lock states, and optimization techniques—detailing their principles, use‑cases, SQL/Redis examples, and performance trade‑offs.

JVMLocksPerformance
0 likes · 16 min read
Mastering Java Locks: From Pessimistic to Distributed and Optimizations
php Courses
php Courses
Nov 8, 2023 · Backend Development

Implementing Thread Pools and Coroutines in PHP

This article explains how to implement low‑level thread pools and coroutine mechanisms in PHP, providing detailed code examples that demonstrate creating a ThreadPool class, managing worker threads, and using generator‑based coroutines to achieve high‑performance, concurrent execution.

PHPPerformanceThread Pool
0 likes · 5 min read
Implementing Thread Pools and Coroutines in PHP
IT Services Circle
IT Services Circle
Nov 7, 2023 · Backend Development

Understanding ThreadLocal Memory Leaks and How to Prevent Them

This article explains the internal structure of ThreadLocal, identifies scenarios where ThreadLocal can cause memory leaks—especially in thread‑pool environments—analyzes the root causes, and provides practical techniques such as using remove() and expungeStaleEntry() to avoid these leaks.

JavaMemory LeakThread Pool
0 likes · 11 min read
Understanding ThreadLocal Memory Leaks and How to Prevent Them
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 3, 2023 · Backend Development

Unlock Massive Concurrency in Java with Virtual Threads and Structured Concurrency

This article introduces Java virtual threads, compares them with traditional platform threads, demonstrates multiple creation and execution patterns, showcases performance benefits through code examples, and explains structured concurrency as a preview feature for building high‑throughput, scalable backend applications.

JavaSpring BootStructured Concurrency
0 likes · 15 min read
Unlock Massive Concurrency in Java with Virtual Threads and Structured Concurrency
Sanyou's Java Diary
Sanyou's Java Diary
Nov 2, 2023 · Backend Development

How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Limits

This article explores how many concurrent requests a SpringBoot application can process with default settings, demonstrating a hands‑on demo, analyzing Tomcat’s thread‑pool defaults, comparing Undertow behavior, and revealing how configuration parameters like core threads, max threads, queue size, and connection limits affect throughput.

SpringBootThreadPoolTomcat
0 likes · 18 min read
How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Limits
php Courses
php Courses
Nov 2, 2023 · Backend Development

Handling Concurrent Access and Race Conditions in PHP

This article explains essential techniques for managing concurrent access and race conditions in PHP, covering mutex locks, semaphores, atomic operations, queue-based processing, database access optimization, and transaction management to improve system reliability and performance.

MutexPHPSemaphore
0 likes · 5 min read
Handling Concurrent Access and Race Conditions in PHP
Architect
Architect
Nov 1, 2023 · Backend Development

Mastering Distributed Locks with Redis: From Basics to Advanced Solutions

This article examines why local locks fail in distributed micro‑service environments, introduces Redis‑based distributed locking, walks through five incremental lock designs—from a simple SETNX implementation to a Lua‑script atomic solution—highlighting each scheme's trade‑offs, code examples, and practical pitfalls.

JavaLuaMicroservices
0 likes · 18 min read
Mastering Distributed Locks with Redis: From Basics to Advanced Solutions
Amap Tech
Amap Tech
Nov 1, 2023 · Backend Development

Gaode Go Ecosystem Evolution, Cloud‑Native Serverless Practices, and Project Refactoring Experience

The article details Gaode’s journey of building a high‑performance Go ecosystem that scaled from zero to tens of millions of QPS, comparing Go with Java and Erlang, outlining cloud‑native serverless architecture, and sharing real‑world refactoring and optimization case studies such as a million‑QPS rendering gateway and a Go‑based sharding middleware.

GCGoMicroservices
0 likes · 34 min read
Gaode Go Ecosystem Evolution, Cloud‑Native Serverless Practices, and Project Refactoring Experience
Java High-Performance Architecture
Java High-Performance Architecture
Oct 31, 2023 · Backend Development

Master Redisson Distributed Locks in Java: Features, Code & Spring Boot

This article introduces Redisson, a Java framework built on Redis for distributed systems, detailing its extensive features such as distributed objects, locks, rate limiters, and task scheduling, and provides step‑by‑step guidance on integrating Redisson’s distributed lock into Spring Boot applications with code examples.

JavaRedisRedisson
0 likes · 11 min read
Master Redisson Distributed Locks in Java: Features, Code & Spring Boot
政采云技术
政采云技术
Oct 31, 2023 · Fundamentals

Understanding Java Threads, Thread Models, and Scheduling

This article explains what threads are, how Java maps its threads to operating‑system thread models (1:1, N:1, N:M), the differences between kernel and user threads, thread scheduling, context switching, priority handling, and includes sample Java code to compare serial and multithreaded execution.

Javaconcurrencymultithreading
0 likes · 19 min read
Understanding Java Threads, Thread Models, and Scheduling
Sanyou's Java Diary
Sanyou's Java Diary
Oct 30, 2023 · Backend Development

Mastering API Retry Strategies in Java: 8 Proven Techniques

This article presents eight practical ways to implement retry mechanisms for third‑party API calls in Java, covering simple loops, recursion, built‑in HttpClient handlers, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries, plus best‑practice guidelines.

HttpClientMessageQueueResilience4j
0 likes · 17 min read
Mastering API Retry Strategies in Java: 8 Proven Techniques
FunTester
FunTester
Oct 30, 2023 · Backend Development

How to Build a High‑Performance Object Pool for Multithreaded Systems

This article explores the motivation, design, implementation, and performance testing of a high‑performance object pool that reduces allocation overhead in multithreaded environments by using thread‑local storage, freelists, and lock‑optimized global resources.

C++Performance Optimizationcacheline alignment
0 likes · 25 min read
How to Build a High‑Performance Object Pool for Multithreaded Systems
Sanyou's Java Diary
Sanyou's Java Diary
Oct 26, 2023 · Backend Development

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

Explore the fundamentals and advanced techniques of asynchronous programming in Java, from basic thread creation and thread pools to Future, FutureTask, CompletableFuture, and Spring Boot’s @Async annotation, including practical code examples, event handling, and message queue integration for high‑throughput systems.

Asynchronous ProgrammingCompletableFutureFuture
0 likes · 17 min read
Master Asynchronous Java: Threads, Futures, CompletableFuture & @Async
FunTester
FunTester
Oct 26, 2023 · Fundamentals

Mastering Java Locks: Reentrant, Synchronized, ReadWrite, and Spin Locks Explained

This article provides a comprehensive guide to Java locking mechanisms, covering ReentrantLock, synchronized, ReadWriteLock, and spin locks, with detailed code examples, performance considerations, common use cases, and best practices to ensure thread safety, avoid deadlocks, and optimize concurrency in multithreaded applications.

JavaLocksReadWriteLock
0 likes · 17 min read
Mastering Java Locks: Reentrant, Synchronized, ReadWrite, and Spin Locks Explained
FunTester
FunTester
Oct 24, 2023 · Backend Development

Using java.util.concurrent.locks.ReentrantLock: Blocking, Interruptible, and Timed Locks in Java

This article explains thread safety in Java multithreading, introduces the ReentrantLock class from java.util.concurrent.locks, demonstrates blocking, interruptible, and timed lock usage with code examples, discusses best practices, fairness, reentrancy, and performance considerations for effective concurrency control.

JavaReentrantLockThread Safety
0 likes · 8 min read
Using java.util.concurrent.locks.ReentrantLock: Blocking, Interruptible, and Timed Locks in Java
Liangxu Linux
Liangxu Linux
Oct 21, 2023 · Backend Development

Why Nginx Doesn’t Fall Victim to the Thundering Herd Problem

This article explains the thundering herd phenomenon in multi‑process servers, walks through Nginx’s master‑worker architecture and its use of epoll, and compares three practical mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—complete with code excerpts and configuration examples.

BackendEpollNginx
0 likes · 9 min read
Why Nginx Doesn’t Fall Victim to the Thundering Herd Problem
Test Development Learning Exchange
Test Development Learning Exchange
Oct 21, 2023 · Backend Development

10 Practical Python Multiprocessing Scenarios for Inter‑Process Communication

This article presents ten practical Python multiprocessing examples demonstrating various inter‑process communication techniques—including pipes, queues, shared memory, managers, events, semaphores, condition variables, and shared counters—to help developers implement concurrent data exchange and synchronization across processes.

Interprocess CommunicationPythonconcurrency
0 likes · 6 min read
10 Practical Python Multiprocessing Scenarios for Inter‑Process Communication
Code Ape Tech Column
Code Ape Tech Column
Oct 20, 2023 · Backend Development

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

This article explains why exceptions submitted to a Java ThreadPool via submit are not printed, 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 · 15 min read
Handling Exceptions in Java ThreadPool: submit vs execute and Practical Solutions
vivo Internet Technology
vivo Internet Technology
Oct 18, 2023 · Backend Development

Understanding JDK ThreadLocal and Netty FastThreadLocal: Implementation, Advantages, and Best Practices

The article compares JDK ThreadLocal and Netty FastThreadLocal, detailing their implementations, performance trade‑offs, and memory‑leak risks, illustrates a real‑world HTTPS bug caused by missing remove() calls, and recommends always cleaning up ThreadLocal values while noting FastThreadLocal’s O(1) access may not always outperform the JDK version.

FastThreadLocalJavaMemoryLeak
0 likes · 17 min read
Understanding JDK ThreadLocal and Netty FastThreadLocal: Implementation, Advantages, and Best Practices
Top Architecture Tech Stack
Top Architecture Tech Stack
Oct 17, 2023 · Backend Development

Implementing Distributed Locks with Redis: Problems and Solutions

This article explains how Redis can be used to implement distributed locks, outlines common pitfalls such as non‑atomic operations, lock expiration, incorrect unlocking, lack of re‑entrancy and waiting mechanisms, and presents Lua scripts, Java examples, and cluster‑level considerations to mitigate these issues.

JavaLuaRedis
0 likes · 10 min read
Implementing Distributed Locks with Redis: Problems and Solutions
21CTO
21CTO
Oct 15, 2023 · Backend Development

Rust vs Go for Backend Development: Which Language Wins?

This article compares Rust and Go across performance, language features, concurrency, memory safety, ecosystem, learning curve, and real‑world use cases to help backend developers choose the most suitable language for their projects.

Backend DevelopmentGoPerformance
0 likes · 19 min read
Rust vs Go for Backend Development: Which Language Wins?
Cognitive Technology Team
Cognitive Technology Team
Oct 11, 2023 · Fundamentals

Gracefully Stopping a Java Thread and the Difference Between isInterrupted() and interrupted()

The deprecated Thread.stop method should never be used; instead, Java threads are stopped gracefully by using a volatile stop flag or interrupting blocked threads, handling InterruptedException, and distinguishing between Thread.isInterrupted() (read‑only) and Thread.interrupted() (clears the flag).

Graceful ShutdownJavaconcurrency
0 likes · 4 min read
Gracefully Stopping a Java Thread and the Difference Between isInterrupted() and interrupted()
Java Backend Technology
Java Backend Technology
Oct 9, 2023 · Backend Development

How to Merge Requests in Spring Boot to Reduce DB Load and Boost Performance

This article explains how to combine multiple user queries into a single database request using a queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, demonstrating code implementations, handling Java 8 CompletableFuture timeout limitations, and showing performance gains through request merging under high concurrency.

Batch ProcessingJavaSpring Boot
0 likes · 15 min read
How to Merge Requests in Spring Boot to Reduce DB Load and Boost Performance
Test Development Learning Exchange
Test Development Learning Exchange
Oct 8, 2023 · Backend Development

Python Multiprocessing for Parallel Tasks and API Automation

This article explains Python's multiprocessing module, compares it with multithreading, outlines its benefits for CPU utilization and resource isolation, and provides five practical code examples demonstrating concurrent task execution, parallel calculations, data processing, API requests, and test case automation.

API-testingPythonconcurrency
0 likes · 6 min read
Python Multiprocessing for Parallel Tasks and API Automation
Cognitive Technology Team
Cognitive Technology Team
Oct 5, 2023 · Backend Development

Lock‑Free Concurrency in Java: CAS, volatile and JUC Utilities

This article explains how Java achieves lock‑free concurrency using CAS and volatile for optimistic locking, discusses its advantages and drawbacks such as the ABA problem and contention hotspots, and presents solutions including versioned CAS classes and contention‑reduction techniques provided by the JUC package.

CASJUCJava
0 likes · 6 min read
Lock‑Free Concurrency in Java: CAS, volatile and JUC Utilities
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 5, 2023 · Backend Development

Mastering Java Unsafe: Low-Level Memory Tricks and Atomic Operations

This article introduces Java's sun.misc.Unsafe class, explains its memory, CAS, thread, class, and object manipulation APIs, shows how to obtain an Unsafe instance, and provides practical code examples for low‑level operations such as field offsets, compare‑and‑swap, object allocation, and custom atomic counters.

JavaLow-Level Programmingatomic-operations
0 likes · 9 min read
Mastering Java Unsafe: Low-Level Memory Tricks and Atomic Operations
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 29, 2023 · Backend Development

How to Cut API Latency from 5 s to 0.5 s with CompletableFuture Async Optimizations

The article explains how to dramatically reduce the response time of an API that must call multiple downstream services by converting serial calls into parallel ones using Java 8's CompletableFuture, covering its relationship to Future, core APIs, task composition, exception handling, and practical best‑practice recommendations.

Asynchronous ProgrammingCompletableFutureJava 8
0 likes · 20 min read
How to Cut API Latency from 5 s to 0.5 s with CompletableFuture Async Optimizations
Architect
Architect
Sep 28, 2023 · Databases

How to Pick the Best Storage Engine for High‑Throughput Browsing Records: Redis, MySQL or Tair?

This article walks through a real‑world e‑commerce scenario where billions of daily browsing events generate over 100K TPS writes, evaluates storage options on reliability, cost, read/write performance and implementation difficulty, and ultimately recommends Tair after detailed analysis of List, Sorted‑Set and Hash structures, code examples, and concurrency controls.

RedisStorageTair
0 likes · 15 min read
How to Pick the Best Storage Engine for High‑Throughput Browsing Records: Redis, MySQL or Tair?
Programmer DD
Programmer DD
Sep 28, 2023 · Backend Development

Master Java 21 Virtual Threads: Creation, Usage, and Best Practices

This article explains Java 21's virtual threads, their lightweight nature, and provides step‑by‑step code examples for creating and managing them via static builders, ExecutorService, and thread factories, helping developers improve concurrency and scalability in Java applications.

JavaJava 21Thread API
0 likes · 6 min read
Master Java 21 Virtual Threads: Creation, Usage, and Best Practices
macrozheng
macrozheng
Sep 27, 2023 · Backend Development

Master Java CompletableFuture: From Basics to Advanced Async Patterns

This comprehensive guide explains Java's CompletableFuture API, covering its fundamentals, creation methods, chaining operations, exception handling, and best practices for parallel execution, while providing clear code examples and performance tips for building efficient asynchronous workflows in backend development.

Asynchronous ProgrammingCompletableFutureFuture
0 likes · 20 min read
Master Java CompletableFuture: From Basics to Advanced Async Patterns
Architect
Architect
Sep 25, 2023 · Backend Development

Using @Async in Spring: Default Thread Pools, Custom Thread Pools, and Best Practices

Spring's @Async annotation enables asynchronous method execution, but its default SimpleAsyncTaskExecutor creates a new thread per task, leading to resource issues; the article explains built‑in executors, their drawbacks, and how to implement custom thread pools via AsyncConfigurer, AsyncConfigurerSupport, or a custom TaskExecutor for better control.

@AsyncJavaSpring
0 likes · 8 min read
Using @Async in Spring: Default Thread Pools, Custom Thread Pools, and Best Practices
Java High-Performance Architecture
Java High-Performance Architecture
Sep 25, 2023 · Backend Development

Master Distributed Locks with Redisson: Deep Dive into Java High‑Performance Architecture

This article explains the concept of distributed locks for ensuring data consistency in clustered environments, outlines common implementation approaches, and provides a comprehensive guide to using Redisson in Java—including Maven setup, YAML configuration, core source‑code analysis, Lua scripts for lock and unlock operations, and practical test cases.

JavaLuaRedis
0 likes · 15 min read
Master Distributed Locks with Redisson: Deep Dive into Java High‑Performance Architecture
JD Retail Technology
JD Retail Technology
Sep 22, 2023 · Fundamentals

Master Go Basics: From Variables to Concurrency in One Guide

This article provides a comprehensive, beginner‑friendly walkthrough of Go language fundamentals, covering variable and constant declarations, zero values, functions with multiple returns and variadic parameters, struct‑based OOP, non‑intrusive interfaces, slices, maps, goroutines, channels, and the simple error‑handling model with defer, panic, and recover.

Gobasicsconcurrency
0 likes · 24 min read
Master Go Basics: From Variables to Concurrency in One Guide
DeWu Technology
DeWu Technology
Sep 20, 2023 · Fundamentals

Understanding ZGC: Architecture, Key Features, and Execution Cycle

ZGC, introduced in JDK 11, is a non‑generational, highly concurrent Java garbage collector that uses colored pointers and load barriers to achieve sub‑10 ms pause times—even on terabyte‑scale heaps—while limiting throughput loss to under 15 % through three brief stop‑the‑world phases and four concurrent phases.

JVMPerformanceZGC
0 likes · 17 min read
Understanding ZGC: Architecture, Key Features, and Execution Cycle