Tagged articles

Concurrency

2155 articles · Page 18 of 22

Jun 16, 2020 · Backend Development

How to Optimize Java Thread Pool Settings for Maximum Performance

This article explains the principles behind Java thread pools, details the Executor framework, describes key parameters, provides formulas for calculating optimal thread counts for CPU‑bound and I/O‑bound workloads, and includes practical code examples and performance test results to help developers fine‑tune their thread pools.

ConcurrencyExecutorJava

0 likes · 14 min read

How to Optimize Java Thread Pool Settings for Maximum Performance

Architect's Tech Stack

Jun 15, 2020 · Backend Development

Understanding Java Stream Pipeline: Implementation Principles and Execution

This article explains how Java Stream pipelines are built and executed, covering operation recording, the role of stages and sinks, differences between intermediate and terminal operations, and how the library achieves efficient single-pass processing while avoiding common pitfalls.

ConcurrencyJavabackend

0 likes · 17 min read

Understanding Java Stream Pipeline: Implementation Principles and Execution

Selected Java Interview Questions

Jun 13, 2020 · Fundamentals

Why StringBuilder Is Not Thread‑Safe and How It Differs from StringBuffer

This article explains the internal implementation of Java's StringBuilder and StringBuffer, demonstrates how concurrent appends cause incorrect lengths and occasional ArrayIndexOutOfBoundsException, and shows why StringBuffer remains thread‑safe by using synchronized methods.

ConcurrencyJavaStringBuffer

0 likes · 7 min read

Why StringBuilder Is Not Thread‑Safe and How It Differs from StringBuffer

Youzan Coder

Jun 12, 2020 · Fundamentals

When to Use synchronized vs. Lock: Mastering Java Locks

This article explains Java's lock mechanisms, comparing synchronized and the Lock interface, detailing their usage, implementation via AQS, system‑level primitives, and providing code examples to help developers choose the appropriate synchronization tool.

AQSConcurrencyJava

0 likes · 11 min read

When to Use synchronized vs. Lock: Mastering Java Locks

macrozheng

Jun 12, 2020 · Databases

Why Does MySQL Show Negative Balances? Unraveling MVCC and Isolation Levels

This article analyzes a production incident where concurrent MySQL transactions caused an over‑deduction of account balance, explains the underlying MVCC mechanism, consistency view rules, and how different isolation levels (RR vs RC) affect data visibility and lead to negative balances.

ConcurrencyDatabaseInnoDB

0 likes · 12 min read

Why Does MySQL Show Negative Balances? Unraveling MVCC and Isolation Levels

Selected Java Interview Questions

Jun 11, 2020 · Fundamentals

Understanding Java Runtime Memory Areas and the Java Memory Model

This article explains the distinction between Java memory regions and the Java Memory Model, describes each JVM runtime data area—including the program counter, stacks, heap, metaspace, and direct memory—and outlines how the model governs visibility, ordering, and synchronization in concurrent programs.

ConcurrencyGarbage CollectionJVM

0 likes · 20 min read

Understanding Java Runtime Memory Areas and the Java Memory Model

MaGe Linux Operations

Jun 10, 2020 · Fundamentals

Understanding Processes and Threads: Core Concepts, Lifecycle, and Scheduling

This article explains operating system fundamentals such as process and thread definitions, time‑slice preemptive scheduling, process features and lifecycle, thread characteristics, priority handling, multi‑core execution models, and synchronization mechanisms like mutexes and semaphores.

ConcurrencySchedulingprocess

0 likes · 17 min read

Understanding Processes and Threads: Core Concepts, Lifecycle, and Scheduling

Python Programming Learning Circle

Jun 8, 2020 · Backend Development

Understanding Synchronous vs Asynchronous Programming in Python with asyncio and aiohttp

This article explains the limitations of Python's GIL, compares synchronous and asynchronous execution models, introduces asyncio and aiohttp, provides concrete code examples for single and multiple concurrent HTTP requests, and offers solutions for common concurrency errors such as too many file descriptors.

ConcurrencyPythonaiohttp

0 likes · 8 min read

Understanding Synchronous vs Asynchronous Programming in Python with asyncio and aiohttp

Programmer DD

Jun 8, 2020 · Fundamentals

Why Java Replaced synchronized with Lock and How AQS Powers Modern Concurrency

This article explains why Java introduced the Lock API after Java 1.5, compares it with synchronized, details the explicit lock features, walks through the AQS (AbstractQueuedSynchronizer) implementation, and shows how ReentrantLock, fairness, reentrancy, and conditions are built on top of AQS.

AQSConcurrencyJava

0 likes · 36 min read

Why Java Replaced synchronized with Lock and How AQS Powers Modern Concurrency

Xueersi Online School Tech Team

Jun 5, 2020 · Fundamentals

Understanding Go Stack Memory Management: Initialization, Allocation, Expansion, and Shrinking

This article explains how Go's runtime initializes, allocates, expands, and shrinks goroutine stack memory, detailing the underlying heap structures, global pools, platform‑specific constants, and the code paths that handle stack growth and reclamation.

ConcurrencyGogoroutine

0 likes · 11 min read

Understanding Go Stack Memory Management: Initialization, Allocation, Expansion, and Shrinking

Python Programming Learning Circle

Jun 4, 2020 · Fundamentals

Python Multiprocessing Module: Process Creation, Synchronization, and Inter‑Process Communication

This article provides a comprehensive guide to Python's multiprocessing module, covering how to create and manage processes, use join for synchronization, configure daemon processes, and employ synchronization primitives such as Lock, Semaphore, Event, and Queue for safe inter‑process communication, with complete code examples.

ConcurrencyInterprocess CommunicationMultiprocessing

0 likes · 12 min read

Python Multiprocessing Module: Process Creation, Synchronization, and Inter‑Process Communication

Selected Java Interview Questions

Jun 2, 2020 · Backend Development

Deep Dive into ThreadPoolExecutor: Principles, State Control, and Source Code Analysis

This article provides a comprehensive analysis of Java's ThreadPoolExecutor, covering its underlying JUC synchronizer framework, core and non‑core thread handling, state management, key configuration parameters, and detailed walkthrough of critical source‑code methods such as execute, addWorker, and runWorker, supplemented with illustrative code examples.

AQSConcurrencyCoreThreadPool

0 likes · 30 min read

Deep Dive into ThreadPoolExecutor: Principles, State Control, and Source Code Analysis

Huawei Cloud Developer Alliance

Jun 1, 2020 · Fundamentals

Master Java Singleton: DCL, Volatile, Static Inner Class & Enum Explained

This article explores several advanced Java singleton implementations—including double‑check locking with volatile, static inner‑class lazy loading, and enum‑based singletons—explaining their mechanisms, thread‑safety benefits, and trade‑offs for modern backend development.

ConcurrencyDCLEnum

0 likes · 8 min read

Master Java Singleton: DCL, Volatile, Static Inner Class & Enum Explained

FunTester

Jun 1, 2020 · Backend Development

Avoiding Read‑Modify‑Write Race Conditions in ConcurrentHashMap Using Lambda compute

The article explains how read‑modify‑write race conditions can occur when updating a ConcurrentHashMap from multiple threads, demonstrates a failing JUnit example, and shows how using the atomic compute method with a lambda expression eliminates the race and ensures thread‑safe updates.

ComputeConcurrencyJava

0 likes · 7 min read

Avoiding Read‑Modify‑Write Race Conditions in ConcurrentHashMap Using Lambda compute

Selected Java Interview Questions

May 31, 2020 · Backend Development

Java Interview Question Series (Issues 1‑100) – Collection of Article Links

This page compiles a chronological list of 100 WeChat articles covering Java interview topics, including core language concepts, data structures, concurrency, Spring, MySQL, Redis, and system design, providing readers with direct links to each issue for comprehensive preparation.

ConcurrencyData StructuresJava

0 likes · 13 min read

Java Interview Question Series (Issues 1‑100) – Collection of Article Links

Laravel Tech Community

May 30, 2020 · Backend Development

Mastering Swoole Locks in PHP: Types, Methods, and Practical Examples

This guide explains how to use Swoole\Lock in PHP, covering the five supported lock types, constructor parameters, key methods such as lock, unlock, trylock, lockwait, and lock_read, along with best‑practice warnings and a complete example demonstrating inter‑process synchronization.

ConcurrencyLockPHP

0 likes · 5 min read

Mastering Swoole Locks in PHP: Types, Methods, and Practical Examples

Laravel Tech Community

May 29, 2020 · Backend Development

Swoole Coroutine Channel: Overview, Methods, and Example Usage

This article introduces Swoole's Coroutine Channel for inter‑coroutine communication, explains its memory‑efficient implementation and key methods such as __construct, push, pop, stats, close, length, isEmpty, isFull, capacity and errCode, and provides a complete PHP example demonstrating producer‑consumer behavior.

ConcurrencyPHPSwoole

0 likes · 5 min read

Swoole Coroutine Channel: Overview, Methods, and Example Usage

Laravel Tech Community

May 28, 2020 · Backend Development

Using Swoole Atomic for Lock‑Free Counters in PHP

Because PHP lacks native multithreading, Swoole adopts a multi‑process model and provides the Atomic class for lock‑free integer operations, which can be shared across worker processes; this guide explains its purpose, configuration, usage patterns, code examples, and important pitfalls.

ConcurrencyPHPServer

0 likes · 3 min read

Using Swoole Atomic for Lock‑Free Counters in PHP

macrozheng

May 27, 2020 · Backend Development

Master Java Thread Interruption: Using interrupt(), isInterrupted() & interrupted()

This article explains Java’s thread interruption mechanism, detailing the purpose and differences of interrupt(), isInterrupted() and interrupted(), how interruption flags work, when InterruptedException is thrown, proper handling practices, common usage scenarios, and examples from JDK classes such as ThreadPoolExecutor and FutureTask.

ConcurrencyInterrupt APIJava

0 likes · 12 min read

Master Java Thread Interruption: Using interrupt(), isInterrupted() & interrupted()

Programmer DD

May 26, 2020 · Backend Development

Deep Dive into Java's ConcurrentHashMap: Implementation, Put & Remove Mechanics

This article thoroughly examines Java's ConcurrentHashMap, covering its evolution from JDK 1.7 segmented locks to JDK 1.8's CAS‑based design, detailing key internal fields, the thread‑safe put and remove operations, and the complex resizing and transfer mechanisms that enable high‑concurrency performance.

ConcurrencyHashMapJava

0 likes · 24 min read

Deep Dive into Java's ConcurrentHashMap: Implementation, Put & Remove Mechanics

FunTester

May 25, 2020 · Fundamentals

Understanding Java Daemon Threads and How to Create Them

This article explains what daemon threads are in Java, how they differ from user threads, the importance of setDaemon(true), provides the official setDaemon method documentation, and includes a complete demo program showing a daemon thread printing messages every second until the main thread ends.

ConcurrencyDaemon ThreadJava

0 likes · 4 min read

Understanding Java Daemon Threads and How to Create Them

Laravel Tech Community

May 21, 2020 · Databases

When to Use Optimistic vs. Pessimistic Locks in MySQL (and Redis)

This article explains the concepts, advantages, and drawbacks of MySQL pessimistic and optimistic locks, shows how to implement each with SQL and PHP code, compares their suitability for different traffic patterns, and demonstrates a Redis‑based optimistic lock for high‑concurrency flash‑sale scenarios.

ConcurrencyMySQLPHP

0 likes · 10 min read

When to Use Optimistic vs. Pessimistic Locks in MySQL (and Redis)

Liangxu Linux

May 20, 2020 · Fundamentals

Essential Operating System Concepts: From Kernel Mode to Virtualization

This article provides a comprehensive, numbered glossary of core operating‑system concepts—including OS fundamentals, kernel and user modes, memory hierarchy, process management, I/O mechanisms, virtualization, and networking—each defined succinctly and illustrated with diagrams to aid understanding.

ConcurrencyFundamentalsnetworking

0 likes · 48 min read

Essential Operating System Concepts: From Kernel Mode to Virtualization

Sohu Tech Products

May 20, 2020 · Mobile Development

Understanding Deadlocks and Their Prevention in Android Development

This article explains the concept of deadlocks, illustrates classic scenarios such as the dining philosophers problem, shows common lock‑order and multi‑object deadlocks with Java code examples, and details Android's WatchDog mechanism and practical techniques for detecting and avoiding deadlocks in mobile applications.

ConcurrencyDeadlockJava

0 likes · 21 min read

Understanding Deadlocks and Their Prevention in Android Development

Python Programming Learning Circle

May 20, 2020 · Fundamentals

Comprehensive Guide to Python Threading, Locks, Semaphores, Events and Timers

This article explains Python's threading module, demonstrating how to import it, create and manage single and multiple threads, use thread locks (Lock and RLock), condition variables, semaphores, events, thread‑local storage, and timers, providing complete code examples for each concept.

ConcurrencyEventLock

0 likes · 12 min read

Comprehensive Guide to Python Threading, Locks, Semaphores, Events and Timers

Programmer DD

May 20, 2020 · Backend Development

Understanding Java's java.util.concurrent (J.U.C) Framework and AQS Mechanism

This article provides a comprehensive overview of Java's java.util.concurrent package, detailing its core components such as atomic classes, locks, collections, executors, tools, as well as an in‑depth explanation of the AbstractQueuedSynchronizer (AQS) framework, its fields, methods, and related concurrency utilities like FutureTask, BlockingQueue, ForkJoin, and work‑stealing algorithms.

AQSConcurrencyForkJoin

0 likes · 22 min read

Understanding Java's java.util.concurrent (J.U.C) Framework and AQS Mechanism

Java Captain

May 14, 2020 · Fundamentals

Understanding Java volatile: Visibility, Ordering, and Usage in Concurrent Programming

This article explains Java's volatile keyword as a lightweight synchronization mechanism, covering its role in ensuring visibility, ordering, and limited atomicity, the underlying Java Memory Model concepts of atomicity, visibility, and ordering, and when volatile is appropriate or insufficient in concurrent programming.

ConcurrencyJavaMemory Model

0 likes · 12 min read

Understanding Java volatile: Visibility, Ordering, and Usage in Concurrent Programming

Full-Stack Internet Architecture

May 13, 2020 · Fundamentals

Java 8 New Features and Functional Programming Overview

An extensive guide to Java 8’s new capabilities, covering lambda expressions, functional interfaces, streams, default methods, Optional, CompletableFuture, the new date‑time API, concurrency enhancements, and numerous language and library improvements, with detailed explanations and code examples.

CompletableFutureConcurrencyFunctional Interfaces

0 likes · 51 min read

Java 8 New Features and Functional Programming Overview

Open Source Linux

May 11, 2020 · Fundamentals

Understanding Processes: Basics, Forking, and Lifecycle in Operating Systems

This article explains what a process is, how it differs from a program, outlines its key characteristics, clarifies concurrency versus parallelism, describes how to create child processes, and covers orphan and zombie processes, termination methods, process groups, sessions, and race conditions.

ConcurrencyForkoperating system

0 likes · 7 min read

Understanding Processes: Basics, Forking, and Lifecycle in Operating Systems

FunTester

May 9, 2020 · Fundamentals

Mastering Java Synchronization: Object vs Class Locks Explained

This guide explains Java's synchronized keyword, detailing how object‑level and class‑level locks work, provides code examples for each, and lists essential best‑practice tips and common pitfalls to avoid when writing thread‑safe Java code.

ConcurrencyJavaLocks

0 likes · 6 min read

Mastering Java Synchronization: Object vs Class Locks Explained

58 Tech

May 8, 2020 · Backend Development

Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning

This article analyzes the performance bottlenecks of the 58 used‑car list service under high concurrency, breaks down data‑query and data‑transfer stages, and presents three optimization solutions—including query redesign, concurrent data conversion, and thread‑pool parameter tuning—that together reduce latency by over 80 ms and improve resource utilization.

ConcurrencyJavahigh concurrency

0 likes · 9 min read

Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning

Python Programming Learning Circle

May 8, 2020 · Fundamentals

Introduction to the Producer‑Consumer Model with Queue and JoinableQueue in Python

This article explains the producer‑consumer pattern, why it is needed, and demonstrates two Python implementations using a standard Queue and a JoinableQueue, including full code samples, execution results, and discussion of graceful termination for multiple consumers.

ConcurrencyJoinableQueueMultiprocessing

0 likes · 8 min read

Introduction to the Producer‑Consumer Model with Queue and JoinableQueue in Python

Big Data Technology & Architecture

May 7, 2020 · Fundamentals

Understanding the Implementation of ConcurrentHashMap in JDK 7 and JDK 8

This article explains how ConcurrentHashMap ensures thread safety in Java, comparing the lock‑segmentation design of JDK 7 with the CAS‑based, bucket‑level synchronization of JDK 8, and includes key source code excerpts illustrating the insertion process.

CASConcurrencyJDK7

0 likes · 11 min read

Understanding the Implementation of ConcurrentHashMap in JDK 7 and JDK 8

Liangxu Linux

May 5, 2020 · Backend Development

Why Do “Average” Candidates Struggle in Java Interviews? Real Stories and Tips

The author reflects on recent campus recruitment interviews, sharing personal anecdotes, common pitfalls in Java fundamentals, collections, concurrency, and Redis, and offers practical advice on how candidates can improve their technical depth and interview performance.

ConcurrencyHashMapJava

0 likes · 22 min read

Why Do “Average” Candidates Struggle in Java Interviews? Real Stories and Tips

dbaplus Community

Apr 27, 2020 · Backend Development

Why Your Redis Distributed Lock May Fail and How to Fix It

This article examines common failure scenarios of Redis‑based distributed locks, compares a simple lock implementation with the Redlock algorithm, and provides practical solutions for single‑point failures, lock expiration issues, clock drift, and high‑concurrency pitfalls.

ConcurrencyDistributed LockJava

0 likes · 18 min read

Why Your Redis Distributed Lock May Fail and How to Fix It

Radish, Keep Going!

Apr 24, 2020 · Fundamentals

Mastering Go’s sync.Cond: Coordinating Goroutine Execution with Condition Variables

This article explains how Go's sync.Cond works, demonstrates its usage with practical code examples, analyzes its internal implementation, and shows a real‑world application in Kubernetes FIFO queues, helping developers control goroutine synchronization effectively.

ConcurrencyGobackend

0 likes · 6 min read

Mastering Go’s sync.Cond: Coordinating Goroutine Execution with Condition Variables

MaGe Linux Operations

Apr 22, 2020 · Fundamentals

Demystifying Concurrency: From Threads to Coroutines and Monitors

This article clarifies core operating‑system concepts such as tasks, jobs, hyper‑threading, threads, processes, fibers, monitors, and coroutines, explaining their differences, relationships, and how they enable efficient concurrent execution.

ConcurrencyCoroutinesThreads

0 likes · 8 min read

Demystifying Concurrency: From Threads to Coroutines and Monitors

Programmer DD

Apr 22, 2020 · Backend Development

How ThreadLocal Guarantees Thread Isolation and Avoids Memory Leaks in Java

ThreadLocal provides thread‑confined variables in Java, eliminating race conditions without synchronization; this article explains its concept, demonstrates usage with code examples, analyzes the underlying ThreadLocalMap implementation, discusses hash calculations, potential memory‑leak pitfalls, and outlines common application scenarios.

ConcurrencyJavaThreadLocal

0 likes · 15 min read

How ThreadLocal Guarantees Thread Isolation and Avoids Memory Leaks in Java

Programmer DD

Apr 21, 2020 · Backend Development

Unlocking Java’s Unsafe: How CAS Powers High‑Performance Concurrency

This article explains Java's Unsafe class, its low‑level memory operations, how Compare‑and‑Swap (CAS) is implemented via Unsafe, and how AtomicInteger leverages CAS for lock‑free thread safety while also covering the ABA problem and its mitigation.

AtomicIntegerCASConcurrency

0 likes · 9 min read

Unlocking Java’s Unsafe: How CAS Powers High‑Performance Concurrency

Selected Java Interview Questions

Apr 17, 2020 · Backend Development

Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

This article explains the advantages of Java thread pools, breaks down the ThreadPoolExecutor parameters and execution flow, compares common pool types, and demonstrates how to implement a thread‑pool as a singleton to efficiently manage concurrency in backend applications.

ConcurrencyDesignPatternJava

0 likes · 10 min read

Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

Qunar Tech Salon

Apr 15, 2020 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Design, Implementation, and Dynamic Configuration

This article explains the concept, design, and internal implementation of Java's ThreadPoolExecutor, discusses common thread‑pool problems, presents dynamic configuration solutions, and provides practical usage scenarios and code examples to help developers efficiently manage concurrency in backend applications.

ConcurrencyJavaThreadPoolExecutor

0 likes · 27 min read

Deep Dive into Java ThreadPoolExecutor: Design, Implementation, and Dynamic Configuration

Selected Java Interview Questions

Apr 13, 2020 · Backend Development

Differences Between synchronized and Lock in Java with Code Examples

This article explains Java's thread synchronization mechanisms by comparing synchronized blocks with the Lock interface, detailing thread basics, lifecycle methods, lock types, code demonstrations, fairness settings, and underlying JVM implementations, helping readers understand when and how to use each construct effectively.

ConcurrencyJavaLock

0 likes · 17 min read

Differences Between synchronized and Lock in Java with Code Examples

21CTO

Apr 12, 2020 · Backend Development

What I Learned from 20+ Java Backend Interviews: Questions, Answers, and Tips

The author, a 985‑master’s graduate, shares a detailed chronicle of her preparation and interview experiences across dozens of Chinese tech giants, listing the technical questions asked—ranging from Java fundamentals, JVM internals, concurrency, data structures, design patterns, to system design—and offering practical advice for future candidates.

ConcurrencyJVMalgorithms

0 likes · 11 min read

What I Learned from 20+ Java Backend Interviews: Questions, Answers, and Tips

FunTester

Apr 11, 2020 · Operations

Building a Java Multithreaded Performance Testing Framework: Base and Execution Classes

This article explains how to design a Java performance testing framework by defining an abstract multithreaded base class for common behaviors, implementing two virtual classes for different load‑testing modes, and creating an execution class that orchestrates thread pools, collects metrics, and generates visual reports, with full source code examples and a Gitee repository link.

ConcurrencyJavaMultithreading

0 likes · 12 min read

Building a Java Multithreaded Performance Testing Framework: Base and Execution Classes

Selected Java Interview Questions

Apr 9, 2020 · Backend Development

Understanding Java Thread Pools: Benefits, Risks, and Best Practices

This article explains why Java thread pools are preferred over creating a new thread per request, outlines associated risks such as deadlocks, resource exhaustion, and thread leaks, and provides practical guidelines, sizing formulas, and code examples for various common thread‑pool implementations.

ConcurrencyJavaPerformance

0 likes · 14 min read

Understanding Java Thread Pools: Benefits, Risks, and Best Practices

Programmer DD

Apr 7, 2020 · Fundamentals

Why Does HashMap Become Thread‑Unsafe? Deep Dive into JDK 7 & 8 Resizing Bugs

This article explains why Java's HashMap is not thread‑safe, analyzing the dead‑loop and data‑loss problems caused by resizing in JDK 7 and the overwrite issue in JDK 8, with code examples and step‑by‑step thread interleaving illustrations.

ConcurrencyHashMapJDK7

0 likes · 11 min read

Why Does HashMap Become Thread‑Unsafe? Deep Dive into JDK 7 & 8 Resizing Bugs

Open Source Linux

Apr 6, 2020 · Backend Development

What I Learned from My Alibaba CBU Technical Interview: A Detailed Self‑Review

This article recounts the author's Alibaba CBU technical interview experience, covering self‑introduction, core computer‑science topics such as data structures, concurrency, HTTP, and security, reflections on the interview process, and a concrete plan for future technical growth.

CloudConcurrencyData Structures

0 likes · 10 min read

What I Learned from My Alibaba CBU Technical Interview: A Detailed Self‑Review

Meituan Technology Team

Apr 2, 2020 · Backend Development

Java ThreadPoolExecutor: Design, Implementation, and Dynamic Management

The article explains Java’s ThreadPoolExecutor—its purpose, core design, lifecycle management, task scheduling, worker behavior, and typical configurations for fast response or batch processing—then proposes a dynamic pool with runtime‑adjustable core and max sizes, queue selection, and real‑time monitoring to prevent mis‑configuration and boost stability.

ConcurrencyJavaThread Management

0 likes · 30 min read

Java ThreadPoolExecutor: Design, Implementation, and Dynamic Management

Programmer DD

Mar 29, 2020 · Fundamentals

Mastering Java Thread Lifecycle: States, Transitions, and Debugging Tips

This article explains Java thread lifecycle, compares OS generic thread states with Java’s six states, shows how to query thread state via getState(), and introduces debugging tools like jstack and Arthas, helping developers master state transitions and write robust concurrent code.

ArthasConcurrencyJava

0 likes · 12 min read

Mastering Java Thread Lifecycle: States, Transitions, and Debugging Tips

Selected Java Interview Questions

Mar 29, 2020 · Backend Development

Understanding Java Synchronized: Basic Usage, Underlying Mechanism, and Execution Results

This article explains the three forms of using the synchronized keyword in Java—method, static method, and block synchronization—demonstrates each with runnable code examples, analyzes the JVM monitorenter/monitorexit instructions, and clarifies why synchronized methods and blocks enforce mutual exclusion and visibility guarantees.

ConcurrencyJVMJava

0 likes · 13 min read

Understanding Java Synchronized: Basic Usage, Underlying Mechanism, and Execution Results

Selected Java Interview Questions

Mar 25, 2020 · Backend Development

Comprehensive Guide to Java HashMap: Structure, Operations, Concurrency Issues, and Interview Insights

This article provides an in‑depth explanation of Java's HashMap, covering its array‑plus‑linked‑list (and tree) structure, default capacity and load factor, constructors, put/get workflows, concurrency pitfalls, differences between Java 7 and 8, and key points to ace interview questions.

ConcurrencyData StructureHashMap

0 likes · 8 min read

Comprehensive Guide to Java HashMap: Structure, Operations, Concurrency Issues, and Interview Insights

FunTester

Mar 23, 2020 · Backend Development

Curated Collection of Java, Groovy, and Python Technical Articles

This article presents a curated list of technical resources covering Java, Groovy, and Python, including tutorials on concurrency, memory management, regular expressions, scripting, and performance optimization, each linked to detailed explanations and code examples.

ConcurrencyGroovyJava

0 likes · 9 min read

Curated Collection of Java, Groovy, and Python Technical Articles

Programmer DD

Mar 22, 2020 · Fundamentals

Why Use Locks in Java? Understanding volatile, synchronized, and CAS

This article explains why Java uses locks to prevent dirty reads and data inconsistency, compares volatile and synchronized mechanisms, details monitor-based lock implementation, lock optimizations like biased and lightweight locks, introduces CAS and AbstractQueuedSynchronizer, and illustrates these concepts with code examples and diagrams.

AQSCASConcurrency

0 likes · 13 min read

Why Use Locks in Java? Understanding volatile, synchronized, and CAS

Programmer DD

Mar 21, 2020 · Fundamentals

Why Does Concurrent Programming Need Wait/Notify? Unlock Efficient Thread Coordination

This article explains why busy‑waiting loops waste CPU in Java concurrency, introduces the wait/notify mechanism, shows how synchronized, wait() and notify()/notifyAll() work together, highlights common pitfalls such as using if instead of while, and provides practical code examples and best‑practice guidelines for safe thread coordination.

ConcurrencyJavaMESA Model

0 likes · 14 min read

Why Does Concurrent Programming Need Wait/Notify? Unlock Efficient Thread Coordination

Ctrip Technology

Mar 19, 2020 · Mobile Development

Ctrip Hotel Android Map Development: Architecture, Challenges, and Solutions

This article details the design and implementation of Ctrip's hotel Android map features, covering business background, module architecture, coordinate system handling, multithreading challenges, and practical solutions such as MVP, AsyncTask, and atomic flags to ensure smooth user experience.

AndroidConcurrencyKotlin

0 likes · 10 min read

Ctrip Hotel Android Map Development: Architecture, Challenges, and Solutions

Open Source Linux

Mar 16, 2020 · Operations

QPS vs TPS vs Concurrency: Uncovering the Real Difference in System Throughput

This article explains core performance metrics such as Queries Per Second (QPS) and Transactions Per Second (TPS), distinguishes their differences, introduces related concepts like concurrency, PV, UV, and DAU, and outlines how to evaluate system throughput and conduct basic performance testing.

ConcurrencyQPSTPS

0 likes · 9 min read

QPS vs TPS vs Concurrency: Uncovering the Real Difference in System Throughput

Selected Java Interview Questions

Mar 16, 2020 · Databases

Understanding MySQL Table Locks, Row Locks, and Gap Locks

This article explains the differences between MySQL table locks and row locks, describes how MyISAM and InnoDB handle locking, provides explicit lock syntax with examples, discusses gap locks, and offers practical recommendations for avoiding lock contention in concurrent applications.

ConcurrencyGAP LockInnoDB

0 likes · 7 min read

Understanding MySQL Table Locks, Row Locks, and Gap Locks

FunTester

Mar 15, 2020 · Backend Development

Curated Collection of Java, Groovy, and Python Articles

This curated collection presents dozens of Chinese-language articles covering Java, Groovy, and Python topics such as concurrency, performance optimization, regular expressions, JMeter scripting, and algorithmic challenges, providing links to in-depth tutorials and code examples for developers seeking to deepen their programming expertise.

ConcurrencyGroovyJava

0 likes · 9 min read

Curated Collection of Java, Groovy, and Python Articles

Programmer DD

Mar 8, 2020 · Backend Development

Mastering Java NIO File Locks: Exclusive & Shared Lock Techniques

This tutorial explains how to use Java NIO's FileChannel to acquire exclusive and shared file locks, covering lock types, required channel modes, code examples for FileOutputStream, RandomAccessFile, and FileInputStream, and discusses platform-specific considerations and common exceptions.

Backend DevelopmentConcurrencyFile I/O

0 likes · 10 min read

Mastering Java NIO File Locks: Exclusive & Shared Lock Techniques

Xueersi Online School Tech Team

Mar 6, 2020 · Backend Development

Understanding Go's sync.Pool: Implementation, Usage Scenarios, and Evolution from Go 1.12 to 1.13

This article explains what a sync.Pool object pool is, when it should be used, details the Go 1.12 implementation with its internal structures and algorithms, describes the enhancements introduced in Go 1.13, and analyzes the resulting performance improvements for high‑concurrency backend applications.

ConcurrencyGoObject Pool

0 likes · 18 min read

Understanding Go's sync.Pool: Implementation, Usage Scenarios, and Evolution from Go 1.12 to 1.13

Programmer DD

Mar 6, 2020 · Backend Development

Mastering Java ThreadPoolExecutor Rejection Policies: When and How to Use Them

This article explains the design principles of thread pools, when Java's ThreadPoolExecutor triggers rejection policies, details the four built‑in JDK policies with code examples, and explores additional strategies from Dubbo, Netty, ActiveMQ and Pinpoint, helping developers choose the right approach for their workloads.

ConcurrencyJDKJava

0 likes · 13 min read

Mastering Java ThreadPoolExecutor Rejection Policies: When and How to Use Them

Selected Java Interview Questions

Mar 4, 2020 · Backend Development

Classification and Explanation of Java Locks for Interview Preparation

This article summarizes the main types of Java locks—including fair/unfair, reentrant, exclusive/shared, mutex/read‑write, optimistic/pessimistic, segment, biased/lightweight/heavyweight, and spin locks—provides brief definitions, usage notes, and a code example to help interview candidates answer concurrency questions effectively.

ConcurrencyJavaLocks

0 likes · 8 min read

Classification and Explanation of Java Locks for Interview Preparation

Xueersi Online School Tech Team

Feb 28, 2020 · Fundamentals

Understanding Locks and Mutex Implementation in Go

This article explains the concept of locks, why they are needed in concurrent programming, and provides an in‑depth look at Go's synchronization primitives—including CAS, atomic operations, spinlocks, semaphores, and the evolution of the sync.Mutex implementation with code examples and performance considerations.

ConcurrencyGolangLock

0 likes · 17 min read

Understanding Locks and Mutex Implementation in Go

FunTester

Feb 26, 2020 · Fundamentals

Why Thread‑Safe Collections Still Fail with Non‑Thread‑Safe Objects in Java

Through a series of Java demos, this article examines how storing non‑thread‑safe objects inside thread‑safe collections like ConcurrentHashMap or CopyOnWriteArrayList can still cause concurrency bugs, explains the underlying remove() implementation, and shows how switching to a thread‑safe Vector resolves the issue.

CollectionsConcurrencyCopyOnWriteArrayList

0 likes · 8 min read

Why Thread‑Safe Collections Still Fail with Non‑Thread‑Safe Objects in Java

Xiaokun's Architecture Exploration Notes

Feb 25, 2020 · Fundamentals

Why Thread Context Switching Slows Your Java App—and How to Fix It

This article explains how thread context switching and concurrency affect Java program performance, demonstrates the impact with code examples and benchmarks, and provides practical solutions for thread safety, visibility, deadlock avoidance, and resource optimization.

Concurrencycontext switchingthreading

0 likes · 10 min read

Why Thread Context Switching Slows Your Java App—and How to Fix It

FunTester

Feb 24, 2020 · Backend Development

Achieving Thread‑Safe Java Performance Tests Without Locks

This article explains why traditional locking harms Java performance‑testing throughput, introduces lock‑free alternatives such as CAS and ThreadLocal, and provides a complete Java demo that shows how each thread can hold its own object to eliminate contention and boost speed.

ConcurrencyJavaThreadLocal

0 likes · 5 min read

Achieving Thread‑Safe Java Performance Tests Without Locks

Programmer DD

Feb 21, 2020 · Backend Development

Mastering Thread Termination in Java: Safe Practices and Common Pitfalls

This article explains how to properly stop a Java thread, compares deprecated Thread.stop() with interruption techniques, demonstrates checking a thread's interrupted state, shows how to use exceptions and return statements for graceful termination, and warns about the dangers of forceful stops and lock release.

ConcurrencyExceptionJava

0 likes · 12 min read

Mastering Thread Termination in Java: Safe Practices and Common Pitfalls

Python Programming Learning Circle

Feb 20, 2020 · Backend Development

Understanding Backpressure in Asynchronous Systems

Backpressure, the resistance to data flow in overloaded systems, is crucial for reliable asynchronous programming; this article explains its concepts, illustrates pitfalls in Python asyncio and other languages, and presents strategies such as buffering, draining, semaphores, and protocol-level flow control to manage overload.

ConcurrencyFlow ControlPython

0 likes · 16 min read

Understanding Backpressure in Asynchronous Systems

High Availability Architecture

Feb 20, 2020 · Fundamentals

Structured Concurrency in Rust: Concepts, Scope Implementation, and Practical Examples

This article introduces the challenges of traditional concurrency, explains the structured concurrency paradigm, surveys its history and implementations across languages, and provides a detailed Rust example using the task_scope library with Scope, CancelScope, timeout handling, nested scopes, and a practical Happy Eyeballs exercise.

ConcurrencyStructured Concurrencyasynchronous programming

0 likes · 12 min read

Structured Concurrency in Rust: Concepts, Scope Implementation, and Practical Examples

Qunar Tech Salon

Feb 19, 2020 · Fundamentals

Deep Dive into Java's AbstractQueuedSynchronizer (AQS) and ReentrantLock

This article provides a comprehensive analysis of Java's AbstractQueuedSynchronizer (AQS) framework, explains how ReentrantLock is built on AQS, walks through lock acquisition and release mechanisms, discusses queue management, and demonstrates how to create a custom lock using AQS.

AQSConcurrencyJava

0 likes · 32 min read

Deep Dive into Java's AbstractQueuedSynchronizer (AQS) and ReentrantLock

FunTester

Feb 18, 2020 · Backend Development

Why Java’s volatile Can’t Replace Synchronization: Understanding Memory Consistency and Deadlocks

This article explains Java memory‑consistency problems, demonstrates how stale values arise with unsynchronized threads, shows how volatile and synchronized provide happens‑before guarantees, and illustrates common synchronization pitfalls such as reference locks and deadlocks with concrete code examples.

ConcurrencyDeadlockJava

0 likes · 7 min read

Why Java’s volatile Can’t Replace Synchronization: Understanding Memory Consistency and Deadlocks

FunTester

Feb 17, 2020 · Fundamentals

Mastering Thread‑Safe Objects in Java: From Synchronized Collections to Atomic Variables

This article explains how Java threads share objects, why immutable objects are safest, how to make mutable collections thread‑safe using synchronized wrappers or concurrent classes, handles non‑thread‑safe types like SimpleDateFormat, and demonstrates race‑condition fixes with synchronized blocks and AtomicInteger.

AtomicIntegerCollectionsConcurrency

0 likes · 10 min read

Mastering Thread‑Safe Objects in Java: From Synchronized Collections to Atomic Variables

FunTester

Feb 15, 2020 · Backend Development

Understanding Double-Checked Locking Singleton Pattern in Java

This article explains the double‑checked locking design pattern for thread‑safe singletons in Java, demonstrates its performance drawbacks, and presents alternative implementations such as early initialization, init‑on‑demand holder, and enum‑based singletons, highlighting their advantages and limitations.

ConcurrencyJavaSingleton

0 likes · 6 min read

Understanding Double-Checked Locking Singleton Pattern in Java

Java Interview Crash Guide

Feb 12, 2020 · Backend Development

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

Distributed locks ensure that, across hundreds of servers handling millions of concurrent red‑packet requests, only one instance updates the shared total at a time, preventing inconsistencies and deadlocks, with implementations ranging from Java synchronized blocks to Redis SETNX and Zookeeper Znode mechanisms.

ConcurrencyDistributed LockZookeeper

0 likes · 14 min read

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

FunTester

Feb 12, 2020 · Backend Development

How to Stress-Test a VIP Payment Callback API with Distributed Locks

This article walks through a complete performance‑testing setup for a VIP purchase callback API, detailing the request flow, distributed‑lock handling with Redis, parameter generation using AtomicInteger, Java implementation, and pitfalls to ensure accurate, high‑concurrency testing.

APIConcurrencyDistributed Lock

0 likes · 6 min read

How to Stress-Test a VIP Payment Callback API with Distributed Locks

Alibaba Cloud Native

Feb 6, 2020 · Operations

How Modern Schedulers Work: From Linux Kernels to Go Runtime and Kubernetes

This article explores the design principles, evolution, and implementation details of schedulers across operating systems, the Go programming language runtime, and Kubernetes, covering concepts such as task and resource allocation, cooperative vs. preemptive scheduling, work‑stealing, priority algorithms, and the latest scheduling framework extensions.

ConcurrencySchedulinggo runtime

0 likes · 55 min read

How Modern Schedulers Work: From Linux Kernels to Go Runtime and Kubernetes

Xiaokun's Architecture Exploration Notes

Jan 28, 2020 · Fundamentals

Why Java’s final Keyword Guarantees Thread Safety – Deep Dive

This article explains the semantics of Java's final keyword, how the compiler and JVM enforce immutability and memory‑barrier rules, and why final fields provide thread‑safe, write‑once‑read‑many behavior for both instance and static variables.

ConcurrencyJavafinal

0 likes · 13 min read

Why Java’s final Keyword Guarantees Thread Safety – Deep Dive

FunTester

Jan 26, 2020 · Backend Development

Common Concurrency Bugs in Backend Java Development and Their Solutions

Although developers often overlook high‑concurrency scenarios, this article highlights two typical backend Java concurrency bugs—shared request state in singleton beans and improper lazy initialization—explains their pitfalls, and demonstrates correct thread‑safe patterns such as double‑checked locking and proper singleton design.

ConcurrencyJavaLazy Initialization

0 likes · 5 min read

Common Concurrency Bugs in Backend Java Development and Their Solutions

Xiaokun's Architecture Exploration Notes

Jan 24, 2020 · Fundamentals

Understanding Java volatile: Memory Semantics, Barriers, and Practical Examples

This article explains the purpose, usage scenarios, and memory semantics of Java's volatile keyword, demonstrates its behavior with code examples and memory barrier concepts, and summarizes how volatile ensures visibility and ordering across threads.

ConcurrencyJavamemory barrier

0 likes · 9 min read

Understanding Java volatile: Memory Semantics, Barriers, and Practical Examples

Xiaokun's Architecture Exploration Notes

Jan 22, 2020 · Fundamentals

How volatile Impacts Java Threads: Experiments, JVM Modes, and Atomicity

This article demonstrates how the volatile keyword influences thread communication in Java, compares client and server JVM modes, analyzes resulting memory visibility and reordering effects, and explores atomicity limits with bytecode examples and practical recommendations.

AtomicityConcurrencyJVM

0 likes · 8 min read

How volatile Impacts Java Threads: Experiments, JVM Modes, and Atomicity

Senior Brother's Insights

Jan 16, 2020 · Backend Development

150+ Essential Java Interview Questions: Collections, JVM, Concurrency, Spring & More

This article compiles over 150 Java interview questions covering collections, JVM tuning, concurrency, Spring framework, design patterns, Spring Boot, Netty, and Redis, providing a comprehensive study guide to help candidates prepare for upcoming interview seasons.

Backend DevelopmentConcurrencyInterview Questions

0 likes · 16 min read

150+ Essential Java Interview Questions: Collections, JVM, Concurrency, Spring & More

Alibaba Terminal Technology

Jan 16, 2020 · Backend Development

How FIBJS Refactors Async and ORM for Faster Backend Performance

This article examines FIBJS's transition from callback‑based asynchronous code to coroutine‑based sync style, compares its ORM refactor and worker‑thread handling with NodeJS, and presents performance metrics that show memory and throughput improvements across various workloads.

ConcurrencyFIBJSNodeJS Comparison

0 likes · 11 min read

How FIBJS Refactors Async and ORM for Faster Backend Performance

JD Retail Technology

Jan 13, 2020 · Backend Development

Understanding Netty Futures and Building a Simple Callback-Based Asynchronous Task Framework

This article explains the limitations of Java's Future, demonstrates Netty's non‑blocking Future with listeners, and walks through building a simple Java callback‑based asynchronous task framework—including timeout handling—using Netty, CompletableFuture, and custom Worker/Listener abstractions.

CallbackConcurrencyFuture

0 likes · 13 min read

Understanding Netty Futures and Building a Simple Callback-Based Asynchronous Task Framework

AI Code to Success

Jan 11, 2020 · Mobile Development

Why Does Creating a Handler in a Background Thread Throw an Exception?

This article explains Android's Handler and Looper mechanism, shows why creating a Handler in a non‑Looper thread triggers a RuntimeException, and walks through the relevant source code—including Handler constructors, Looper.myLooper(), ThreadLocal operations, and the required Looper.prepare() call.

ANRAndroidConcurrency

0 likes · 10 min read

Why Does Creating a Handler in a Background Thread Throw an Exception?

Xiaokun's Architecture Exploration Notes

Jan 11, 2020 · Fundamentals

Why Java’s synchronized Guarantees Strong Memory Consistency

This article explains how Java’s synchronized keyword relies on JVM monitorenter/monitorexit instructions to enforce strong memory consistency, compares execution results with and without synchronization, and details the underlying memory semantics, benefits, and performance drawbacks.

Concurrencymemory-modelsynchronized

0 likes · 9 min read

Why Java’s synchronized Guarantees Strong Memory Consistency

Xiaokun's Architecture Exploration Notes

Jan 7, 2020 · Fundamentals

How Does Java’s synchronized Keyword Work Under the Hood?

This article explains the inner workings of Java's synchronized methods and blocks, detailing the JVM method_info structure, relevant access flags, bytecode generation, monitorenter/monitorexit instructions, and the rules that ensure structured locking even during exceptions.

ConcurrencyJVMJava

0 likes · 9 min read

How Does Java’s synchronized Keyword Work Under the Hood?

JavaEdge

Jan 6, 2020 · Fundamentals

Understanding Java CAS: How Compare‑And‑Swap Powers Lock‑Free Concurrency

This article explains the Compare‑And‑Swap (CAS) primitive, its three operands, how Java's Unsafe class implements CAS methods, the internal workings of AtomicInteger, common pitfalls like spinning, single‑variable limits and the ABA problem, and the enhancements introduced in Java 8.

AtomicIntegerCASConcurrency

0 likes · 9 min read

Understanding Java CAS: How Compare‑And‑Swap Powers Lock‑Free Concurrency

Selected Java Interview Questions

Jan 6, 2020 · Backend Development

Understanding Java ThreadPoolExecutor: Creation, Execution Flow, and Core Parameters

This article explains why multithreading and thread pools are essential for server‑side Java development, details the full ThreadPoolExecutor constructor parameters, and walks through the executor, addWorker, Worker, runWorker, and getTask implementations with illustrative diagrams.

ConcurrencyJavaThreadPoolExecutor

0 likes · 6 min read

Understanding Java ThreadPoolExecutor: Creation, Execution Flow, and Core Parameters

JavaEdge

Jan 4, 2020 · Backend Development

Mastering Java’s Unsafe park/unpark and AQS: Build Custom Locks with LockSupport

This article explains how Java’s Unsafe class provides low‑level park and unpark methods, how the LockSupport utility wraps them for easier use, and demonstrates building a simple exclusive lock with AbstractQueuedSynchronizer, covering state handling, blocking mechanisms, and thread‑queue management.

AQSConcurrencyCustomLock

0 likes · 7 min read

Mastering Java’s Unsafe park/unpark and AQS: Build Custom Locks with LockSupport

Test Development Learning Exchange

Dec 31, 2019 · Fundamentals

Multithreading Concepts: Locks, Deadlock, Recursive Locks, and Daemon Threads

This article explains multithreading fundamentals, covering thread concepts, lock mechanisms for database access, deadlock causes and solutions, recursive locks (RLock), data race issues, and daemon thread behavior. It also discusses connection pooling, timeout strategies to avoid deadlock, and practical code examples in Python.

ConcurrencyConnection PoolingDaemon Thread

0 likes · 6 min read

Multithreading Concepts: Locks, Deadlock, Recursive Locks, and Daemon Threads

Programmer DD

Dec 28, 2019 · Backend Development

Unlock Hidden Java Thread Features: Names, Priorities, ThreadLocal, Daemons & CPU Affinity

This article explores five advanced Java thread techniques—custom thread names, priority management, ThreadLocal storage, user versus daemon threads, and processor affinity—showing how to apply them for better debugging, performance tuning, and reliable concurrent applications.

CPU affinityConcurrencyJava

0 likes · 12 min read

Unlock Hidden Java Thread Features: Names, Priorities, ThreadLocal, Daemons & CPU Affinity

Big Data Technology & Architecture

Dec 26, 2019 · Fundamentals

Java Thread Interview Questions and Answers with Code Examples

This article provides a comprehensive guide to common Java multithreading interview questions, covering thread ordering with join, lock vs synchronized, read‑write locks, wait vs sleep, blocking queues, producer‑consumer patterns, deadlock detection, thread dumps, thread states, and immutable objects, all illustrated with runnable code samples.

BlockingQueueConcurrencyDeadlock

0 likes · 33 min read

Java Thread Interview Questions and Answers with Code Examples

FunTester

Dec 26, 2019 · Backend Development

Deep‑Copying HttpRequestBase in Java: A Custom FunRequest Wrapper

This article explains why a separate HttpRequestBase object is needed for each concurrent request in a performance testing framework, and provides a complete Java implementation of a FunRequest class that offers deep‑copy, cloning, and fluent configuration of GET/POST HTTP requests.

ConcurrencyHttpClientJava

0 likes · 8 min read

Deep‑Copying HttpRequestBase in Java: A Custom FunRequest Wrapper

Alibaba Cloud Native

Dec 25, 2019 · Backend Development

Master Go Panic/Recover, Thread Limits, and Error Handling – A Practical Guide

This article explores Go's panic/recover mechanism, identifies which runtime errors can be recovered, explains unrecoverable scenarios like thread exhaustion and map race, demonstrates best‑practice error handling with Go 1.13 features and popular error libraries, and offers concrete logging strategies for robust server development.

ConcurrencyError handlingGOMAXPROCS

0 likes · 34 min read

Master Go Panic/Recover, Thread Limits, and Error Handling – A Practical Guide

Alibaba Cloud Developer

Dec 23, 2019 · Backend Development

Boost Python I/O Performance: Mastering Coroutines and Async/Await

This article explains Python coroutine fundamentals, async/await syntax, and demonstrates how to use aiohttp with an event loop and semaphore to dramatically speed up I/O‑bound network requests, providing practical code and performance results.

Async/AwaitConcurrencyPython

0 likes · 13 min read

Boost Python I/O Performance: Mastering Coroutines and Async/Await

Python Programming Learning Circle

Dec 18, 2019 · Fundamentals

Why Python Threads Lag Behind Single Threading and How Locks Fix It

This article explains why Python's OS‑level threads can be slower for CPU‑bound tasks due to the Global Interpreter Lock, describes race conditions caused by reference counting, and shows how using threading locks (including context‑manager syntax) ensures correct concurrent execution.

ConcurrencyGILLock

0 likes · 6 min read

Why Python Threads Lag Behind Single Threading and How Locks Fix It

Senior Brother's Insights

Dec 16, 2019 · Backend Development

Mastering Java Thread Pools: Creation, Configuration, and Best Practices

This comprehensive guide explains Java thread pool fundamentals, creation methods, core parameters, rejection policies, execution flow, common work queues, and shutdown techniques, while providing interview questions, source‑code analysis, and practical code examples for robust concurrent programming.

ConcurrencyExecutorServiceJava

0 likes · 20 min read

Mastering Java Thread Pools: Creation, Configuration, and Best Practices

Selected Java Interview Questions

Dec 16, 2019 · Backend Development

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

This article explains the various ways to terminate a running Java thread—including using exit flags, the deprecated stop() method, interrupt(), and exception handling—illustrates each approach with code samples, compares Thread.interrupted() and isInterrupted(), and discusses the dangers of forceful termination and lock release.

ConcurrencyJavaStop

0 likes · 12 min read

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

Programmer DD

Dec 15, 2019 · Backend Development

Java ThreadLocal Deep Dive: Structure, 0x61c88647 Hash Trick & Usage

This article explains the internal architecture of Java's ThreadLocal, including its ThreadLocalMap implementation, the purpose of the special hash code 0x61c88647, collision handling strategies, proper usage patterns in web applications, and precautions for avoiding memory leaks in thread pools.

ConcurrencyHashingJava

0 likes · 12 min read

Java ThreadLocal Deep Dive: Structure, 0x61c88647 Hash Trick & Usage