BestHub
Sign in
Tagged articles

concurrency

2156 articles · Page 16 of 22
Byte Quality Assurance Team
Byte Quality Assurance Team
Mar 31, 2021 · Backend Development

Root Cause Analysis and Optimization of RocketMQ Message Dispatch in the Tesla Interface Testing Platform

The article investigates a performance bottleneck in Tesla's interface testing platform where large test tasks experience up to nine‑minute report delays, identifies the hidden latency in RocketMQ message dispatch to handlers, and proposes a redesign of channel scheduling that reduces execution time to under four minutes.

Channel SchedulingMessage QueueRocketMQ
0 likes · 6 min read
Root Cause Analysis and Optimization of RocketMQ Message Dispatch in the Tesla Interface Testing Platform
Code Ape Tech Column
Code Ape Tech Column
Mar 29, 2021 · Backend Development

Understanding Distributed Locks and Their Implementation with Redis and Zookeeper

Distributed locks ensure exclusive access across multiple servers in high-concurrency scenarios, and this article explains their necessity, illustrates problems with simple locks, and details practical implementations using Redis and Zookeeper, including lock acquisition, release, expiration handling, and avoiding deadlocks.

Distributed LockRedisZookeeper
0 likes · 13 min read
Understanding Distributed Locks and Their Implementation with Redis and Zookeeper
Java Captain
Java Captain
Mar 28, 2021 · Backend Development

Analysis and Solutions for Redis Distributed Lock Over‑selling in High‑Concurrency Seckill Scenario

This article examines a real‑world flash‑sale incident where Redis distributed locks failed, causing severe overselling, and presents root‑cause analysis, safer lock implementation with Lua scripts, atomic stock handling, refactored Java code, and deeper reflections on lock necessity and further optimizations.

Distributed LockLuaRedis
0 likes · 10 min read
Analysis and Solutions for Redis Distributed Lock Over‑selling in High‑Concurrency Seckill Scenario
MaGe Linux Operations
MaGe Linux Operations
Mar 27, 2021 · Fundamentals

Ultimate Python Cheat Sheet: From Py2 vs Py3 Differences to Advanced Concurrency and Design Patterns

This comprehensive guide compiles essential Python knowledge—including Python 2 vs 3 changes, conversion tools, frequently used libraries, concurrency models, testing techniques, core language concepts, plus related topics such as networking, MySQL, Redis, Linux, design patterns, data structures, algorithms, and interview‑level questions—providing a one‑stop reference for developers seeking to deepen their Python expertise.

Performancecheatsheetconcurrency
0 likes · 32 min read
Ultimate Python Cheat Sheet: From Py2 vs Py3 Differences to Advanced Concurrency and Design Patterns
NiuNiu MaTe
NiuNiu MaTe
Mar 23, 2021 · Backend Development

Quickly Master Go: Install, Code, Concurrency, and Testing

Learn how to set up Go in Linux, macOS, and Windows, understand its core syntax, manage packages, work with variables, arrays, slices, maps, control structures, goroutines, channels, interfaces, write unit tests, use Go Convey, connect databases with GORM, and build simple web servers with the standard library or Gin.

Backend DevelopmentGoTesting
0 likes · 20 min read
Quickly Master Go: Install, Code, Concurrency, and Testing
Java Interview Crash Guide
Java Interview Crash Guide
Mar 22, 2021 · Backend Development

Top 30 Java Interview Questions Every Backend Engineer Should Master

This article compiles 30 essential Java interview questions covering OOP fundamentals, collections, concurrency, JVM internals, Spring framework, and performance optimization, providing concise explanations and key concepts to help backend developers prepare effectively for technical interviews.

concurrencyinterviewjava
0 likes · 10 min read
Top 30 Java Interview Questions Every Backend Engineer Should Master
Beike Product & Technology
Beike Product & Technology
Mar 19, 2021 · Backend Development

Implementing a PHP Coroutine Task Scheduler for Concurrent RPC and MySQL Access

This article presents a PHP coroutine‑based Task Scheduler that enables high‑concurrency RPC calls and asynchronous MySQL queries, explains its design and implementation with code examples, compares performance against traditional synchronous and HttpMultiClient approaches, and discusses task dependency handling using DAG and topological sorting.

RPCasyncconcurrency
0 likes · 19 min read
Implementing a PHP Coroutine Task Scheduler for Concurrent RPC and MySQL Access
Open Source Linux
Open Source Linux
Mar 18, 2021 · Backend Development

How to Optimize Nginx for High Concurrency, Custom Errors, and Better Caching

This guide walks through customizing Nginx's 404 page, enabling the stub_status module to monitor server metrics, tuning worker processes and connection limits for higher concurrency, expanding client header buffers, and configuring static file caching to improve overall web performance.

CachingError handlingOptimization
0 likes · 8 min read
How to Optimize Nginx for High Concurrency, Custom Errors, and Better Caching
Sohu Tech Products
Sohu Tech Products
Mar 17, 2021 · Mobile Development

Understanding and Using Schedulers in Swift Combine

This article explains the concept of Schedulers in the Swift Combine framework, compares the default scheduling behavior with explicit subscribe(on:) and receive(on:) operators, demonstrates various Scheduler implementations (ImmediateScheduler, RunLoop, DispatchQueue, OperationQueue) through detailed code examples, and provides practical guidance for managing thread execution in reactive iOS applications.

CombineReactive ProgrammingScheduler
0 likes · 22 min read
Understanding and Using Schedulers in Swift Combine
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 13, 2021 · Fundamentals

Effective Java Practices: Builder Pattern, Object Creation, and Performance Optimizations

This article presents a collection of Java best‑practice guidelines—including using the Builder pattern for many constructor arguments, privatizing utility class constructors, minimizing object creation, avoiding finalizers, applying the Law of Demeter, preferring enums, and careful use of var‑args—to improve code readability, memory usage, and runtime performance.

Best PracticesDesign PatternsMemory management
0 likes · 15 min read
Effective Java Practices: Builder Pattern, Object Creation, and Performance Optimizations
Java Backend Technology
Java Backend Technology
Mar 13, 2021 · Backend Development

Why Java 8 Parallel Streams Can Be Slower Than Simple Loops

A production incident shows that using Java 8 parallel streams for message processing can dramatically reduce throughput, making them slower than a straightforward for‑loop due to the shared ForkJoinPool and thread‑pool sizing issues.

ForkJoinPoolParallel StreamPerformance
0 likes · 11 min read
Why Java 8 Parallel Streams Can Be Slower Than Simple Loops
Top Architect
Top Architect
Mar 11, 2021 · Fundamentals

Why ConcurrentHashMap.get() in Java 8 Is Lock‑Free

This article explains how Java 8's ConcurrentHashMap implements the get operation without acquiring locks by using volatile fields, CAS, and a simplified node structure, contrasting it with the segment‑based design of JDK 1.7 and detailing the memory‑visibility guarantees provided by volatile.

JDK8concurrencyconcurrenthashmap
0 likes · 9 min read
Why ConcurrentHashMap.get() in Java 8 Is Lock‑Free
FunTester
FunTester
Mar 11, 2021 · Operations

Accelerating Multi‑User Performance Tests with Java’s CyclicBarrier

This article explains how to eliminate the serial‑login bottleneck in multi‑user performance testing by using Java’s CyclicBarrier to synchronize user logins, then runs a two‑step insert‑update scenario with a custom FunTester class, complete with full code examples and result analysis.

CyclicBarrierbackendconcurrency
0 likes · 8 min read
Accelerating Multi‑User Performance Tests with Java’s CyclicBarrier
Tencent Database Technology
Tencent Database Technology
Mar 8, 2021 · Databases

Introduction to the InnoDB Lock Module and Its Performance Optimizations

This article provides a comprehensive overview of MySQL InnoDB's lock subsystem, describing its data structures, lock compatibility matrices, lock/unlock workflows, lock splitting, inheritance and migration, and presents several optimization techniques such as avoiding lock_sys mutex, asynchronous deadlock detection, and lock_sys mutex sharding to alleviate contention in MySQL 5.7 and later versions.

InnoDBLock ManagerMySQL
0 likes · 13 min read
Introduction to the InnoDB Lock Module and Its Performance Optimizations
Efficient Ops
Efficient Ops
Mar 7, 2021 · Backend Development

Boost Nginx Performance: Custom 404 Pages, Status Monitoring, and Concurrency Tuning

This guide walks through customizing Nginx 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting kernel limits, expanding header buffers, and configuring browser caching for static assets to dramatically improve server performance and reliability.

CacheNginxServer monitoring
0 likes · 10 min read
Boost Nginx Performance: Custom 404 Pages, Status Monitoring, and Concurrency Tuning
ITPUB
ITPUB
Mar 2, 2021 · Fundamentals

Master OS Interview Questions: From Basics to Advanced Concepts

This comprehensive guide covers over forty operating system interview questions, explaining core concepts such as OS fundamentals, process and thread management, memory handling, file systems, I/O mechanisms, scheduling algorithms, and deadlock prevention, providing detailed answers and diagrams to help candidates excel in technical interviews.

File SystemInterview QuestionsMemory management
0 likes · 65 min read
Master OS Interview Questions: From Basics to Advanced Concepts
Laravel Tech Community
Laravel Tech Community
Feb 27, 2021 · Fundamentals

Understanding Processes, Threads, Concurrency, and Process Pools

This article explains the concepts of processes and threads, their differences, interaction methods, the relationship between them, the three execution states of a task, the distinctions among parallel, concurrent, and serial execution, and the purpose and operation of process pools in operating systems.

Process Poolconcurrencyprocess
0 likes · 10 min read
Understanding Processes, Threads, Concurrency, and Process Pools
360 Smart Cloud
360 Smart Cloud
Feb 25, 2021 · Backend Development

Understanding Distributed Locks: Concepts, System Classification, and Implementations with Redis and etcd/Zookeeper

This article explains the fundamentals of distributed locks, compares lock implementations based on asynchronous replication and Paxos protocols, and provides practical Redis and etcd/Zookeeper examples—including exclusive and shared lock mechanisms, code snippets, and usage considerations for reliability and safety.

Distributed LockEtcdZookeeper
0 likes · 9 min read
Understanding Distributed Locks: Concepts, System Classification, and Implementations with Redis and etcd/Zookeeper
Tencent Cloud Developer
Tencent Cloud Developer
Feb 24, 2021 · Backend Development

Common Concurrency Bugs in Go and Their Fixes

Analyzing several major Go projects, the article catalogs frequent concurrency pitfalls—such as unbuffered channels, WaitGroup deadlocks, context leaks, loop‑variable races, double channel closes, timer errors, and RWMutex misuse—and offers concise, idiomatic fixes to prevent blocking, leaks, panics, and deadlocks.

ChannelsContextGo
0 likes · 10 min read
Common Concurrency Bugs in Go and Their Fixes
Top Architect
Top Architect
Feb 23, 2021 · Backend Development

Understanding Java 8 Stream API: Architecture, Parallelism, and Best Practices

This article explains the design and implementation of Java 8 Stream API, covering its composition, pipelining, internal iteration, parallel execution via ForkJoinPool, performance considerations, ordering semantics, and practical guidelines for using parallel streams effectively.

Backend DevelopmentForkJoinPoolParallel Streams
0 likes · 21 min read
Understanding Java 8 Stream API: Architecture, Parallelism, and Best Practices
Top Architect
Top Architect
Feb 22, 2021 · Backend Development

Lazy Initialization and Lazy Loading in Java: Using Supplier, Streams, and Virtual Proxy Patterns

This article explains the concepts of eager versus lazy evaluation in Java, presents common scenarios for lazy initialization, demonstrates how to implement lazy loading with Supplier, virtual proxy, and delegate patterns, and shows practical Stream examples including infinite prime number generation.

Design PatternsLazy InitializationStream
0 likes · 11 min read
Lazy Initialization and Lazy Loading in Java: Using Supplier, Streams, and Virtual Proxy Patterns
Selected Java Interview Questions
Selected Java Interview Questions
Feb 21, 2021 · Fundamentals

Understanding Double-Checked Locking Singleton Pattern in Java

This article explains the double-checked locking implementation of the Singleton pattern in Java, detailing why two null checks are necessary, the role of the volatile keyword in preventing instruction reordering and ensuring visibility across threads, and provides a complete example code.

Singletonconcurrencydouble-checked locking
0 likes · 5 min read
Understanding Double-Checked Locking Singleton Pattern in Java
FunTester
FunTester
Feb 20, 2021 · Backend Development

How I Stress‑Tested a Socket.IO Service with Fixed QPS and Uncovered Hidden Bugs

After mastering the Socket protocol and a fixed‑QPS load‑testing model, I built a comprehensive Socket.IO performance test that simulates a teacher‑student scenario, measures message latency, identifies calculation errors and logging overhead, and reveals several bugs and optimization opportunities in the asynchronous handling and compensation threads.

PerformanceSocket.IOconcurrency
0 likes · 10 min read
How I Stress‑Tested a Socket.IO Service with Fixed QPS and Uncovered Hidden Bugs
Programmer DD
Programmer DD
Feb 19, 2021 · Backend Development

Mastering Lazy Initialization and Stream Laziness in Java 8

This article explains the difference between eager and lazy evaluation, shows when and how to use lazy initialization in Java, demonstrates Supplier‑based lazy loading, virtual proxy patterns, and stream laziness with infinite streams and prime number generation, all with concrete code examples.

Functional ProgrammingLazy InitializationStream
0 likes · 12 min read
Mastering Lazy Initialization and Stream Laziness in Java 8
Top Architect
Top Architect
Feb 10, 2021 · Backend Development

Understanding Thread Safety Issues in Java ArrayList and How to Fix Them

This article explains why Java's ArrayList is not thread‑safe, illustrates the two main concurrency problems—array index out‑of‑bounds and element overwriting—through source‑code analysis and multithreaded examples, and presents several practical solutions such as synchronized wrappers, explicit locking, CopyOnWriteArrayList and ThreadLocal.

ArrayListCollectionsCopyOnWriteArrayList
0 likes · 11 min read
Understanding Thread Safety Issues in Java ArrayList and How to Fix Them
FunTester
FunTester
Feb 7, 2021 · Backend Development

Using ThreadLocal for Collect/Uncollect Performance Testing in Java

This article demonstrates how to apply Java's ThreadLocal together with an AtomicInteger to generate unique minisource_id values for a collect‑and‑uncollect workflow, and shows the complete code modifications and performance‑test script used to measure request latency.

ThreadLocalbackendconcurrency
0 likes · 6 min read
Using ThreadLocal for Collect/Uncollect Performance Testing in Java
FunTester
FunTester
Feb 6, 2021 · Fundamentals

Mastering Java ThreadLocal: Achieve Thread‑Safe Objects Without synchronized

This article explains how Java's ThreadLocal class provides a thread‑local storage mechanism that creates independent object instances for each thread, improving scalability and performance compared to synchronized blocks, and demonstrates its usage with practical code examples and best‑practice guidelines.

Backend DevelopmentThreadLocalconcurrency
0 likes · 8 min read
Mastering Java ThreadLocal: Achieve Thread‑Safe Objects Without synchronized
Senior Brother's Insights
Senior Brother's Insights
Feb 1, 2021 · Backend Development

Mastering Java Thread Pools: When to Use Each Executor Type

This article explains the concept of thread pools, compares seven creation methods in Java, details their parameters, execution flow, and rejection policies, and provides practical code examples to help developers choose the most appropriate pool for reliable and efficient multithreaded programming.

ThreadPoolExecutorconcurrencyexecutorservice
0 likes · 17 min read
Mastering Java Thread Pools: When to Use Each Executor Type
macrozheng
macrozheng
Jan 25, 2021 · Backend Development

Designing a Flexible Java ThreadPoolExecutor: From Basics to Advanced Features

This article walks through building a custom thread pool executor in Java, starting with a simple thread creation example, evolving through multiple design iterations, and culminating in a full-featured implementation that supports core and maximum pool sizes, task queues, thread factories, and rejection policies.

ExecutorThreadPoolExecutorconcurrency
0 likes · 10 min read
Designing a Flexible Java ThreadPoolExecutor: From Basics to Advanced Features
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 24, 2021 · Backend Development

Understanding and Using AtomicReference for Thread‑Safe Updates in Java

This article explains the limitations of volatile for compound updates, demonstrates non‑thread‑safe bank‑account examples, introduces synchronized locking, and then shows how AtomicReference with CAS operations provides a lock‑free, thread‑safe solution, including a deep dive into its internal implementation and related memory‑barrier concepts.

AtomicReferenceCASThreadSafety
0 likes · 14 min read
Understanding and Using AtomicReference for Thread‑Safe Updates in Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 13, 2021 · Backend Development

Understanding Java's AbstractQueuedSynchronizer (AQS) and Concurrency Utilities

This article provides an in-depth explanation of Java's AbstractQueuedSynchronizer (AQS) framework, covering its role in JUC concurrency utilities such as locks, semaphores, CountDownLatch, ReentrantReadWriteLock, and Condition, including template methods, state management, node structures, queue algorithms, and practical code examples.

AQSConditionJUC
0 likes · 25 min read
Understanding Java's AbstractQueuedSynchronizer (AQS) and Concurrency Utilities
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 8, 2021 · Backend Development

Deep Dive into Java HashMap, ConcurrentHashMap, JMM, and Concurrency Fundamentals

This article provides a comprehensive overview of Java's HashMap and ConcurrentHashMap implementations, explains core concurrency concepts such as thread states, the differences between concurrency and parallelism, memory models, volatile semantics, singleton patterns, thread pools, ThreadLocal, CAS, and the AQS framework.

HashMapJMMSingleton
0 likes · 31 min read
Deep Dive into Java HashMap, ConcurrentHashMap, JMM, and Concurrency Fundamentals
Top Architect
Top Architect
Jan 7, 2021 · Fundamentals

Android HashMap Source Code Analysis (Based on Android SDK 28)

This article provides a detailed analysis of the Android HashMap implementation in SDK 28, covering its fields, internal Node class, constructors, resizing logic, hash function, collision handling, and related Map implementations, with complete source code excerpts and performance considerations.

AndroidCollisionResolutionDataStructure
0 likes · 34 min read
Android HashMap Source Code Analysis (Based on Android SDK 28)
vivo Internet Technology
vivo Internet Technology
Jan 6, 2021 · Fundamentals

Deep Dive into Java Volatile Keyword: CPU Cache, MESI Protocol, and JMM

The article thoroughly explains how CPU caches and the MESI coherence protocol interact with Java’s Memory Model, detailing the volatile keyword’s role in ensuring visibility and preventing instruction reordering, and illustrates these concepts with examples such as visibility problems and double‑checked locking.

CPU cacheJMMMESI Protocol
0 likes · 22 min read
Deep Dive into Java Volatile Keyword: CPU Cache, MESI Protocol, and JMM
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 4, 2021 · Backend Development

Understanding ThreadPoolExecutor keepAliveTime=0 in Java

This article clarifies that setting keepAliveTime to 0 in a Java ThreadPoolExecutor causes excess idle threads beyond corePoolSize to terminate immediately, correcting the common misconception that 0 means threads live forever, and demonstrates the behavior with a concise code example.

ThreadPoolExecutorconcurrencyexecutorservice
0 likes · 4 min read
Understanding ThreadPoolExecutor keepAliveTime=0 in Java
Architecture Digest
Architecture Digest
Jan 3, 2021 · Operations

Understanding How Many Concurrent TCP Connections a Server Can Actually Support

This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers, details the TCP four‑tuple theory, outlines Linux file‑descriptor restrictions, shows how to tune kernel buffers with sysctl, and shares a real‑world test achieving one million active connections.

LinuxTCPconcurrency
0 likes · 6 min read
Understanding How Many Concurrent TCP Connections a Server Can Actually Support
ITPUB
ITPUB
Dec 31, 2020 · Operations

How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits

This article demystifies common misconceptions about server concurrency, explains the theoretical maximum TCP connections based on the four‑tuple, details Linux file‑descriptor and buffer limits, and walks through a practical experiment that achieves over one million simultaneous connections on a single machine.

LinuxPerformanceTCP
0 likes · 7 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits
FunTester
FunTester
Dec 31, 2020 · Operations

Speed Up Load Test Preparation with Java CyclicBarrier

This article explains how to use Java's CyclicBarrier and related concurrency utilities to parallelize user login preparation for load testing, reducing setup time and synchronizing multi‑stage performance tests with concrete code examples and sample console output.

CyclicBarrierconcurrencyjava
0 likes · 8 min read
Speed Up Load Test Preparation with Java CyclicBarrier
Liangxu Linux
Liangxu Linux
Dec 30, 2020 · Backend Development

Master High-Performance Backend Development: 10 Essential Techniques

This guide walks developers through a step‑by‑step progression of performance‑boosting techniques—including zero‑copy I/O, epoll, thread pools, lock‑free programming, IPC, RPC, database indexing, caching, Bloom filters, full‑text search, and load balancing—to help build faster, more scalable backend services.

Backend PerformanceI/O optimizationRPC
0 likes · 22 min read
Master High-Performance Backend Development: 10 Essential Techniques
Liangxu Linux
Liangxu Linux
Dec 30, 2020 · Backend Development

How Servers Serve Millions: Processes, Threads, and Event Loops Explained

This article explains how servers handle massive concurrent requests by evolving from simple multi‑process models to lightweight threads, then to event‑driven architectures with I/O multiplexing, highlighting the trade‑offs of blocking versus non‑blocking I/O and the role of coroutines.

IO MultiplexingNon-blocking IOThreads
0 likes · 12 min read
How Servers Serve Millions: Processes, Threads, and Event Loops Explained
Java Interview Crash Guide
Java Interview Crash Guide
Dec 29, 2020 · Backend Development

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

This article explains why traditional locks fail under massive concurrent traffic, how distributed locks coordinate multiple servers to ensure correct total payouts, and compares Redis and Zookeeper implementations, highlighting their mechanisms, pitfalls, and practical considerations for large‑scale systems.

Distributed LockZookeeperconcurrency
0 likes · 13 min read
How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems
High Availability Architecture
High Availability Architecture
Dec 27, 2020 · Fundamentals

Understanding Coroutines: From Ordinary Functions to User‑Level Threads

This article explains the concept of coroutines, compares them with ordinary functions, shows Python code examples of yielding and resuming execution, illustrates their historical background, and describes how they are implemented using heap‑allocated stack frames to achieve lightweight, user‑level concurrency.

Programming FundamentalsPythonconcurrency
0 likes · 13 min read
Understanding Coroutines: From Ordinary Functions to User‑Level Threads
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 25, 2020 · Backend Development

CountDownLatch in Java: Usage, Examples, and Source Code Analysis

This article introduces Java's CountDownLatch synchronization tool, explains its purpose as a gate or counter, demonstrates basic and advanced usage with code examples—including a simple counter and a student race scenario—and provides an in‑depth analysis of its underlying AQS‑based source code.

AQSCountDownLatchconcurrency
0 likes · 15 min read
CountDownLatch in Java: Usage, Examples, and Source Code Analysis
360 Quality & Efficiency
360 Quality & Efficiency
Dec 25, 2020 · Backend Development

Evolution of Redis Distributed Locks and Redisson Implementation Analysis

This article explains how distributed lock requirements arise when scaling from monolithic to multi‑server architectures, reviews the evolution of Redis‑based locking mechanisms from simple SETNX to Lua scripts and Redisson's advanced features, and provides detailed source‑code analysis of Redisson's lock, unlock, and lock acquisition implementations.

LockRedisconcurrency
0 likes · 12 min read
Evolution of Redis Distributed Locks and Redisson Implementation Analysis
Architect's Tech Stack
Architect's Tech Stack
Dec 24, 2020 · Fundamentals

Why System.currentTimeMillis() Can Be Slow Under High Concurrency and How to Optimize It

The article explains that System.currentTimeMillis()—a common Java API for timestamps—can become dramatically slower when called concurrently or very frequently, analyzes the native implementation causing the slowdown, and presents a cached‑clock solution to mitigate the performance issue.

OptimizationSystem.currentTimeMillisconcurrency
0 likes · 5 min read
Why System.currentTimeMillis() Can Be Slow Under High Concurrency and How to Optimize It
macrozheng
macrozheng
Dec 24, 2020 · Backend Development

Mastering Java Thread Pools: When and How to Choose the Right One

This article explains the concept of thread pools, compares seven creation methods—including FixedThreadPool, CachedThreadPool, and ThreadPoolExecutor—covers their parameters, execution flow, and rejection policies, and offers guidance on selecting the most appropriate pool for Java applications.

concurrencyexecutorservicejava
0 likes · 20 min read
Mastering Java Thread Pools: When and How to Choose the Right One
Code Ape Tech Column
Code Ape Tech Column
Dec 17, 2020 · Backend Development

108 Essential Java Multithreading Interview Questions and Answers

This comprehensive guide compiles 108 common Java multithreading interview questions, covering the purpose of concurrency, thread creation methods, lifecycle nuances, synchronization utilities, memory visibility, thread safety levels, debugging techniques, executor frameworks, concurrent collections, atomic operations, lock implementations, and best‑practice recommendations.

ExecutorSynchronizationconcurrency
0 likes · 59 min read
108 Essential Java Multithreading Interview Questions and Answers
High Availability Architecture
High Availability Architecture
Dec 16, 2020 · Backend Development

Implementing Task Scheduling Dependencies and Workflow with Go and DAG

This article explains the concepts of task scheduling dependencies and workflow, introduces graph theory basics such as vertices, edges, and DAGs, and provides a complete Go implementation—including graph structures, BFS traversal, topological sorting, and concurrent execution—to efficiently manage dependent tasks in distributed systems.

DAGGoTask scheduling
0 likes · 10 min read
Implementing Task Scheduling Dependencies and Workflow with Go and DAG
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 16, 2020 · Backend Development

Using Condition to Replace wait/notify for Safer and Faster Java Thread Communication

This article explains why Java's Condition class should replace wait/notify for thread communication, demonstrates the thread‑livelock problem with notify, shows how Condition avoids it, compares performance with notifyAll, and provides complete code examples for producer‑consumer scenarios.

ConditionPerformanceThread Communication
0 likes · 13 min read
Using Condition to Replace wait/notify for Safer and Faster Java Thread Communication
Programmer DD
Programmer DD
Dec 11, 2020 · Backend Development

Why Does Executors.newSingleThreadExecutor Shut Down Unexpectedly? Uncovering GC and Finalize Mysteries

This article investigates the intermittent RejectedExecutionException caused by Executors.newSingleThreadExecutor, explains how Java's garbage collector and finalize method can prematurely shut down thread pools, demonstrates the behavior with reproducible code, and shows how newer JDK versions have fixed the issue.

GarbageCollectionconcurrencyfinalize
0 likes · 11 min read
Why Does Executors.newSingleThreadExecutor Shut Down Unexpectedly? Uncovering GC and Finalize Mysteries
MaGe Linux Operations
MaGe Linux Operations
Dec 10, 2020 · Backend Development

Is Async Python Really Faster? Uncover the Sync vs Async Truth

This article explains the difference between synchronous and asynchronous Python, how each model handles concurrency, the two main async implementations (coroutine‑based and greenlet‑based), and when async can actually outperform sync in high‑load, I/O‑bound scenarios.

Synchronizationasyncbackend
0 likes · 12 min read
Is Async Python Really Faster? Uncover the Sync vs Async Truth
Architecture Digest
Architecture Digest
Dec 9, 2020 · Backend Development

Implementing Distributed Locks with Redis: Concepts, Algorithms, and Code Examples

This article explains how to implement distributed locks using Redis, covering the essential requirements of mutual exclusion, deadlock avoidance, and fault tolerance, detailing single‑instance and multi‑instance algorithms, code examples with SETNX and Lua scripts, and discussing challenges such as latency, crashes, and persistence.

Backend Developmentconcurrencyfault tolerance
0 likes · 10 min read
Implementing Distributed Locks with Redis: Concepts, Algorithms, and Code Examples
ITPUB
ITPUB
Dec 8, 2020 · Operations

How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits

This article demystifies the true maximum number of concurrent TCP connections a single Linux server can sustain, explaining the theoretical limits of the TCP four‑tuple, the practical constraints imposed by file descriptor and memory settings, and walks through a real‑world experiment achieving one million connections.

LinuxServerTCP
0 likes · 6 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits
JD Retail Technology
JD Retail Technology
Dec 1, 2020 · Fundamentals

In‑Depth Source Code Analysis of Kotlin Coroutines: Launch, Suspension, and Resumption

This article provides a comprehensive source‑code walkthrough of Kotlin coroutines, explaining how launch creates a coroutine, how the compiler transforms suspend functions into state‑machine classes, and detailing the mechanisms of suspension and resumption through Continuation, Dispatchers, and the coroutine scheduler.

CoroutinesDispatcherKotlin
0 likes · 46 min read
In‑Depth Source Code Analysis of Kotlin Coroutines: Launch, Suspension, and Resumption
Programmer DD
Programmer DD
Nov 30, 2020 · Backend Development

How Many Threads Are Optimal? Mastering Thread Pool Sizing for Maximum Performance

This article explains why multithreading improves program performance, distinguishes latency reduction from throughput increase, and provides practical formulas to determine the ideal number of threads for both I/O‑bound and CPU‑bound workloads, helping you fully utilize hardware resources.

I/O Boundconcurrencycpu-utilization
0 likes · 4 min read
How Many Threads Are Optimal? Mastering Thread Pool Sizing for Maximum Performance
Selected Java Interview Questions
Selected Java Interview Questions
Nov 24, 2020 · Backend Development

Understanding Java BlockingQueue: Concepts, Implementations, and a Custom Example

This article explains the fundamentals of queues and blocking queues, describes how Java's java.util.concurrent.BlockingQueue works, outlines its main methods and common implementations, and provides a complete custom BlockingQueue source code example for multithreaded producer‑consumer scenarios.

Backend Developmentblockingqueueconcurrency
0 likes · 10 min read
Understanding Java BlockingQueue: Concepts, Implementations, and a Custom Example
Architecture Digest
Architecture Digest
Nov 18, 2020 · Backend Development

Deep Dive into Java ConcurrentHashMap: Implementation, Concurrency Mechanisms, and Core Methods

This article provides a comprehensive analysis of Java's ConcurrentHashMap, covering its historical evolution, key internal fields, the thread‑safe put and remove operations, the complex resizing and transfer mechanisms, and auxiliary methods such as size, get, and clear, all illustrated with original source code.

Data StructuresJDKconcurrency
0 likes · 24 min read
Deep Dive into Java ConcurrentHashMap: Implementation, Concurrency Mechanisms, and Core Methods
Laravel Tech Community
Laravel Tech Community
Nov 15, 2020 · Databases

MySQL Lock Types and Deadlock Causes with Practical Examples

This article explains MySQL's three lock levels—table, row, and page—describes next‑key, gap, and record locks, analyzes why deadlocks occur, and provides multiple real‑world examples and prevention strategies, including code snippets for reproducible scenarios.

DatabaseDeadlockInnoDB
0 likes · 12 min read
MySQL Lock Types and Deadlock Causes with Practical Examples
MaGe Linux Operations
MaGe Linux Operations
Nov 15, 2020 · Backend Development

Why Distributed Locks Matter: Redis vs Zookeeper Explained

This article examines the stock‑oversell problem in high‑concurrency e‑commerce systems, explains why native JVM locks fail in multi‑machine deployments, and compares practical distributed‑lock solutions using Redis (including RedLock and Redisson) and Zookeeper (with Curator), highlighting their advantages, drawbacks, and selection guidelines.

Distributed Lockbackendconcurrency
0 likes · 18 min read
Why Distributed Locks Matter: Redis vs Zookeeper Explained
Java Captain
Java Captain
Nov 7, 2020 · Backend Development

Why Use Distributed Locks? Implementations with Redis and Zookeeper

The article explains the stock‑oversell problem in a single‑machine e‑commerce system, shows why native Java locks fail in multi‑node deployments, and then details practical distributed‑lock solutions using Redis (including SET NX PX, Lua‑based release, RedLock algorithm and Redisson) and Zookeeper (ephemeral sequential nodes and Curator), before comparing their advantages, drawbacks, and offering selection guidance.

Distributed LockZookeeperconcurrency
0 likes · 17 min read
Why Use Distributed Locks? Implementations with Redis and Zookeeper
FunTester
FunTester
Nov 5, 2020 · Operations

How to Implement Fixed‑QPS Load Testing and Fix Common Bugs

This article explains a practical fixed‑QPS load‑testing model for HTTP requests, provides reusable Java code for creating test tasks, and details two bug fixes—one for thread‑pool shutdown handling in asynchronous compensation threads and another for inaccurate request‑counting that caused over‑compensation.

Bug FixPerformanceconcurrency
0 likes · 7 min read
How to Implement Fixed‑QPS Load Testing and Fix Common Bugs
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 5, 2020 · Fundamentals

Why Understanding JVM Garbage Collection Algorithms Is Essential for Advanced Java Developers

This article explores the underlying principles of Java Virtual Machine garbage collection, detailing core concepts, classic algorithms, generational and incremental improvements, and the role of read/write barriers, helping developers grasp why mastering GC is a fundamental skill for high‑performance Java programming.

GC AlgorithmsGarbage Collectionconcurrency
0 likes · 26 min read
Why Understanding JVM Garbage Collection Algorithms Is Essential for Advanced Java Developers
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 2, 2020 · Backend Development

Java Multithreaded Sequential Printing: Solutions Using Lock, wait/notify, Condition, Semaphore, and LockSupport

This article presents various Java solutions for common interview multithreading problems that require sequential printing, demonstrating implementations using Lock, wait/notify, Condition, Semaphore, and LockSupport, along with detailed code examples and explanations of thread communication mechanisms.

LockSemaphoreconcurrency
0 likes · 15 min read
Java Multithreaded Sequential Printing: Solutions Using Lock, wait/notify, Condition, Semaphore, and LockSupport
Programmer DD
Programmer DD
Oct 30, 2020 · Backend Development

Why Reactive Programming Is the Future of High-Concurrency Java Development

This article explains how reactive programming, introduced by Microsoft in 2009 and adopted by Java through frameworks like RxJava and Spring Reactor, addresses high‑concurrency server‑side challenges, clarifies concepts such as backpressure, and compares Reactor with RxJava for modern backend engineers.

RxJavaSpring Reactorbackpressure
0 likes · 13 min read
Why Reactive Programming Is the Future of High-Concurrency Java Development
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Oct 20, 2020 · Mobile Development

Why YYCache Excels: Deep Dive into iOS Cache Design & Performance

This article examines the YYCache iOS library, covering its multi‑level architecture, LRU implementation, thread‑safe APIs, eviction policies, lock choices, disk‑storage strategies, Swift integration, performance benchmarks, and practical takeaways for building high‑performance mobile caches.

CacheLRUPerformance
0 likes · 24 min read
Why YYCache Excels: Deep Dive into iOS Cache Design & Performance
Architecture Digest
Architecture Digest
Oct 20, 2020 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Creation, Task Execution, and Shutdown Mechanisms

This article provides an in‑depth analysis of Java's ThreadPoolExecutor, explaining how Executors' factory methods create pools, detailing the constructor parameters, internal state management, task submission via execute, worker thread lifecycle, and the differences between shutdown and shutdownNow, with code excerpts for clarity.

ExecutorsShutdownThreadPoolExecutor
0 likes · 19 min read
Deep Dive into Java ThreadPoolExecutor: Creation, Task Execution, and Shutdown Mechanisms