Tagged articles
Executor
43 articles · Page 1 of 1
This guide explains the default Java ThreadPoolExecutor workflow, identifies why interview questions may require launching maximum threads before queuing tasks, and presents a concise two‑pool plus custom rejection‑policy solution that satisfies the requirement without writing a custom thread pool from scratch.
ExecutorInterviewJava
0 likes · 5 min read

When the core pool size of a Java ThreadPoolExecutor is configured to zero, new tasks are initially placed into the work queue, and the executor may create non‑core threads to process them, a behavior that often surprises interview candidates.
ExecutorJava
0 likes · 5 min read

This article walks through the complete lifecycle of a MySQL SELECT statement, detailing how the client, connector, optional query cache, parser, optimizer, and executor interact to transform SQL text into an execution plan and finally return results.
Database InternalsExecutorMySQL
0 likes · 13 min read

This comprehensive guide explores Java thread pools, detailing their advantages, design concepts, core classes, constructors, task queues, rejection policies, lifecycle states, initialization, dynamic resizing, shutdown procedures, and the internal workings of ThreadPoolExecutor, Worker, and related methods with clear examples and diagrams.
ExecutorMultithreadingThreadPool
0 likes · 34 min read

This article explains the purpose, advantages, design principles, configuration parameters, task queue options, rejection policies, lifecycle management, and internal execution flow of Java's ThreadPoolExecutor, providing code examples and detailed insights into how thread pools work in concurrent applications.
ConcurrencyExecutorJava
0 likes · 30 min read

This article provides a comprehensive overview of Java's ThreadPoolExecutor, explaining its motivation, advantages, design concepts, constructors, task queues, rejection policies, thread management methods, and detailed source code analysis, helping developers master thread pool usage and implementation.
ConcurrencyExecutorJava
0 likes · 32 min read

This article introduces nine different approaches to achieve asynchronous programming in Java, including using Thread and Runnable, Executors thread pools, custom thread pools, Future and Callable, CompletableFuture, ForkJoinPool, Spring @Async, message queues, and Hutool's ThreadUtil, with code examples and usage tips.
CompletableFutureExecutorJava
0 likes · 15 min read

The article outlines nine practical approaches for asynchronous programming in Java—including low‑level Thread/Runnable, managed Executors and custom thread pools, Future/Callable, CompletableFuture, ForkJoinPool, Spring’s @Async annotation, message‑queue integration, and the Hutool ThreadUtil utility—offering a comprehensive toolbox for scalable, non‑blocking execution.
CompletableFutureExecutorJava
0 likes · 13 min read

This article provides a comprehensive, English-language walkthrough of MyBatis's four core components—Executor, StatementHandler, ParameterHandler, and ResultSetHandler—explaining their interfaces, default implementations, key methods, and how they collaborate to translate Java objects into SQL statements and process query results.
ExecutorJavaMyBatis
0 likes · 21 min read

This article explains the step‑by‑step decision process a Java thread pool follows when execute() adds a task, covering core and maximum pool sizes, queue handling, thread creation, rejection policies, and idle thread termination.
ConcurrencyExecutorJava
0 likes · 3 min read

On October 27, 2023, a sudden surge in request volume and downstream latency caused the bfe‑customer‑application‑query‑svc to exhaust its Tomcat thread pool, triggering health‑check failures and pod restarts; a deep dive revealed that an ill‑designed custom executor and unchecked thread‑waiting calls created a bottleneck that amplified the outage.
ExecutorIncidentAnalysisJava
0 likes · 36 min read

This article walks through how MySQL processes a SELECT query, detailing the server and storage engine layers, the roles of the connector, query cache, parser, optimizer, and executor, and provides practical command‑line examples to illustrate each step.
ConnectorDatabase ArchitectureExecutor
0 likes · 11 min read

The article walks through MyBatis’s internal execution pipeline, from loading the configuration file and building a SqlSessionFactory, to creating a SqlSession, generating a MapperProxy for the mapper interface, and finally invoking the mapped method which triggers JDBC operations, while detailing caching and executor mechanisms.
CachingDynamicProxyExecutor
0 likes · 31 min read

This guide explains the five ThreadPoolExecutor rejection policies in Java—AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy, and custom handlers—detailing their behavior, use‑cases, and providing concrete code examples for each.
ExecutorJavaMultithreading
0 likes · 6 min read


政采云技术Sep 13, 2023 · Backend Development
This article explains the concept of threads in Java, how to create them, the purpose and benefits of thread pools, the inheritance hierarchy of Java's Executor framework, key parameters of ThreadPoolExecutor, rejection policies, pool states, and the underlying working mechanism, supplemented with code examples.
ConcurrencyExecutorJava
0 likes · 15 min read

This article explains how MyBatis delegates SQL execution to four core objects—Executor, StatementHandler, ParameterHandler, and ResultSetHandler—detailing their architecture, implementations such as SimpleExecutor, ReuseExecutor, BatchExecutor, and demonstrating three common batch insertion techniques with code examples.
Batch OperationsExecutorJava
0 likes · 13 min read

In high‑concurrency Java scenarios, using a thread pool instead of creating raw Thread objects dramatically reduces resource consumption, prevents CPU overload and memory leaks, and offers reusable threads, controlled concurrency, task scheduling, and configurable rejection policies, all managed by the core ThreadPoolExecutor class.
Executorperformancethread pool
0 likes · 13 min read

Apache Airflow is an open‑source platform for programmatically authoring, scheduling, and monitoring workflows using Directed Acyclic Graphs (DAGs), featuring components such as Scheduler, Web Server, Database, and various Executors, and offering easy‑to‑use, extensible, scalable, and robust integrations for data pipeline management.
Apache AirflowDAGExecutor
0 likes · 10 min read

This article provides a thorough introduction to MyBatis, including a complete beginner example with database schema, Maven configuration, XML and Java mapper files, and a demo program, followed by an in‑depth explanation of MyBatis’s lifecycle, core components such as SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and their interactions.
ExecutorJavaMyBatis
0 likes · 27 min read

The article presents a step‑by‑step MyBatis tutorial that creates a sample user table, adds Maven dependencies, configures MyBatis, defines mapper XML and Java interfaces, demonstrates a test program, and explains core components such as SqlSession, Executor, StatementHandler, ParameterHandler, and ResultSetHandler.
ExecutorJavaMyBatis
0 likes · 28 min read

This article explains how to design and implement a DAG‑based task orchestration framework in Java, covering graph representations, dependency management, executor integration, state tracking, and how to persist workflows and tasks in a relational database for platform‑level usage.
DAGExecutorJava
0 likes · 11 min read


JavaEdgeMay 16, 2021 · Backend Development
This article explains the purpose and design of Java thread pools, illustrates common pitfalls such as unbounded queues causing OutOfMemoryError, and provides practical guidelines for configuring bounded queues, naming threads, handling exceptions, choosing rejection policies, and using separate pools for compute‑intensive tasks.
Best PracticesExecutorJava
0 likes · 12 min read

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.
ConcurrencyExecutorJava
0 likes · 10 min read

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.
ConcurrencyExecutorJava
0 likes · 59 min read

This article explains how Java's ThreadPoolExecutor manages threads and tasks by describing corePoolSize, workQueue behavior, maximumPoolSize, rejection policies, and keepAliveTime, highlighting the costs of thread creation and the importance of bounded queues to avoid OOM.
BackendExecutorJava
0 likes · 8 min read

This article explains how Java's ThreadPoolExecutor manages threads and tasks, covering the costs of thread creation, the roles of corePoolSize, workQueue, maximumPoolSize, rejection policies, keep‑alive time, and best practices for using bounded queues to avoid OOM.
ConcurrencyExecutorJava
0 likes · 8 min read

This article thoroughly examines the MyBatis selectList() execution process—including environment setup, mapper definitions, caching executors, parameter handling, statement preparation, and result set processing—by stepping through source code and debugging traces within a Spring Boot 2.3.3 context.
CachingExecutorJava
0 likes · 7 min read

This article introduces MyBatis's underlying architecture by explaining the six core interfaces—SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and TypeHandler—detailing their roles, key methods, caching mechanisms, and how they are instantiated within a Spring Boot environment.
ExecutorJavaMyBatis
0 likes · 13 min read

This article explains Spark's transition from static to unified memory management, detailing on‑heap and off‑heap memory regions, key configuration parameters, dynamic allocation behavior, and legacy mode, helping users optimize executor memory usage for both batch and streaming workloads.
ExecutorSparkmemory management
0 likes · 7 min read

This article explains the purpose, default values, and practical tuning recommendations for common Spark submit options such as executor counts, memory settings, shuffle behavior, speculation, and various Spark SQL configurations to help users optimize big‑data workloads.
ConfigurationExecutorPerformance Tuning
0 likes · 14 min read

This article analyzes Apache Spark's executor-side memory management model, focusing on the UnifiedMemoryManager in Spark 2.2.1, detailing on‑heap and off‑heap memory regions, dynamic execution/storage memory sharing, task memory allocation, and practical configuration examples.
ExecutorOff‑HeapSpark
0 likes · 10 min read

This article provides a comprehensive overview of Spark's memory management, covering executor memory architecture, the differences between on‑heap and off‑heap memory, static versus unified memory managers, storage and execution memory handling, and practical guidelines for optimizing Spark applications.
ExecutorOff‑heapSpark
0 likes · 21 min read

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

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

The article explains Spark’s executor memory layout under the UnifiedMemoryManager, detailing on‑heap and off‑heap divisions, the four memory regions, default fraction settings, how storage and execution memory share space, and provides heuristics and tuning tips for avoiding OOM and optimizing performance.
ExecutorPerformance TuningSpark
0 likes · 24 min read

Learn how to enable Spring's @Async support, configure custom executors, use @Async with void and Future return types, and implement custom exception handling for uncaught async errors, providing a complete guide to asynchronous method execution in Spring applications.
ExceptionHandlingExecutorSpring
0 likes · 4 min read

This article explains Apache Spark's memory architecture, covering the shift from static to unified memory management, the roles of on‑heap and off‑heap memory, configurable parameters, dynamic memory sharing between execution and storage, and the legacy mode introduced in Spark 1.6.
Apache SparkExecutorOff‑Heap
0 likes · 7 min read

The article explains MySQL 8.0’s new iterator‑based executor, detailing the underlying iterator model, its advantages over the legacy executor, the specific RowIterator classes introduced, supported query features, and future enhancements for more advanced algebraic operations.
C++ExecutorMySQL
0 likes · 12 min read

This article walks through MyBatis' internal workflow—from parsing the global XML configuration and building the SqlSessionFactory, to creating a SqlSession, executing a query via the Executor, handling caching, and finally mapping results—illustrated with key code snippets and a diagram.
ExecutorJavaMyBatis
0 likes · 16 min read

This article explains Spark's executor memory architecture, covering on‑heap and off‑heap memory planning, static and unified memory managers, storage and execution memory allocation, RDD persistence, eviction policies, and shuffle memory usage, providing practical guidance for performance tuning.
ExecutorOff‑HeapSpark
0 likes · 23 min read

This article explains Spark's executor memory architecture, covering on‑heap and off‑heap allocation, static versus unified memory managers, storage and execution memory handling, RDD persistence levels, eviction policies, and shuffle memory usage, providing practical formulas and configuration tips for optimal performance.
ExecutorOff‑HeapSpark
0 likes · 23 min read

This article examines Spark's unified memory manager in version 2.2.1, detailing on‑heap and off‑heap memory regions, the four on‑heap memory pools, dynamic execution‑storage memory sharing, task memory accounting, and provides concrete calculation examples to explain UI discrepancies and runtime memory limits.
ExecutorOff‑HeapPerformance Tuning
0 likes · 13 min read


ITPUBApr 11, 2017 · Big Data
This article explains Spark's executor memory architecture, covering on‑heap and off‑heap allocation, static versus unified memory managers, storage and execution memory handling, RDD persistence, eviction policies, and the role of Tungsten's page‑based management in optimizing performance.
ExecutorOff‑HeapOn‑Heap
0 likes · 23 min read
