This article explains Go’s concurrency fundamentals, distinguishing concurrency from parallelism, describing the CSP model built on goroutines and channels, and detailing the underlying M‑P‑G scheduler architecture—including thread models, runqueues, and load balancing—providing a comprehensive overview for developers.
The article reviews Dmitry Vyukov's 2019 talk on Go's goroutine scheduler, explains the GMP (goroutine‑M‑Processor) model, walks through its evolution from naive thread‑per‑goroutine to thread pools and work‑stealing, and discusses fairness, pre‑emptive scheduling, and possible future improvements.
This article provides a comparative overview of several popular big‑data workflow schedulers—including Oozie, Azkaban, Airflow, XXL‑Job, and DolphinScheduler—detailing their supported task types, visual workflow definition, monitoring capabilities, pause/resume features, high‑availability options, and other notable characteristics.
This guide walks through building Helm charts, deploying the Undermoon operator, creating and scaling a Redis Cluster on Kubernetes, and configuring the undermoon‑scheduler to ensure master‑replica placement across nodes, with detailed commands and parameter explanations.
Go implements a two‑level N:M concurrency model where lightweight Goroutines (G) run on logical processors (P) backed by OS threads (M), with the GMP scheduler managing run queues and channels—mutex‑protected circular buffers with send/receive queues—providing efficient, preemptive multitasking and communication.
This article explains the inner workings of the Kubernetes scheduler, details its pre‑score, score, and normalize‑score phases, discusses zone handling and resource fragmentation, and demonstrates how to extend the scheduler using the Scheduling Framework with a custom Go plugin.
This article explains how to handle a PC‑triggered device upgrade record by using Quartz for timed execution and Spring Batch for bulk processing, detailing Maven dependencies, YAML configuration, service and batch classes, custom reader/writer logic, a processor that calls an upgrade‑dispatch API, and the overall challenges encountered.
This article explains why multiple Spring Boot timers can conflict due to single‑threaded execution, demonstrates the problem with example outputs, and shows how to configure a thread pool and use @Async annotations to run timers concurrently, preventing bottlenecks and avalanche effects.
This article explains how to configure and use PyTorch optimizers, their attributes and methods, and demonstrates various learning‑rate scheduling techniques—including manual updates and built‑in schedulers such as LambdaLR, StepLR, MultiStepLR, ExponentialLR, CosineAnnealingLR, and ReduceLROnPlateau—through clear code examples.
This article explains the fundamentals of Reactor's reactive programming model—including Mono and Flux types, map and flatMap operators, asynchronous execution, scheduler choices, and error handling—while providing practical code examples to help developers efficiently use Spring WebFlux.
The article delves into Linux 5.10.61’s CFS task placement code, explaining the Energy‑Model framework, key data structures, and energy calculations, then walks through select_task_rq_fair’s wake‑up, fork, and exec paths, detailing EAS CPU selection, wake‑affine logic, fast and slow CPU‑selection algorithms, and how they balance performance with power on heterogeneous mobile platforms.
This article explains React 16's three‑layer architecture—Scheduler, Reconciler, and Renderer—introduces fiber nodes and trees, and details how the render and commit phases process updates using beginWork, completeWork, effect lists, and three‑step DOM mutation.
This article explains why Spring Boot's default single‑threaded scheduler can cause timer conflicts in real‑world applications and demonstrates how adding @Async annotations together with a custom ThreadPoolTaskExecutor configuration enables concurrent execution of multiple scheduled tasks.
This article explains the concept of requestIdleCallback, its limitations, and how React Fiber implements a custom idle‑time scheduler using requestAnimationFrame and MessageChannel, complete with code demos and analysis of the underlying React source.
This article explains how React's shift from the legacy stack reconciler to the Fiber architecture and the introduction of Concurrent Mode address UI jank by slicing work, prioritizing updates, and enabling interruptible rendering, ultimately improving performance and responsiveness.
This article provides a comprehensive overview of React's runtime optimization strategies across versions 15 to 18, explaining the evolution of its architecture, the introduction of Fiber, concurrent rendering, scheduling, priority lanes, and new APIs such as Suspense, startTransition, and useDeferredValue, while including detailed code excerpts and practical insights for developers.
This article walks through the evolution of React’s runtime architecture from version 15 to 18, explaining key concepts such as Fiber, Scheduler, priority lanes, concurrent mode, and new APIs like startTransition and useDeferredValue, while providing concrete code examples and visual diagrams.
This article walks through every component that processes a simple `kubectl run` command, from the client’s request parsing, through API‑server authentication, authorization, admission control, controller manager scheduling, to kubelet’s CRI and CNI handling that finally creates the pod and its containers.
This article walks through the complete internal journey of a `kubectl run nginx --image=nginx --replicas=3` command, detailing how the request is validated, authenticated, authorized, processed by the API server, passed through initializers, scheduled, and finally materialized as running pods by kubelet, with code excerpts from Kubernetes v1.21.
This article provides a comprehensive guide to Kubernetes Scheduler, covering its architecture, extension points, API, node affinity, taints and tolerations, scheduling bottlenecks, priority classes, and performance tuning techniques to optimize pod placement in large clusters.
This tutorial demonstrates how to combine Spring Boot, WebMagic, and MyBatis to crawl Zhihu pages, configure Maven dependencies, set up MySQL data sources, define entity and mapper classes, and schedule the crawler to run periodically, providing a complete Java web‑crawling scaffold.
This article explains how Go’s lightweight goroutine model and user‑space scheduler provide faster, more efficient concurrency than traditional OS threads, detailing the design, execution environment, task queues, work‑stealing, and blocking mechanisms that make Go’s concurrency a standout feature for backend development.
This article explains the Linux kernel scheduler's core concepts, walks through the initialization code of the 5.4 kernel (including run queues, scheduling classes, domains, and groups), and details how multi‑core and NUMA topologies are handled to achieve balanced CPU usage.
The article introduces xlss, a high‑performance, highly‑available Kubernetes local storage solution, details its core components, application scenarios, custom scheduler design, backup and recovery processes, and provides code snippets and CRD examples for implementing resilient stateful workloads.
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.
This article introduces LVS, a layer‑4 load‑balancing tool, explains its advantages over layer‑7 solutions like Nginx, describes how combining LVS with Nginx and Keepalived creates a highly available, horizontally scalable architecture, and details the three scheduling modes VS/NAT, VS/TUN, and VS/DR.
The article details Go’s G‑M‑P scheduler, showing how lightweight Goroutines (G) run on OS threads (M) bound to virtual processors (P), describing runtime initialization, run‑queue management, work‑stealing, the main schedule loop, execution binding, and cleanup via goexit.
This article explains the internal workings of Golang v1.0 coroutines, covering their creation, stack‑switching logic, scheduler design, virtual‑memory basics, assembly examples, channel handling, socket event loops, and the low‑level implementation of defer, panic, and recover.
This article details a real‑world investigation of Spark SQL job latency on a YARN cluster, explains how switching the scheduler to FAIR mode, creating resource pools, and consolidating small Parquet files dramatically reduced scheduler delay and cut execution time from over 100 seconds to under 20 seconds.
This article provides an in‑depth overview of Apache Airflow, covering its core concepts, advantages, architecture components, installation steps, example ETL DAG code, common command‑line tools, and practical tips for leveraging Airflow in data engineering workflows.
This article explains React 16’s new Fiber architecture and its cooperative scheduling algorithm, showing how large diff tasks are split into small asynchronous units using priority queues and min‑heap structures, with code examples, performance visuals, and insights into real‑time and delayed task handling.
This article reviews the challenges of scheduling heterogeneous workloads—micro‑services, big‑data, AI, and HPC—on a unified cloud‑native platform, compares existing schedulers like Mesos and YARN, examines Kubernetes ecosystem extensions such as Volcano and YuniKorn, and details the design and components of the Transwarp Scheduler built on Kubernetes Scheduling Framework v2.
This article explains the need for high‑performance scheduling in Java, introduces the hashed timing wheel algorithm, and details Dubbo's implementation—including core interfaces, data structures, worker logic, and practical use cases such as retries and heartbeat handling.
Ruby 3.0.0 Preview 1 introduces RBS for static type definitions, experimental Ractor for actor‑model concurrency, and a new Scheduler API for lightweight thread management, accompanied by examples and a list of supported synchronization methods, highlighting the language’s evolving capabilities.
This article analyzes a TiDB production cluster outage caused by write‑write conflicts, walks through the monitoring data and log investigation, explains the underlying transaction model differences, and shares the step‑by‑step troubleshooting process that led to the final resolution.
This article explains how Kubernetes' Kube‑scheduler has evolved from early Extender and multiple‑scheduler approaches to the modern Scheduling Framework, detailing its architecture, extension points, and a step‑by‑step guide to building a custom QoS plugin with code examples.
This article details Ctrip Cloud Container's practical experience in building a unified, policy‑driven scheduling framework for Kubernetes, covering algorithm parameterization, affinity configuration, extended resource‑balancing, load‑aware scoring, and performance tuning that together raise scheduling throughput by over five times in large‑scale clusters.
This tutorial walks through creating an end‑to‑end Zhihu hot‑list project that scrapes the billboard page, stores the data with Flask‑SQLAlchemy, schedules periodic updates, exposes RESTful APIs, and finally displays the results in a uni‑app mini‑program with interactive charts.
This article explains the role of YARN's Scheduler, compares FIFO, Capacity, and Fair schedulers, details their configurations—including XML snippets for Capacity and Fair schedulers, queue hierarchy, preemption settings, and provides practical guidance for resource allocation in Hadoop clusters.
This roundup covers the open‑source launch of OAM, KubeVirt joining the CNCF Sandbox, the release of KubeAdvisor 1.0, several kube‑scheduler improvements, kubeadm usability upgrades, notable KEPs, VMware‑Tanzu project migrations, a tool for converting deprecated Kubernetes APIs, and a curated list of weekly technical readings.
This article explains RxJava's Scheduler abstraction, lists the built‑in schedulers, demonstrates thread control with subscribeOn() and observeOn() through a detailed code example, and walks through the underlying source code to show how tasks are scheduled and executed on different threads.
The article walks through Go’s 1.9.2 scheduler on Linux, explaining how the three abstractions—G (goroutine), M (OS thread), and P (processor)—are created, bound, and used in the scheduling loop to run, yield, and balance goroutines via local, global, and stolen queues.
This article presents a concise yet detailed formal model of the Kubernetes Scheduler, describing its control‑loop logic, scheduling and preemption processes, feasibility filters, viability scoring, and binding objects using TLA+ specifications and illustrative code snippets.
This article explores Go's goroutine implementation by dissecting the M‑P‑G model, scheduling strategies, preemption mechanisms, and low‑level context‑switch details, complemented with code snippets and assembly examples to illustrate how lightweight user‑level threads achieve high concurrency.
EasyScheduler is an open‑source big‑data workflow scheduler that uses a decentralized architecture with Master and Worker nodes coordinated via ZooKeeper, supporting DAG‑based task definitions, various task types, fault tolerance, priority handling, distributed locks, and remote logging, all illustrated with detailed component diagrams.
This article introduces EasyScheduler, an open‑source big data workflow scheduling system, explaining its core terminology, decentralized architecture, distributed lock implementation, thread‑shortage handling, fault‑tolerance mechanisms, task‑retry and priority designs, as well as its logging solution using Logback and gRPC.
Go’s syscall mechanism uses assembly‑implemented entry functions like Syscall and Syscall6 to invoke the kernel, while the runtime’s entersyscall and exitsyscall hooks notify the scheduler, allowing P resources to be released during blocking calls and handling privileged low‑level syscalls separately.
The article provides a comprehensive overview of Hadoop's Capacity Scheduler, describing its resource‑allocation features, configurable XML parameters, queue access controls, dynamic configuration updates, and the internal workflow of application initialization and resource scheduling within YARN.
This article explains the inner workings of the Kubernetes scheduler, covering its architecture, pod queue handling, filtering, prioritization, binding, preemption, and code-level details, while also discussing current limitations and future enhancements such as the V2 framework and gang scheduling extensions.
This article provides a comprehensive overview of the Quartz Java scheduling framework, detailing its architecture, core components such as Scheduler, Job, Trigger and JobDetail, typical use cases, Spring‑based cluster deployment configurations, monitoring techniques, and the underlying database‑lock synchronization mechanism.
The article details Alibaba’s Sigma scheduling and cluster management platform—its three‑layer architecture, data and state consistency strategies, real‑world case studies, Go‑based redesign, integration with Kubernetes APIs, and lessons on concurrency, high availability, and pod dispersion for massive Double 11 traffic.
This article provides a comprehensive overview of Kubernetes, covering its definition, primary functions, core concepts such as Pods, Services, Replication Controllers and Labels, and detailed explanations of master components, Kubelet, and Proxy within the cloud‑native container orchestration ecosystem.
This article explains Go's concurrency foundations, detailing the difference between concurrency and parallelism, the CSP model using goroutines and channels, and the internal M‑P‑G scheduler architecture that balances work across processors and system threads.
This article surveys the evolution, core concepts, and concrete implementation details of Linux task scheduling, illustrating kernel data structures, scheduling entities, run‑queue management, and the CFS algorithm with code excerpts and explaining how the scheduler balances interactive and background workloads.
This article explains the inner workings of Go's runtime scheduler, detailing how lightweight goroutines (G), logical processors (P), and OS threads (M) interact, how work stealing operates, and how to trace scheduler behavior using GODEBUG and go tool trace.
This article surveys the evolution of schedulers—from early batch systems and OS process schedulers to modern centralized, two‑level, and shared‑state designs—explaining their core concepts, trade‑offs, and real‑world examples such as YARN, Mesos, Spark, Borg, and Kubernetes.
Alibaba’s nine‑year Double‑11 evolution grew transaction volume 280‑fold, prompting a unified scheduling system (Sigma), mixed‑deployment of online and offline tasks via Sigma and Fuxi, and a cloud‑native architecture that leverages PouchContainer, resource isolation, and dynamic scaling to cut IT costs and boost resource utilization.
This article surveys the architecture of cluster resource managers and task schedulers—covering definitions, design principles, and three main categories (centralized, two‑level, and shared‑state) with concrete examples such as Hadoop YARN, Mesos, Spark Drizzle, Borg and Kubernetes—while highlighting their trade‑offs in scalability, fault‑tolerance, and flexibility.
This article provides a comprehensive overview of the Kubernetes kube‑scheduler, detailing its watch‑and‑bind mechanism, two‑stage scheduling algorithm, and an in‑depth analysis of the source code structure and key functions for readers interested in mastering Kubernetes scheduling internals.
This article explains how Inceptor 5.0’s enhanced Scheduler resolves multi‑tenant resource contention by introducing finer‑grained scheduling modes, ACL and SLA configuration, and a tree‑structured queue system that balances priority, quotas, and user permissions for more reliable big‑data job execution.
A backend process that reports CPU and memory every 10 seconds missed occasional reports on Windows because the Sleep function oversleeps by up to one scheduler time slice, a problem solved by adjusting timing or using higher‑precision wait mechanisms such as Event.wait on Linux.
This guide explains how to verify and configure Oracle's automatic optimizer statistics collection, customize collection windows, tailor statistics for large and partitioned tables, detect stale statistics, and decide when to gather histograms, providing practical SQL and PL/SQL examples.
This article explains how to implement a pure‑PHP timer using CLI mode, the PCNTL extension, and SIGALRM signals, covering basic concepts, task storage structures, the Timer class implementation, example usage, and practical considerations for long‑running services.
