BestHub
Sign in
Tagged articles

concurrency

2156 articles · Page 10 of 22
Top Architect
Top Architect
Sep 6, 2023 · Backend Development

Using Redisson for Distributed Locks in Java: Configuration, Code Samples, and Source‑Code Analysis

This article explains how distributed locks solve data‑consistency problems in clustered environments, introduces Redisson as a Redis‑based locking library, provides Maven and YAML configuration, shows Java code for Redisson setup and test cases, and analyses the underlying Lua scripts and source‑code mechanisms.

Distributed LockJavaLua Script
0 likes · 18 min read
Using Redisson for Distributed Locks in Java: Configuration, Code Samples, and Source‑Code Analysis
政采云技术
政采云技术
Sep 6, 2023 · Fundamentals

Understanding Threads, Multithreading, and Virtual Threads in Java

This article explains the concept of threads in computer science, demonstrates how Java encapsulates threads with the Thread class, shows basic and multithreaded examples, introduces thread pools and their management, and details the new virtual thread model introduced by Project Loom for high‑throughput, low‑overhead concurrency.

JDKJavaThreads
0 likes · 15 min read
Understanding Threads, Multithreading, and Virtual Threads in Java
Java Architect Essentials
Java Architect Essentials
Sep 4, 2023 · Backend Development

Using CompletableFuture for Asynchronous Programming in Java: Examples and Best Practices

This article explains Java asynchronous programming by first showing the limitations of the JDK5 Future interface, then demonstrating how CountDownLatch can coordinate tasks, and finally presenting CompletableFuture creation, result retrieval, callback chaining, exception handling, and multi‑task composition with practical code examples.

CompletableFutureExceptionHandlingFuture
0 likes · 20 min read
Using CompletableFuture for Asynchronous Programming in Java: Examples and Best Practices
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 4, 2023 · Frontend Development

Controlling Concurrent Requests in JavaScript with Promise.all, Promise.race, and async/await

This article explains how to manage multiple asynchronous HTTP requests in modern web development by using Promise.all, Promise.race, async/await, manual counters, and third‑party libraries, providing complete code examples and best‑practice recommendations for limiting concurrency and improving application performance.

Async/AwaitJavaScriptPromise
0 likes · 8 min read
Controlling Concurrent Requests in JavaScript with Promise.all, Promise.race, and async/await
Selected Java Interview Questions
Selected Java Interview Questions
Aug 31, 2023 · Backend Development

How to Solve SimpleDateFormat Thread Safety Issues in High-Concurrency Scenarios

This article presents several common solutions for addressing the thread‑safety problem of Java's SimpleDateFormat in high‑concurrency environments, including using local variables, synchronized blocks, Lock, ThreadLocal, Java 8 DateTimeFormatter, and Joda‑Time, and evaluates their performance and suitability.

DateTimeFormatterJavaSimpleDateFormat
0 likes · 17 min read
How to Solve SimpleDateFormat Thread Safety Issues in High-Concurrency Scenarios
政采云技术
政采云技术
Aug 31, 2023 · Backend Development

Understanding Java ThreadLocal: Principles, Implementation, and Best Practices

ThreadLocal provides each Java thread with its own isolated variable copy, and this article explains its underlying mechanism, core methods (set, get, remove), internal ThreadLocalMap structure, practical code examples, common usage scenarios, and important considerations such as memory leaks and proper cleanup.

BackendJavaMemoryLeak
0 likes · 12 min read
Understanding Java ThreadLocal: Principles, Implementation, and Best Practices
macrozheng
macrozheng
Aug 25, 2023 · Backend Development

How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Thread Pool Secrets

This article explores the interview question of how many concurrent requests a SpringBoot project can process by building a minimal demo, measuring Tomcat and Undertow thread pool limits, analyzing default configurations, and showing how container settings and annotations like @Async affect the actual request capacity.

PerformanceUndertowconcurrency
0 likes · 19 min read
How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Thread Pool Secrets
JD Cloud Developers
JD Cloud Developers
Aug 24, 2023 · Backend Development

Mastering Java Locks: From ReentrantLock to Distributed Redisson & Zookeeper

This article explains the fundamentals and practical usage of various Java locking mechanisms—including ReentrantLock, synchronized, ReentrantReadWriteLock, and the Atomic and Concurrent families—then explores distributed lock solutions such as Redisson’s multiple lock types and Zookeeper/Curator, comparing their performance, consistency, and suitability for different scenarios.

JavaLocksZookeeper
0 likes · 22 min read
Mastering Java Locks: From ReentrantLock to Distributed Redisson & Zookeeper
Su San Talks Tech
Su San Talks Tech
Aug 24, 2023 · Backend Development

Simplify JWT Token Handling in Spring Using Custom Annotations & ThreadLocal

This article walks through the evolution of a Spring‑based JWT token validation solution, from passing HttpServletRequest into service methods to using a custom @NeedToken annotation, reflection, a base class, and finally ThreadLocal to ensure each request’s token is safely isolated in high‑concurrency environments.

AOPJWTJava
0 likes · 13 min read
Simplify JWT Token Handling in Spring Using Custom Annotations & ThreadLocal
FunTester
FunTester
Aug 24, 2023 · Backend Development

How to Fix Critical Bugs in a Go Goroutine Pool and Boost Scaling Efficiency

This article analyzes several bugs discovered in a Go goroutine pool implementation—incorrect active count, mismatched execution counters, slow scaling during QPS spikes, and inefficient recycling—and presents detailed code fixes and redesigns to achieve accurate metrics and faster, more graceful worker management.

BackendBug FixGo
0 likes · 11 min read
How to Fix Critical Bugs in a Go Goroutine Pool and Boost Scaling Efficiency
JD Tech
JD Tech
Aug 23, 2023 · Fundamentals

Go Language Basics: Syntax, Variables, Control Flow, OOP, Concurrency, and Error Handling

This article introduces Go to developers familiar with other object‑oriented languages, covering the language definition, basic syntax such as variable and constant declarations, control structures, functions with multiple returns and variadic parameters, data structures like arrays, slices and maps, struct‑based object‑orientation, interfaces, goroutine‑based concurrency, channels, mutexes, and the simple error‑handling model using error, defer, panic, and recover.

FunctionsGoVariables
0 likes · 25 min read
Go Language Basics: Syntax, Variables, Control Flow, OOP, Concurrency, and Error Handling
Python Programming Learning Circle
Python Programming Learning Circle
Aug 21, 2023 · Backend Development

Python Multithreading for Web Scraping: Concepts, Code Samples, and Performance Comparison

This tutorial explains process and thread fundamentals, compares single‑threaded and multithreaded Python crawlers, provides complete code examples for both approaches, and demonstrates how converting a single‑threaded scraper to multithreading can significantly reduce execution time when handling large data volumes.

Web Scrapingconcurrencythreading
0 likes · 9 min read
Python Multithreading for Web Scraping: Concepts, Code Samples, and Performance Comparison
Selected Java Interview Questions
Selected Java Interview Questions
Aug 20, 2023 · Backend Development

Understanding Daemon and User Threads in Java

This article explains the concepts of daemon and user threads in Java, how to set a thread as daemon or user using Thread.setDaemon, the differences in lifecycle behavior, appropriate use cases, and includes example code demonstrating each type and their impact on JVM termination.

Daemon ThreadJavaThreads
0 likes · 5 min read
Understanding Daemon and User Threads in Java
Deepin Linux
Deepin Linux
Aug 18, 2023 · Fundamentals

Design and Implementation of a High‑Concurrency Memory Pool in C++

This article presents a comprehensive design and implementation of a high‑concurrency memory pool in C++, covering concepts such as fixed‑size block allocation, thread‑local caches, central and page caches, lock‑free techniques, span management, and performance benchmarking against standard malloc.

C++PerformanceThread Cache
0 likes · 57 min read
Design and Implementation of a High‑Concurrency Memory Pool in C++
360 Quality & Efficiency
360 Quality & Efficiency
Aug 18, 2023 · Backend Development

Performance Testing and Scalability Evaluation of a Miop‑Based Push Service

This report details the design, deployment, and extensive performance testing of a Miop protocol‑based push service, describing the test environment, methodology, multi‑stage load tests up to one million concurrent connections, observed metrics, encountered issues, and recommendations for ensuring stability and scalability.

MiopPush ServiceRedis
0 likes · 10 min read
Performance Testing and Scalability Evaluation of a Miop‑Based Push Service
Top Architect
Top Architect
Aug 17, 2023 · Backend Development

Thread Communication in Java: volatile, wait/notify, CountDownLatch, ReentrantLock+Condition, and LockSupport

This article explains five Java thread‑communication techniques—volatile variables, Object.wait()/notify(), CountDownLatch, ReentrantLock with Condition, and LockSupport—providing code examples and detailed explanations of how each method works and its synchronization behavior, including sample programs that add elements to a list, demonstrate notification timing, and show how locks are acquired and released.

CountDownLatchJavaLockSupport
0 likes · 11 min read
Thread Communication in Java: volatile, wait/notify, CountDownLatch, ReentrantLock+Condition, and LockSupport
Architect
Architect
Aug 16, 2023 · Backend Development

5 Practical Ways to Implement Thread Communication in Java

This article compares five Java thread‑communication techniques—volatile flag, Object.wait()/notify(), CountDownLatch, ReentrantLock with Condition, and LockSupport—by presenting concrete code examples, explaining their underlying mechanisms, and discussing their advantages and drawbacks.

CountDownLatchJavaLockSupport
0 likes · 13 min read
5 Practical Ways to Implement Thread Communication in Java
JD Tech
JD Tech
Aug 15, 2023 · Backend Development

Comprehensive Guide to Java Performance Optimization: Code and Design Strategies

Performance optimization, crucial for user experience, reliability, and resource efficiency, is explored through code and design techniques—from CPU and JVM considerations to caching, preloading, false sharing mitigation, inlining, async processing, and lock granularity—providing practical examples and actionable insights for Java backend developers.

Backend DevelopmentPerformance optimizationcode optimization
0 likes · 32 min read
Comprehensive Guide to Java Performance Optimization: Code and Design Strategies
Architect's Tech Stack
Architect's Tech Stack
Aug 13, 2023 · Backend Development

Handling Exceptions in Java Thread Pools: submit vs execute and Custom Strategies

This article explains why tasks submitted with ExecutorService.submit silently swallow exceptions, how ExecutorService.execute prints them, and presents three practical solutions—including try‑catch, a custom ThreadFactory with UncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread‑pool errors in Java.

ExceptionHandlingJavaconcurrency
0 likes · 14 min read
Handling Exceptions in Java Thread Pools: submit vs execute and Custom Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Aug 11, 2023 · Databases

Introduction to MySQL Locks and Their Types

This article explains the purpose, classification, and implementation of MySQL locks—including global, table, page, row, intention, and gap/record/next-key locks—as well as optimistic and pessimistic locking strategies, providing code examples and usage scenarios for ensuring data consistency in concurrent transactions.

DatabaseInnoDBLocks
0 likes · 11 min read
Introduction to MySQL Locks and Their Types
Architecture Digest
Architecture Digest
Aug 10, 2023 · Fundamentals

Instruction Reordering and Ordering in Java Double-Checked Locking

The article explains the difference between instruction reordering and ordering, analyzes how the double‑checked locking pattern can suffer from reordering at the bytecode level, and demonstrates how synchronized provides ordering while volatile only prevents visibility issues, using Java code examples and detailed bytecode analysis.

Javaconcurrencydouble-checked locking
0 likes · 7 min read
Instruction Reordering and Ordering in Java Double-Checked Locking
Liangxu Linux
Liangxu Linux
Aug 8, 2023 · Fundamentals

Mastering Pthreads: Complete Guide to Thread Creation, Sync, and Management on Linux

This article explains why traditional Unix fork/exec models are costly, introduces POSIX threads (Pthreads) as a lightweight alternative, and provides detailed guidance on thread data structures, creation, termination, synchronization primitives, and attribute configuration with practical code examples for Linux developers.

Synchronizationconcurrencymultithreading
0 likes · 20 min read
Mastering Pthreads: Complete Guide to Thread Creation, Sync, and Management on Linux
Top Architect
Top Architect
Aug 7, 2023 · Backend Development

Best Practices and Pitfalls of Using Thread Pools in Java

This article explains how to correctly declare, monitor, and configure Java thread pools, recommends naming conventions, discusses CPU vs I/O workload sizing, highlights common pitfalls such as deadlocks and ThreadLocal misuse, and introduces dynamic pool‑adjustment techniques used by large tech companies.

JavaPerformanceconcurrency
0 likes · 16 min read
Best Practices and Pitfalls of Using Thread Pools in Java
Selected Java Interview Questions
Selected Java Interview Questions
Aug 3, 2023 · Backend Development

Instruction Reordering and Ordering in Java: Analysis of Double-Checked Locking

The article explains the distinction between instruction reordering and ordering in Java, analyzes how volatile and synchronized affect memory visibility and atomicity, and demonstrates with bytecode and multithreaded examples why double‑checked locking requires both volatile and synchronized to avoid partially constructed singleton instances.

Javaconcurrencydouble-checked locking
0 likes · 6 min read
Instruction Reordering and Ordering in Java: Analysis of Double-Checked Locking
FunTester
FunTester
Aug 2, 2023 · Backend Development

Practical Use of Java ThreadLocal for Thread‑Safe Variable Storage and Real‑World Scenarios

This article explains the Java ThreadLocal class, demonstrates how it provides per‑thread variable isolation to avoid concurrency issues, and shares two real‑world scenarios—including a utility class and a Spring Boot case—showing how ThreadLocal can simplify thread‑local state management while warning about potential memory leaks.

JavaThreadLocalconcurrency
0 likes · 9 min read
Practical Use of Java ThreadLocal for Thread‑Safe Variable Storage and Real‑World Scenarios
JD Tech
JD Tech
Aug 1, 2023 · Fundamentals

JVM Initialization Deadlock Analysis and Resolution

This article investigates a production thread‑pool exhaustion issue caused by a JVM class‑initialization deadlock, explains the underlying class‑loading mechanics, presents detailed stack‑trace analysis, and offers a preventive solution with early bean initialization and a reproducible demo.

class loadingconcurrencyjvm
0 likes · 17 min read
JVM Initialization Deadlock Analysis and Resolution
JD Tech
JD Tech
Jul 28, 2023 · Backend Development

Analyzing MyBatis ParameterType and ResultType Misconfiguration Causing Thread Blocking Under High Concurrency

Under high concurrency, improper configuration of MyBatis parameterType and resultType can lead to thread BLOCKED states due to repeated TypeHandler cache misses, and this article analyzes the root causes, demonstrates debugging steps, and provides recommendations to avoid such performance bottlenecks.

MyBatisTypeHandlerconcurrency
0 likes · 13 min read
Analyzing MyBatis ParameterType and ResultType Misconfiguration Causing Thread Blocking Under High Concurrency
FunTester
FunTester
Jul 28, 2023 · Fundamentals

Unveiling Go’s Channel: Deep Dive into Runtime, Memory Leaks, and Best Practices

This article explores Go's channel implementation—from its CSP‑inspired design and internal hchan structure to real‑world memory‑leak debugging, creation nuances, send/receive mechanics, and proper closing—providing developers with a comprehensive understanding of safe concurrent programming in Go.

Gochannelconcurrency
0 likes · 31 min read
Unveiling Go’s Channel: Deep Dive into Runtime, Memory Leaks, and Best Practices
Zhuanzhuan Tech
Zhuanzhuan Tech
Jul 26, 2023 · Backend Development

Applying CompletableFuture for Asynchronous Programming in Java: A ZhiZhi Store Detail Page Case Study

This article explains the limitations of Java Future, introduces CompletableFuture's asynchronous and compositional capabilities, and demonstrates how to refactor a store detail page service using CompletableFuture, custom thread pools, and design patterns to achieve parallel execution, reduced latency, and better code maintainability.

BackendCompletableFutureJava
0 likes · 14 min read
Applying CompletableFuture for Asynchronous Programming in Java: A ZhiZhi Store Detail Page Case Study
Tech Architecture Stories
Tech Architecture Stories
Jul 24, 2023 · Backend Development

Mastering Distributed Locks: When to Use Redis, Zookeeper, and Redlock

This guide explains why distributed locks are needed, how to correctly acquire and release them, compares Redis and Zookeeper implementations—including single‑master, Redlock, and Zookeeper approaches—and offers practical recommendations for ensuring atomicity, preventing deadlocks, and protecting shared resources in production environments.

AtomicityDistributed LockRedis
0 likes · 12 min read
Mastering Distributed Locks: When to Use Redis, Zookeeper, and Redlock
JD Tech
JD Tech
Jul 21, 2023 · Backend Development

In‑Depth Analysis of Guava RateLimiter: Architecture, Algorithms, and Usage

This article provides a comprehensive walkthrough of Google Guava's RateLimiter, covering its practical rate‑limiting scenarios, underlying token‑bucket algorithm, detailed source‑code structure, core classes such as RateLimiter, SmoothRateLimiter, SmoothBursty and SmoothWarmingUp, usage examples, and considerations for extending or adapting the component in distributed systems.

GuavaRateLimiterRateLimiting
0 likes · 21 min read
In‑Depth Analysis of Guava RateLimiter: Architecture, Algorithms, and Usage
Top Architect
Top Architect
Jul 20, 2023 · Backend Development

Solving Product Overselling in High‑Concurrency Flash Sale Scenarios: Seven Implementation Approaches

This article analyzes the common overselling problem in high‑traffic flash‑sale systems and presents seven concrete solutions—including improved locking, AOP locking, pessimistic and optimistic locks, as well as blocking‑queue and Disruptor‑based designs—complete with SpringBoot code samples and performance testing results.

Flash SaleLockingQueue
0 likes · 20 min read
Solving Product Overselling in High‑Concurrency Flash Sale Scenarios: Seven Implementation Approaches
Code Ape Tech Column
Code Ape Tech Column
Jul 17, 2023 · Backend Development

Best Practices and Common Pitfalls When Using Java Thread Pools

This article summarizes the key pitfalls and recommended practices for creating, configuring, monitoring, and naming Java thread pools, including proper declaration, parameter tuning for CPU‑ and I/O‑bound workloads, avoiding OOM and deadlocks, and leveraging dynamic pool frameworks.

BestPracticesJavaPerformance
0 likes · 17 min read
Best Practices and Common Pitfalls When Using Java Thread Pools
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 17, 2023 · Fundamentals

How to Pass Values Between Parent and Child Threads with InheritableThreadLocal and TransmittableThreadLocal

The article explains why regular ThreadLocal cannot share data from a parent thread to its child, introduces InheritableThreadLocal as a built‑in solution, shows its limitation with thread‑pool reuse, and demonstrates how Alibaba's TransmittableThreadLocal overcomes this issue with concrete code examples and output.

InheritableThreadLocalJavaThreadLocal
0 likes · 10 min read
How to Pass Values Between Parent and Child Threads with InheritableThreadLocal and TransmittableThreadLocal
IT Services Circle
IT Services Circle
Jul 14, 2023 · Fundamentals

Meta Supports PEP 703 to Make the CPython GIL Optional

Meta is promoting PEP 703, which proposes adding a --disable-gil build option to CPython so Python can run without the Global Interpreter Lock, and has pledged three engineer‑years by 2025 to help implement the change, while also noting its Threads product already runs on a heavily modified CPython backend.

CPythonGILMeta
0 likes · 3 min read
Meta Supports PEP 703 to Make the CPython GIL Optional
Python Programming Learning Circle
Python Programming Learning Circle
Jul 8, 2023 · Fundamentals

Comprehensive Python Cheat Sheet: Version Differences, Core Libraries, Advanced Topics, and Code Samples

This extensive guide covers Python 2 vs 3 differences, conversion tools, essential and advanced libraries, concurrency patterns, design patterns, database and system fundamentals, along with numerous code snippets and practical examples for developers seeking a deep understanding of Python programming.

Design Patternsalgorithmsconcurrency
0 likes · 29 min read
Comprehensive Python Cheat Sheet: Version Differences, Core Libraries, Advanced Topics, and Code Samples
Practical DevOps Architecture
Practical DevOps Architecture
Jun 29, 2023 · Backend Development

Comprehensive Course Outline for Backend Development: Databases, Frameworks, Microservices, Messaging, Collections, and JVM

This article presents a detailed curriculum for backend development, covering fundamental concepts and practical topics such as database design and optimization, popular frameworks like Spring and Hibernate, microservice architecture, message middleware (Redis, RabbitMQ, Kafka), common data structures, concurrency, JVM internals, and related interview questions.

Backend DevelopmentDatabasesMicroservices
0 likes · 9 min read
Comprehensive Course Outline for Backend Development: Databases, Frameworks, Microservices, Messaging, Collections, and JVM
IT Services Circle
IT Services Circle
Jun 27, 2023 · Fundamentals

Using CyclicBarrier for Alternating Thread Printing of ABC in Java

This article explains how to use Java's CyclicBarrier to coordinate three threads that alternately print the characters A, B, and C, providing a detailed analysis, example analogy, complete implementation code, execution result, and a brief summary of its relevance in multithreading interviews.

CyclicBarrierJavaconcurrency
0 likes · 5 min read
Using CyclicBarrier for Alternating Thread Printing of ABC in Java
IT Services Circle
IT Services Circle
Jun 23, 2023 · Backend Development

Comprehensive Java Backend Interview Review: Threads, Collections, Networking, HTTP, TCP, and MySQL

This article presents a detailed Java backend interview recap covering self‑introduction, thread‑pool choices, Snowflake ID usage, List implementations, List vs Set differences, common HTTP status codes, flow and congestion control, URL request flow, TCP three‑way handshake, HTTP vs HTTPS, database index types, B+‑tree advantages, transaction isolation problems, and practical interview preparation tips.

Backend DevelopmentDatabaseJava
0 likes · 21 min read
Comprehensive Java Backend Interview Review: Threads, Collections, Networking, HTTP, TCP, and MySQL
21CTO
21CTO
Jun 21, 2023 · Fundamentals

What’s New in C++26? Upcoming Concurrency Features and Language Changes

Herb Sutter reveals that the ISO C++ committee has approved the C++26 schedule, promising major concurrency and parallelism enhancements, new language features like wildcard support and dangerous pointers, while discussing competition from Rust, Google’s Carbon, and his experimental cppfront project.

C++C++26concurrency
0 likes · 4 min read
What’s New in C++26? Upcoming Concurrency Features and Language Changes
Open Source Linux
Open Source Linux
Jun 19, 2023 · Backend Development

Mastering Cache Design in Go: Concepts, APIs, and Concurrency

This article explains cache fundamentals, common use cases, design constraints, and a Go implementation that combines hash‑maps with doubly‑linked lists, LRU eviction, TTL handling, and mutex‑based concurrency control, providing practical code examples and deployment tips.

Backend DevelopmentCacheLRU
0 likes · 11 min read
Mastering Cache Design in Go: Concepts, APIs, and Concurrency
Python Programming Learning Circle
Python Programming Learning Circle
Jun 16, 2023 · Fundamentals

Comprehensive Python Knowledge Summary: Language Differences, Advanced Features, Libraries, Concurrency, Testing, and System Design

This extensive guide compiles Python 2 vs 3 differences, essential built‑in modules, common and advanced libraries, multiprocessing, async programming, testing techniques, networking fundamentals, database and cache concepts, Linux I/O models, design patterns, and algorithm implementations, providing a valuable reference for developers.

DatabasesDesign Patternsalgorithms
0 likes · 30 min read
Comprehensive Python Knowledge Summary: Language Differences, Advanced Features, Libraries, Concurrency, Testing, and System Design
37 Interactive Technology Team
37 Interactive Technology Team
Jun 15, 2023 · Backend Development

Concurrent Safety of Go Maps: Issues, Solutions, and Performance Comparison

Go maps are not safe for concurrent access, so programs can panic when multiple goroutines read and write the same map; to prevent this you can use sync.Once for immutable data, protect maps with sync.RWMutex, employ sharded locks via concurrent‑map, or use the built‑in sync.Map, each offering different performance trade‑offs depending on read/write ratios and concurrency level.

GoRWMutexconcurrency
0 likes · 13 min read
Concurrent Safety of Go Maps: Issues, Solutions, and Performance Comparison
Cognitive Technology Team
Cognitive Technology Team
Jun 11, 2023 · Backend Development

Unified Handling of ThreadLocal Issues in Java Projects

This article explains why ThreadLocal can cause information loss, corruption, or OOM in Java applications and presents two practical approaches—Java agent bytecode manipulation and proxy‑based thread‑pool wrappers—along with concrete Spring Sleuth implementations and testing results to ensure safe propagation and cleanup.

AOPJavaThreadLocal
0 likes · 5 min read
Unified Handling of ThreadLocal Issues in Java Projects
JD Retail Technology
JD Retail Technology
Jun 7, 2023 · Backend Development

Performance Optimization: Code and Design Techniques for Java Services

This article explains service performance concepts and presents systematic code‑level and architectural optimizations for Java back‑ends, covering class preloading, thread‑pool usage, static variables, cache‑line alignment, false sharing mitigation, branch prediction, copy‑on‑write, method inlining, reflection caching, exception handling, logging practices, lock granularity, and pooling strategies, all illustrated with concrete code examples.

Backend DevelopmentCache AlignmentJava
0 likes · 33 min read
Performance Optimization: Code and Design Techniques for Java Services
DeWu Technology
DeWu Technology
Jun 7, 2023 · Backend Development

Ensuring Data Consistency Across Microservices: Strategies and Design Principles

This article examines why data consistency between microservices is critical, defines key terminology, and presents two practical approaches—business‑side final consistency and platform‑side final consistency—detailing their core ideas, design principles, workflow diagrams, and real‑world implementation considerations such as idempotency, storage choices, latency tolerance, state‑machine design, concurrency control, and observability.

Data ConsistencyMicroservicesState Machine
0 likes · 17 min read
Ensuring Data Consistency Across Microservices: Strategies and Design Principles
OPPO Kernel Craftsman
OPPO Kernel Craftsman
May 26, 2023 · Fundamentals

Understanding Linux rwsem Read‑Write Semaphore in Kernel 5.15.81

Linux introduced the read‑write semaphore (rwsem) as a sleep lock that lets multiple readers hold the lock concurrently, improving read‑heavy workload performance, and the article details its internal state representation, acquisition paths for reads and writes, optimistic spinning, handoff mechanisms, and trade‑offs, noting that mobile kernels may need further tuning.

Linux kernelSynchronizationconcurrency
0 likes · 22 min read
Understanding Linux rwsem Read‑Write Semaphore in Kernel 5.15.81
iQIYI Technical Product Team
iQIYI Technical Product Team
May 26, 2023 · Mobile Development

How We Cut Feed Lag in iQIYI Kids App: A Deep Dive into Mobile Performance Optimization

This case study details the performance bottlenecks of the iQIYI Kids feed on low‑end devices and presents a series of engineering solutions—including async card rendering, preloading strategies, image pre‑decoding, and cache optimizations—that reduced scroll hitch time to 1.4 ms, dramatically improving user experience.

Mobile DevelopmentPerformance optimizationconcurrency
0 likes · 9 min read
How We Cut Feed Lag in iQIYI Kids App: A Deep Dive into Mobile Performance Optimization
JD Cloud Developers
JD Cloud Developers
May 23, 2023 · Backend Development

Boost Java Service Performance: Code & Design Optimizations Explained

This article explores comprehensive performance optimization techniques for Java services, covering code-level strategies such as preloading classes, cache line alignment, branch prediction, copy‑on‑write, inlining, and design approaches like caching, asynchronous processing, pooling, and pre‑handling, while highlighting trade‑offs and practical examples.

CachingDesign PatternsJava
0 likes · 29 min read
Boost Java Service Performance: Code & Design Optimizations Explained
php Courses
php Courses
May 22, 2023 · Operations

Overview of RunnerGo Performance Testing Module and Its Features

This article provides a comprehensive guide to RunnerGo's performance testing module, detailing plan management, various load test modes such as concurrency, step, error‑rate, response‑time, and requests‑per‑second, along with configuration options, execution workflow, and links to the open‑source repository.

Response Timeconcurrencyerror rate
0 likes · 11 min read
Overview of RunnerGo Performance Testing Module and Its Features
Cognitive Technology Team
Cognitive Technology Team
May 21, 2023 · Backend Development

Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring

This article explains how improper use of AOP in Spring can cause object escape leading to concurrency safety problems, discusses issues such as asynchronous thread modifications, caching, and incorrect advice ordering with @Transaction, @Retryable, and dynamic datasource switching, and provides practical guidance to avoid these pitfalls.

AOPJavaObject Escape
0 likes · 5 min read
Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring
360 Quality & Efficiency
360 Quality & Efficiency
May 19, 2023 · Backend Development

Resolving SimpleDateFormat Thread Safety Issues with ThreadLocal in Java

This article explains why Java's SimpleDateFormat is not thread‑safe, demonstrates the concurrency problem with a multithreaded demo, and presents three solutions—creating new instances, synchronizing access, and using ThreadLocal—highlighting the ThreadLocal approach with code examples and discussion of potential memory‑leak considerations.

SimpleDateFormatThreadLocalconcurrency
0 likes · 4 min read
Resolving SimpleDateFormat Thread Safety Issues with ThreadLocal in Java
JD Tech
JD Tech
May 15, 2023 · Backend Development

Implementing Asynchronous Timeout with CompletableFuture in Java (JDK 8 & JDK 9)

This article explains how to use Java's CompletableFuture for parallel execution, demonstrates the limitations of simple timeout handling in JDK 8, and shows how JDK 9's built‑in orTimeout method and a custom utility class can provide precise asynchronous timeout control for backend services.

Async TimeoutCompletableFutureJDK8
0 likes · 12 min read
Implementing Asynchronous Timeout with CompletableFuture in Java (JDK 8 & JDK 9)
FunTester
FunTester
May 15, 2023 · Backend Development

Why Direct Thread Creation Fails and How Java Thread Pools Boost Performance

In high‑concurrency Java applications, creating threads directly with the Thread class leads to performance degradation, resource exhaustion, and lack of management, whereas using the Executor framework’s ThreadPoolExecutor—configured via corePoolSize, maximumPoolSize, keepAliveTime, workQueue, threadFactory, and rejectHandler—provides reusable threads, controlled concurrency, task scheduling, monitoring, and customizable rejection policies, dramatically improving efficiency.

ExecutorFrameworkJavaThreadPoolExecutor
0 likes · 9 min read
Why Direct Thread Creation Fails and How Java Thread Pools Boost Performance
JD Tech
JD Tech
May 11, 2023 · Fundamentals

Evolution of Java Multithreading: From Manual Gear to Virtual Threads

This article systematically traces the evolution of Java multithreading from the early native Thread model through the introduction of java.util.concurrent and synchronized optimizations to the modern virtual thread era, highlighting key concepts, milestones, and performance impacts.

JDKJava 19concurrency
0 likes · 19 min read
Evolution of Java Multithreading: From Manual Gear to Virtual Threads
Programmer DD
Programmer DD
May 11, 2023 · Backend Development

Why Java’s ArrayList addAll Fails Under Concurrency and How to Fix It

This article explains the importance and challenges of concurrent programming, details Java's memory model and synchronization primitives, analyzes a real‑world case where concurrent addAll on ArrayList caused missing UI elements, and demonstrates how using thread‑safe collections resolves the issue.

ArrayListJMMJava
0 likes · 14 min read
Why Java’s ArrayList addAll Fails Under Concurrency and How to Fix It
Architect's Guide
Architect's Guide
May 9, 2023 · Backend Development

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

This article explains various ways to terminate a running Java thread, including using exit flags, the deprecated stop/suspend/resume methods, interrupt, handling InterruptedException, and the risks of forceful termination, accompanied by detailed code examples and best‑practice recommendations.

Deprecated APIJavaThread Management
0 likes · 11 min read
How to Properly Stop a Java Thread: Methods, Examples, and Pitfalls
Laravel Tech Community
Laravel Tech Community
May 5, 2023 · Fundamentals

Go Language Enters TIOBE Top 10: Reasons and Implications

The article explains why Go has entered the TIOBE top‑10, highlighting its built‑in concurrency, garbage collection, static typing, Google backing, and its role in projects like Docker and Kubernetes, while describing how the TIOBE index is calculated and how it can guide language selection decisions.

TIOBE Indexconcurrencyprogramming languages
0 likes · 3 min read
Go Language Enters TIOBE Top 10: Reasons and Implications
Tencent Cloud Developer
Tencent Cloud Developer
May 5, 2023 · Backend Development

Golang vs Java: Syntax, Concurrency, Exception Handling, GC and Ecosystem Comparison

While Go offers concise syntax, non‑intrusive interfaces, lightweight goroutine concurrency, a simple three‑color garbage collector and a small native binary footprint, Java provides a mature object‑oriented model, extensive libraries, generational GC and robust tooling, making the optimal language choice depend on project performance, ecosystem and development speed requirements.

Backend DevelopmentGolangJava
0 likes · 28 min read
Golang vs Java: Syntax, Concurrency, Exception Handling, GC and Ecosystem Comparison
Selected Java Interview Questions
Selected Java Interview Questions
May 5, 2023 · Backend Development

High‑Frequency Java Concurrency Questions: AQS, Locks, Thread Pools, Blocking Queues, CountDownLatch, Semaphore, CopyOnWriteArrayList, and ConcurrentHashMap

This article explains the core concepts and common pitfalls of Java's AbstractQueuedSynchronizer (AQS) and its derived utilities such as ReentrantLock, ReentrantReadWriteLock, CountDownLatch, Semaphore, as well as the design and behavior of blocking queues, thread‑pool parameters, CopyOnWriteArrayList, and ConcurrentHashMap, providing code examples and practical guidance.

AQSJavaLock
0 likes · 21 min read
High‑Frequency Java Concurrency Questions: AQS, Locks, Thread Pools, Blocking Queues, CountDownLatch, Semaphore, CopyOnWriteArrayList, and ConcurrentHashMap
JD Tech
JD Tech
May 4, 2023 · Backend Development

Understanding Redis Distributed Locks: Features, Implementations, and Best Practices

This article explains why distributed locks are needed, describes the five essential characteristics of Redis locks, compares three common implementation methods, and provides detailed Java code examples with watchdog, re‑entrancy, and expiration handling to guide developers in building reliable distributed locking solutions.

Distributed LockLuaWatchdog
0 likes · 21 min read
Understanding Redis Distributed Locks: Features, Implementations, and Best Practices
Architect's Guide
Architect's Guide
Apr 30, 2023 · Backend Development

Evolution of Distributed Locks with Redis and Redisson

This article explains the step‑by‑step evolution of Redis‑based distributed lock implementations—from a simple SETNX approach to a robust solution using UUIDs, expiration, atomic Lua scripts, and finally Redisson’s high‑level lock API—illustrating common pitfalls and their fixes.

BackendJavaRedis
0 likes · 8 min read
Evolution of Distributed Locks with Redis and Redisson
Top Architect
Top Architect
Apr 28, 2023 · Backend Development

Netty TCP Demo: Long‑Lived Socket Connection Architecture and Implementation

This article presents a complete Netty‑based TCP demo for IoT projects, detailing the project background, architecture, module layout, business flow, and in‑depth Java code examples—including a local queue, multithreaded processing, client creation, Redis locking, and SpringBoot integration—along with testing instructions and source links.

JavaMessageQueueNetty
0 likes · 19 min read
Netty TCP Demo: Long‑Lived Socket Connection Architecture and Implementation
Java High-Performance Architecture
Java High-Performance Architecture
Apr 26, 2023 · Backend Development

How to Build a Robust Redis Distributed Lock with Spring AOP

This article explains why time‑consuming business operations need a distributed lock, walks through using Redis as a lock with Spring AOP, details the lock‑acquire, timeout, and renewal mechanisms, provides full code examples, testing steps, and best‑practice recommendations for reliable concurrency control in Java back‑end services.

Distributed LockJavaRedis
0 likes · 12 min read
How to Build a Robust Redis Distributed Lock with Spring AOP
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2023 · Backend Development

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

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

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

Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal

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

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

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

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

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

Nine Common Pitfalls of Using Multithreading in Java Applications

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

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

Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas

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

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

Evolution of Distributed Locks with Redis and Redisson

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

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

Lock Optimization and Escape Analysis in the JVM

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

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

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

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

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

Understanding Synchronization Mechanisms and RCU in the Linux Kernel

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

Linux kernelRCUSpinlock
0 likes · 26 min read
Understanding Synchronization Mechanisms and RCU in the Linux Kernel
Selected Java Interview Questions
Selected Java Interview Questions
Mar 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.

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

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

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

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

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

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

LinuxSocketTCP
0 likes · 11 min read
Why 65,535 Isn’t the Real Limit for TCP Connections on Linux