Tagged articles
Startup Optimization
47 articles · Page 1 of 1
This guide explains how to use Windows Task Manager to diagnose system freezes, identify resource-hogging processes, end unresponsive programs, monitor CPU/memory/disk usage, manage startup items, and leverage advanced tabs like Details and Services, with practical tips and exam-focused insights.
Performance TroubleshootingProcess ManagementResource Monitor
0 likes · 8 min read

This article walks through seven concrete Spring Boot startup optimizations—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration slimming, class‑loading reduction, delayed database connections, and AOT/native compilation—showing real‑world benchmarks that cut launch times by around 70%.
AOTAuto-configurationJVM tuning
0 likes · 9 min read

The article explains that Spring's @Lazy annotation has two distinct mechanisms—class‑level lazy bean creation and dependency‑level proxy placeholders—detailing how each works, when to apply them, common pitfalls such as transaction and aspect failures, and best‑practice scenarios for reducing startup time while safely handling circular dependencies.
@LazyBean ProxyCircular Dependency
0 likes · 12 min read

The article dissects Claude Code's sub‑second startup by explaining how a beta header enables Fast Mode, how parallel prefetch of MDM configuration and macOS Keychain is orchestrated with Promise.all in a preAction hook, and how multi‑layer gating and a cooldown mechanism ensure safe, recoverable performance gains.
CLICooldownFast mode
0 likes · 16 min read


java1234Jan 27, 2026 · Backend Development
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
Auto-configurationClass LoadingDatabase Connection
0 likes · 9 min read

This article answers ten Spring Boot interview questions, covering why @Configuration classes are CGLIB‑proxied, common startup‑time bottlenecks and diagnostics, graceful shutdown mechanics, execution timing of ApplicationContextInitializer vs ApplicationRunner, circular‑dependency handling, health‑endpoint aggregation, distributed‑transaction strategies, Kubernetes probes, JSON serialization safeguards, and migration challenges to Jakarta EE 9+.
CGLIBJSON SerializationSpring Boot
0 likes · 15 min read

This article presents a step‑by‑step guide that combines lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration exclusion, class‑loading analysis, delayed datasource creation, and AOT/layered compilation to reduce Spring Boot startup latency by up to 70% in real‑world services.
AOT CompilationJVM tuningSpring Boot
0 likes · 10 min read

This article walks through seven practical Spring Boot startup‑time optimizations—lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, class‑loading reduction, lazy database connections, and AOT/layered compilation—backed by real‑world case studies and measurable performance gains.
AOTAuto-configurationJVM
0 likes · 10 min read

This article explains why Java applications often start slowly, identifies the main culprits such as excessive class loading, bloated JARs, and reflection, and provides a comprehensive set of JVM, Spring Boot, code‑level, and deployment optimizations—including lazy loading, auto‑configuration pruning, GraalVM native images, and container probes—to dramatically reduce startup time and ace interview questions.
JVMJavaPerformance Tuning
0 likes · 13 min read

This article explores comprehensive strategies for dramatically reducing Spring Boot application startup latency, covering real‑world case studies, dependency slimming, JVM and CDS tuning, lazy and asynchronous bean initialization, GraalVM native image compilation, and advanced runtime techniques such as CRaC, with detailed metrics and step‑by‑step guidance.
Bean InitializationCDSCRaC
0 likes · 35 min read

This article presents ten practical techniques—including lazy loading, lazy database initialization, selective auto‑configuration, log level tuning, JVM flags, dependency trimming, bean optimization, JIT tweaks, classpath scanning reduction, and DevTools restart—to dramatically reduce Spring Boot application startup time.
JavaSpring BootStartup Optimization
0 likes · 6 min read

This article explains nine practical techniques—including narrowing component scans, enabling lazy initialization, excluding unused auto‑configurations, using a component indexer, tuning the database pool, avoiding heavy bean init tasks, leveraging CDS, running exploded jars, and employing GraalVM native images—to dramatically reduce Spring Boot 3 application startup time.
JavaPerformance TuningSpring Boot
0 likes · 11 min read

Learn seven practical strategies—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, dependency slimming, delayed datasource connections, and AOT/layered compilation—to dramatically reduce Spring Boot application startup time, memory usage, and class loading, with real‑world performance comparisons.
AOT CompilationAuto-configurationJVM tuning
0 likes · 9 min read

This article shares ten practical techniques—including lazy bean loading, removing unused auto‑configurations, classloader tweaks, thread‑pool tuning, logging reduction, health‑check disabling, SSD upgrades, Maven packaging fixes, and Arthas monitoring—that together can reduce Spring Boot startup from minutes to seconds, dramatically boosting developer productivity.
Performance TuningSpring BootStartup Optimization
0 likes · 7 min read

This article systematically analyzes a Spring Boot project's 280‑second startup, identifies bottlenecks such as bean initialization and sharding data source loading, and applies listener‑based timing, bean‑post‑processor profiling, and asynchronous initialization to reduce launch time to 159 seconds, improving developer efficiency.
BackendJavaSharding
0 likes · 13 min read

This article explains how Azul's CRaC and ReadyNow technologies differ in approach to accelerating Java application startup, detailing the Java launch process, optimization phases, implementation requirements, and a side‑by‑side comparison of their benefits and trade‑offs.
CRaCJVMJava
0 likes · 12 min read

The DeWu Tech article dissects iOS’s dyld BuildingClosure stage, shows how hash‑collision‑laden selector strings inflate its runtime, and demonstrates that renaming the colliding selectors reduces perfect‑hash iterations, cutting the phase’s duration by roughly 80% and noticeably speeding up app startup.
Startup OptimizationdyldiOS
0 likes · 11 min read

This article provides a comprehensive guide to speeding up Spring Boot application startup by explaining configuration principles, code‑level interventions, lazy loading, dependency reduction, auto‑configuration exclusion, logging adjustments, compile‑time optimizations, and caching strategies, all illustrated with practical Java examples.
JavaPerformance TuningSpring Boot
0 likes · 30 min read

This article explains the CRaC (Coordinated Restore at Checkpoint) technology for Java applications, describing its principles, supported environments, practical steps for enabling it with Spring Boot, and use‑case scenarios that dramatically reduce JVM startup time.
CRaCJVMJava
0 likes · 9 min read

This article walks through a systematic investigation of a slow‑starting Dubbo service built on Spring 3.2, using JProfile to pinpoint costly class‑loading checks, disabling unnecessary annotation processing, and resolving thread‑waiting issues caused by RabbitMQ and other components, ultimately reducing deployment time by about 40%.
DubboJProfileJava
0 likes · 7 min read

This article explains why a pre‑ads loading step is required for Android apps, analyzes the limitations of the current linear startup flow, and details several technical solutions—including system‑API checks, exclusion rules, handler hooking, and initialization reversal—to reliably detect icon‑click launches and reduce startup latency.
Ad PreloadingAndroidHandler Hook
0 likes · 9 min read

This article explains the principles of Spring Boot startup configuration, demonstrates how to intervene using ApplicationContextInitializer, SpringApplicationRunListener, ApplicationRunner, and CommandLineRunner, and provides practical optimization tips such as reducing dependencies, adjusting auto‑configuration, enabling lazy loading, compile‑time optimizations, log level tuning, and caching to speed up application startup.
BackendStartup Optimizationspring-boot
0 likes · 35 min read

This article examines the causes of slow startup in large Spring applications, presents visual analysis techniques and a toolbox—including Arthas, JVM Sandbox, Async Profiler, and Spring Startup Analyzer—and provides concrete installation, configuration, and optimization procedures that can reduce startup time by 70‑80% while improving development efficiency and resource utilization.
BackendJar SlimmingJava
0 likes · 14 min read


JD TechDec 28, 2023 · Backend Development
This article explores the challenges of slow Spring application startup in large Java projects, presents detailed analysis techniques, visualizations, and a suite of tools—including Spring Startup Analyzer, Arthas, and Async Profiler—to identify bottlenecks, and provides step‑by‑step optimization methods such as bean lazy loading, jar slimming, and configuration tweaks that can reduce startup time by up to 80% while improving resource utilization and deployment efficiency.
SpringStartup Optimizationlazy loading
0 likes · 16 min read

Learn how to dramatically reduce startup time in large Spring applications by using spring-context-indexer to generate component indexes at compile time, configure Maven or Gradle dependencies, create manual or IDE‑generated index files, support custom annotations, and disable indexing when needed.
JavaSpringStartup Optimization
0 likes · 6 min read

This article presents a comprehensive set of techniques—including lazy initialization, deferred database connections, selective auto‑configuration, logging level tuning, JVM parameter tweaks, dependency pruning, bean optimization, JIT settings, class‑path scanning reduction, and DevTools restart—to significantly shorten Spring Boot application startup time, each illustrated with clear code examples.
JavaStartup Optimizationperformance
0 likes · 7 min read


政采云技术Nov 7, 2023 · Databases
This article investigates why Sharding-JDBC takes over half of the application startup time to load metadata, explains the role of the max.connections.size.per.query setting, demonstrates how adjusting it speeds up startup, and discusses the trade‑offs and potential dead‑lock risks of increasing the value.
Database ConfigurationPerformance TuningSharding-JDBC
0 likes · 7 min read

Spring Startup Analyzer is an open-source tool that captures Spring Boot startup data, generates interactive reports, and offers async bean initialization to speed up launches, with detailed statistics, bean timelines, method call metrics, unused JAR detection, and flame-graph visualizations, plus step-by-step usage instructions.
JavaPerformance AnalysisSpring Boot
0 likes · 9 min read

iQIYI’s mobile app reduces video startup latency by preloading data, pre‑decoding frames, pre‑creating player instances, streamlining initialization, optimizing DNS and CDN selection, and employing device‑aware decoding strategies, achieving near‑zero launch times and superior user experience while planning further audio‑track and hardware collaborations.
AndroidMobile StreamingStartup Optimization
0 likes · 8 min read

This article details a ten‑month iOS startup optimization project for the Sohu Video app, describing measurement methods, ten technical improvements—including dynamic‑to‑static library conversion, load‑method refactoring, binary reordering, and double‑root view architecture—that together reduced launch time by roughly 46% and provides practical code snippets and performance data.
Startup OptimizationStatic LibrariesiOS
0 likes · 16 min read


政采云技术Oct 25, 2022 · Backend Development
This article explains how to analyze and accelerate SpringBoot startup by profiling with tools like Async Profiler, refactoring heavy business code, leveraging BeanPostProcessor for bean initialization metrics, using Spring's context indexer, and applying lazy initialization to reduce launch time in large Java backend services.
BeanPostProcessorSpringBootStartup Optimization
0 likes · 11 min read


58 TechSep 27, 2022 · Mobile Development
This article details the systematic analysis and optimization of the 58.com Android app’s startup process, covering profiling, componentized task framework, delayed initialization, merging launch and home activities, layout improvements, monitoring tools, and results that achieved roughly a 50% reduction in cold‑start time.
AndroidComponentizationDelay Initialization
0 likes · 20 min read

This article details a five‑month performance project that reduced the heart‑beat app’s average launch time from over eight seconds to around four seconds by dissecting cold‑start phases, optimizing Application initialization, streamlining the launch chain, and applying home‑page, lock, and monitoring strategies.
AndroidApp LaunchStartup Optimization
0 likes · 30 min read

By analyzing thread preemption on low‑end iPhones, this article demonstrates how selecting appropriate GCD queue QoS levels—favoring Utility or Background over User‑Initiated—reduces main‑thread contention, improves launch screen rendering by ~100 ms, and accelerates message list first‑load by up to 1.5 s without altering business logic.
ConcurrencyGCDQoS
0 likes · 10 min read

Baidu’s comprehensive low‑end device startup optimization—using a scoring‑based observation system, TTI metrics, automated degradation prevention, high‑performance tools such as UniKV and ABTest lock fixes, and an intelligent scheduling framework—cut cold‑start TTI by over 40% on Android and 30%‑plus on iOS.
Android optimizationStartup OptimizationTask Scheduling
0 likes · 19 min read

This article details the Watermelon iOS app's comprehensive startup optimization, covering launch phase definitions, metric design, task scheduling, code instrumentation, thread management, rendering and network improvements, as well as monitoring and anti‑regression measures to consistently reduce launch latency.
Startup OptimizationTask SchedulingiOS
0 likes · 24 min read

This article walks through practical iOS startup optimization, covering monitoring strategies, non‑intrusive instrumentation, development‑stage testing, essential tools like Time Profiler and System Trace, and a comprehensive set of best‑practice tactics to shrink launch time and maintain performance.
Performance MonitoringStartup OptimizationiOS
0 likes · 28 min read

This article details Beike's iOS app startup optimization workflow, covering online startup speed measurement, offline performance analysis with a custom profiler, and governance practices such as +load method control, code stripping, and binary reordering to improve launch time and user experience.
BKTimeProfilerBinary ReorderingPerformance Analysis
0 likes · 16 min read

This article explains the principles of virtual memory and paging, demonstrates how page faults affect iOS app launch time, and provides a step‑by‑step guide to using clang static instrumentation and Xcode order files to reorder binary symbols, reduce page faults, and achieve measurable startup speed improvements.
Binary ReorderingStartup Optimizationclang instrumentation
0 likes · 26 min read

This article details JD Finance's Android mobile app startup speed optimization project, covering background, launch type analysis, measurement tools, and a series of practical improvements such as theme switching, application code reduction, thread management, network tweaks, and activity refinements that together cut launch time by up to 45%.
AndroidJD FinanceStartup Optimization
0 likes · 15 min read

In a mobile‑first world where limited device resources and unstable networks threaten user retention, Kuaishou’s performance team built an APM monitoring platform and applied systematic memory, startup, and jank optimizations that cut startup time by 40%, reduced package size by 23 MB, and significantly improved key product metrics.
APMKuaishouMobile App
0 likes · 9 min read

This article describes how Alibaba's HandCat team analyzed the growing startup latency of their Android app, identified static initialization bottlenecks, and implemented a data‑driven, per‑user and per‑device task orchestration using AOP instrumentation and algorithmic scheduling, achieving up to 1.6 s faster launches on low‑end devices.
AOP instrumentationPersonalizationStartup Optimization
0 likes · 15 min read

By forming a dedicated team and creating the Lens SDK with a TaskManager framework that breaks startup work into independent, concurrent, and condition‑driven tasks—while delaying non‑critical work, adding fallback handling, and continuously monitoring performance—iQIYI cut its Android app launch time from roughly 1.5 seconds to under 0.5 seconds.
AndroidStartup Optimizationmobile development
0 likes · 8 min read

This guide explains how Linux distributions start many default services, how to use Systemd tools to view and analyze boot processes, and provides step‑by‑step instructions for safely disabling or masking unneeded services to improve startup performance.
Startup Optimizationdisable serviceslinux boot
0 likes · 6 min read

The article details iQIYI’s systematic approach to Android app startup optimization—analyzing cold‑start processes, measuring latency with SysTrace and adb, applying process‑aware initialization, async work off the UI thread, layout simplifications, delayed services, and automated tracing—to achieve up to 40 % launch‑time reduction and establish continuous monitoring.
ADBAndroidMultithreading
0 likes · 15 min read

The article explains why an Android app may start several processes, causing Application.onCreate() to execute multiple times, and presents various techniques—including android:process configuration, process‑specific initialization, getRunningAppProcesses(), UsageStatsManager, and the AndroidProcesses library—to reduce startup latency and manage running processes across different Android versions.
AndroidProcess ManagementStartup Optimization
0 likes · 8 min read


21CTOFeb 7, 2017 · Mobile Development
This article examines the factors that slow iOS app launch—especially dynamic library loading and Objective‑C class initialization—and presents practical measurements and optimization techniques to dramatically reduce both cold and hot startup times.
Startup Optimizationdynamic linkingiOS
0 likes · 15 min read
