BestHub
Sign in
Tagged articles
2077 articles
Page 9 of 21
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 testingConcurrencyPython
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.

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

Concurrencyatomic operationsjava
0 likes · 9 min read
Mastering Java Unsafe: Low-Level Memory Tricks and Atomic Operations
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.

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

ConcurrencyThread APIjava
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.

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

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

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

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

ConcurrencyGarbage CollectionJVM
0 likes · 17 min read
Understanding ZGC: Architecture, Key Features, and Execution Cycle
Java Architecture Diary
Java Architecture Diary
Sep 18, 2023 · Fundamentals

What’s New in Java 21? Explore Updated String, Collections, and More

This article walks through the latest Java 21 additions—including enhanced String search methods, new Emoji utilities in Character, repeat() for StringBuilder and StringBuffer, updated Charset factories, named regex groups, SequencedCollection interfaces, localized DateTimeFormatter patterns, extended Math and BigInteger operations, and improved Thread and Future APIs—providing code examples and usage guidance.

APICollectionsConcurrency
0 likes · 13 min read
What’s New in Java 21? Explore Updated String, Collections, and More
Su San Talks Tech
Su San Talks Tech
Sep 17, 2023 · Backend Development

Mastering CompletableFuture: From Basics to RocketMQ Integration

Explore how Java's CompletableFuture enhances asynchronous programming by overcoming Future's limitations, learn its core APIs, practical code examples, and see a real-world application in RocketMQ where combined futures streamline message persistence and replication.

Backend DevelopmentCompletableFutureConcurrency
0 likes · 15 min read
Mastering CompletableFuture: From Basics to RocketMQ Integration
Code Ape Tech Column
Code Ape Tech Column
Sep 16, 2023 · Backend Development

Batch Request Merging in Java to Reduce Database Connections

This article explains how to merge multiple user‑detail requests on the server side using a blocking queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby converting many individual SQL calls into a single batch query, saving database connections and improving high‑concurrency performance.

Batch processingCompletableFutureConcurrency
0 likes · 13 min read
Batch Request Merging in Java to Reduce Database Connections
dbaplus Community
dbaplus Community
Sep 14, 2023 · Databases

Master MySQL InnoDB Locks: From Row Locks to Deadlock Prevention

This article explains why MySQL needs locking, details every InnoDB lock type—including shared, exclusive, intention, record, gap, next‑key, insert‑intention and auto‑increment locks—covers lock compatibility, deadlock causes and prevention, compares optimistic and pessimistic locking, and shows how SELECT FOR UPDATE behaves under different isolation levels.

ConcurrencyInnoDBMySQL
0 likes · 20 min read
Master MySQL InnoDB Locks: From Row Locks to Deadlock Prevention
政采云技术
政采云技术
Sep 13, 2023 · Backend Development

Understanding Java Threads and Thread Pools

This article explains the concept of threads in Java, how to create them, the purpose and benefits of thread pools, the inheritance hierarchy of Java's Executor framework, key parameters of ThreadPoolExecutor, rejection policies, pool states, and the underlying working mechanism, supplemented with code examples.

ConcurrencyExecutorRejectionPolicy
0 likes · 15 min read
Understanding Java Threads and Thread Pools
Java Architect Essentials
Java Architect Essentials
Sep 12, 2023 · Fundamentals

Why volatile and synchronized Can't Prevent Instruction Reordering in Java

An in‑depth analysis of Java’s instruction reordering versus ordered execution, illustrating how volatile ensures visibility but not atomicity, how synchronized guarantees atomicity and ordering yet cannot stop bytecode‑level reordering, with detailed DCL singleton bytecode walkthrough and multithreaded examples.

ConcurrencyInstruction ReorderingSingleton
0 likes · 7 min read
Why volatile and synchronized Can't Prevent Instruction Reordering in Java
Architect
Architect
Sep 12, 2023 · Backend Development

Ensuring Transaction Consistency in Multi‑Threaded Spring Applications Using CompletableFuture and Programmatic Transactions

This article explains how to parallelize business steps with CompletableFuture, why Spring's @Async and @Transactional annotations cannot guarantee transaction consistency across threads, and presents a programmatic transaction approach—including copying Spring's transaction resources between threads—to achieve reliable multi‑threaded commits or rollbacks.

CompletableFutureConcurrencyProgrammaticTransaction
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑Threaded Spring Applications Using CompletableFuture and Programmatic Transactions
政采云技术
政采云技术
Sep 12, 2023 · Backend Development

Understanding Netty EventLoop: Architecture, Mechanisms, and Best Practices

This article explains the Netty EventLoop implementation, covering its reactor‑based event loop design, event handling and task processing mechanisms, code examples, common pitfalls such as the JDK epoll bug, and practical recommendations for building high‑performance backend services.

Backend DevelopmentConcurrencyEventLoop
0 likes · 15 min read
Understanding Netty EventLoop: Architecture, Mechanisms, and Best Practices
Tencent Cloud Developer
Tencent Cloud Developer
Sep 11, 2023 · Fundamentals

Understanding Python's Global Interpreter Lock (GIL) and Its Impact

The article explains Python’s Global Interpreter Lock—its historical origins, how CPython’s tick‑based and later time‑slice schedulers manage thread execution, why it limits multi‑core performance, common multiprocessing workarounds, and the difficulties of removing it despite recent proposals for a GIL‑free build.

ConcurrencyGILPerformance
0 likes · 15 min read
Understanding Python's Global Interpreter Lock (GIL) and Its Impact
Selected Java Interview Questions
Selected Java Interview Questions
Sep 7, 2023 · Backend Development

Understanding Blocking Queues in Java: Concepts, Types, and Core Methods

Blocking queues are thread‑safe data structures in Java that support blocking operations, enabling producer‑consumer coordination; this article explains their definition, differences from List/Set and regular queues, various implementations such as ArrayBlockingQueue and LinkedBlockingQueue, core methods like take and put, and bounded versus unbounded capacities.

BlockingQueueConcurrencyDataStructure
0 likes · 11 min read
Understanding Blocking Queues in Java: Concepts, Types, and Core Methods
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.

ConcurrencyLua ScriptRedis
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.

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

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

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

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

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

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

ConcurrencyDistributed SystemsLocks
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.

AOPConcurrencyJWT
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 FixConcurrency
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.

ConcurrencyFunctionsGo
0 likes · 25 min read
Go Language Basics: Syntax, Variables, Control Flow, OOP, Concurrency, and Error Handling
MaGe Linux Operations
MaGe Linux Operations
Aug 21, 2023 · Backend Development

Why Your Java ThreadPool Won’t Release Threads – The Hidden Power of shutdown()

This article explores why a Java thread pool can retain hundreds of waiting threads, explains how the shutdown and shutdownNow methods trigger thread interruption, details the internal worker lifecycle that leads to garbage collection, and provides practical code demos to ensure proper resource cleanup.

ConcurrencyExecutorServiceGarbageCollection
0 likes · 14 min read
Why Your Java ThreadPool Won’t Release Threads – The Hidden Power of shutdown()
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.

ConcurrencyWeb Scrapingthreading
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.

ConcurrencyDaemon ThreadThreads
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++ConcurrencyPerformance
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.

ConcurrencyMiopPush Service
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.

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

ConcurrencyCountDownLatchLockSupport
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 DevelopmentCode OptimizationConcurrency
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.

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

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

ConcurrencyInstruction Reorderingdouble-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.

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

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

ConcurrencyInstruction Reorderingdouble-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.

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

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

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

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

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

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

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

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

BestPracticesConcurrencyPerformance
0 likes · 17 min read
Best Practices and Common Pitfalls When Using Java Thread Pools
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.

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

AlgorithmsConcurrencyDesign Patterns
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 DevelopmentConcurrencyDatabases
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.

ConcurrencyCyclicBarrierjava
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 DevelopmentConcurrencyDatabase
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 DevelopmentCacheConcurrency
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.

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

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

AOPConcurrencyThreadLocal
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 AlignmentCode Optimization
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.

ConcurrencyData ConsistencyDistributed Systems
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.

ConcurrencyLinux kernelSynchronization
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.

ConcurrencyMobile DevelopmentPerformance Optimization
0 likes · 9 min read
How We Cut Feed Lag in iQIYI Kids App: A Deep Dive into Mobile Performance Optimization
New Oriental Technology
New Oriental Technology
May 25, 2023 · Fundamentals

Deep Dive into Java volatile: CPU Cache Architecture, MESI Protocol, JMM and Happens‑Before

This article thoroughly explains the low‑level implementation of Java's volatile keyword by analysing CPU multi‑level cache design, the MESI cache‑coherency protocol, the Java Memory Model, memory barriers, the happens‑before principle, and the impact on singleton patterns and synchronized blocks.

CPU cacheConcurrencyHappens-before
0 likes · 36 min read
Deep Dive into Java volatile: CPU Cache Architecture, MESI Protocol, JMM and Happens‑Before
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.

CachingCode OptimizationConcurrency
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.

ConcurrencyResponse Timeerror 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.

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

ConcurrencySimpleDateFormatThreadLocal
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 TimeoutCompletableFutureConcurrency
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.

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

ConcurrencyJDKJava 19
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.

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

ConcurrencyDeprecated APIThread
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.

ConcurrencyTIOBE Indexprogramming 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 DevelopmentConcurrencyGolang
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.

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

ConcurrencyLuaWatchdog
0 likes · 21 min read
Understanding Redis Distributed Locks: Features, Implementations, and Best Practices