{
  "id": 377858,
  "title": "Scheduling concurrency",
  "url": "https://urgent.news/2026/08/09/scheduling-concurrency",
  "topic": "culture",
  "section": "Culture",
  "published": "2026-08-09T13:36:13.000Z",
  "source": {
    "name": "Dev.to",
    "slug": "dev-to",
    "url": "https://dev.to/silvern47/scheduling-concurrency-9bd"
  },
  "original_language": "en",
  "account": "This account explores the three programming languages Go, Kotlin, and Elixir/Erlang, with a focus on their concurrency models. The article delves into Go's preemptive scheduling, particularly in versions 1.14 and beyond.\n\nPrior to Go 1.14, the language utilized cooperative preemption at function prologues. This method allowed the compiler to insert preemption points in those areas, ensuring precise garbage collection by knowing all local GC roots at safe-points. However, this approach had its drawbacks, such as the potential for a program to entirely halt in extreme cases and the introduction of a 7.8% slowdown in large benchmark suites despite efforts to mitigate the issue through fault-based preemption.\n\nGo 1.14 introduced a signal-based non-cooperative preemption mechanism, which enabled switching between concurrent execution contexts without explicit preemption checks or assistance from those contexts. This change mirrors the way modern operating systems manage thread switching. When a goroutine is interrupted, the runtime captures its CPU state and resumes it later, eliminating the need for preemption checks.\n\nThe specific choice of the SIGURG signal for this purpose is explained. It meets several criteria, including passing through debuggers by default, not being used internally by libc in mixed Go/C binaries, being spurious and causing no harm, and being unlikely to be used by applications for its intended meaning. SIGUSR, on the other hand, is a different case, representing a more complex intersection of OS signals, compiler internals, runtime, and GC designs.",
  "summary": "Have been trying to look at 3 different languages: Go, Kotlin, Elixir/Erlang mostly to understand their concurrency models. This article concerns mostly about Go's preemptive scheduling. Looking at the dense article on go: https://go.googlesource.com/proposal/+/master/design/24543-non-cooperative-preemption.md Here is what I understand. Before Go 1.14: Cooperative preemption at function prologues…",
  "key_points": [
    "Go 1.14 introduced signal-based non-cooperative preemption mechanism",
    "SIGURG signal chosen for preemption due to specific criteria",
    "Preemption eliminates need for checks, mirrors OS thread switching"
  ],
  "editors_take": null,
  "illustration": null,
  "coverage": {
    "outlets": 1,
    "also_reported_by": []
  },
  "ai_generated": true,
  "disclaimer": "Summaries, key points and the editor’s take are written by software from other outlets’ reporting and may contain errors — always check the linked original."
}