Threads and threading models

Python 3.14 · main.py

from dataclasses import dataclass

THREAD = {"CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"}


@dataclass
class Task:  # what Linux keeps for every thread and every process
    tid: int  # gettid()
    tgid: int  # getpid(): the ID of the thread group
    memory: dict[str, int]  # the address space: shared with CLONE_VM, else copied


@dataclass
class Kernel:
    next_tid: int = 101

    def clone(self, parent: Task, flags: set[str]) -> Task:
        tid = self.next_tid
        self.next_tid += 1
        memory = parent.memory if "CLONE_VM" in flags else dict(parent.memory)
        tgid = parent.tgid if "CLONE_THREAD" in flags else tid
        return Task(tid, tgid, memory)


kernel = Kernel()
main = Task(100, 100, {"counter": 0})
thread = kernel.clone(main, THREAD)  # what pthread_create asks for
child = kernel.clone(main, set())  # what fork asks for
print("task    getpid  gettid")
for name, task in [("main", main), ("thread", thread), ("child", child)]:
    print(f"{name:<7}{task.tgid:>7}{task.tid:>8}")
thread.memory["counter"] = 1
print(f"thread sets counter to 1: main reads {main.memory['counter']}")
child.memory["counter"] = 2
print(f"child sets counter to 2: main reads {main.memory['counter']}")

In Python: The thread receives the parent's own dict, while dict(parent.memory) makes a new one: that is the whole difference between sharing and copying an address space here.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

const THREAD = new Set(["CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"]);

// What Linux keeps for every thread and every process: tid is gettid(), tgid is getpid(),
// and memory is the address space, shared with CLONE_VM, else copied.
class Kernel {
  nextTid = 101;

  clone(parent, flags) {
    const tid = this.nextTid++;
    const memory = flags.has("CLONE_VM") ? parent.memory : new Map(parent.memory);
    const tgid = flags.has("CLONE_THREAD") ? parent.tgid : tid;
    return { tid, tgid, memory };
  }
}

const kernel = new Kernel();
const main = { tid: 100, tgid: 100, memory: new Map([["counter", 0]]) };
const thread = kernel.clone(main, THREAD); // what pthread_create asks for
const child = kernel.clone(main, new Set()); // what fork asks for
console.log("task    getpid  gettid");
for (const [name, task] of [
  ["main", main],
  ["thread", thread],
  ["child", child],
]) {
  console.log(name.padEnd(7) + String(task.tgid).padStart(7) + String(task.tid).padStart(8));
}
thread.memory.set("counter", 1);
console.log(`thread sets counter to 1: main reads ${main.memory.get("counter")}`);
child.memory.set("counter", 2);
console.log(`child sets counter to 2: main reads ${main.memory.get("counter")}`);

In JavaScript: A Map is held by reference, so the thread receives the parent's Map itself, and new Map(parent.memory) makes the child a copy of its own.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Main {
  static final Set<String> THREAD =
      Set.of("CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD");

  /**
   * What Linux keeps for every thread and every process: tid is gettid(), tgid is getpid(), and
   * memory is the address space, shared with CLONE_VM, else copied.
   */
  record Task(int tid, int tgid, Map<String, Integer> memory) {}

  static int nextTid = 101;

  static Task cloneTask(Task parent, Set<String> flags) {
    int tid = nextTid++;
    var memory = flags.contains("CLONE_VM") ? parent.memory() : new HashMap<>(parent.memory());
    int tgid = flags.contains("CLONE_THREAD") ? parent.tgid() : tid;
    return new Task(tid, tgid, memory);
  }

  static String padded(Object value, int width) {
    String text = String.valueOf(value);
    return " ".repeat(width - text.length()) + text;
  }

  public static void main(String[] args) {
    Task main = new Task(100, 100, new HashMap<>(Map.of("counter", 0)));
    Task thread = cloneTask(main, THREAD); // what pthread_create asks for
    Task child = cloneTask(main, Set.of()); // what fork asks for
    System.out.println("task    getpid  gettid");
    String[] names = {"main", "thread", "child"};
    Task[] tasks = {main, thread, child};
    for (int i = 0; i < tasks.length; i++) {
      String name = names[i] + " ".repeat(7 - names[i].length());
      System.out.println(name + padded(tasks[i].tgid(), 7) + padded(tasks[i].tid(), 8));
    }
    thread.memory().put("counter", 1);
    System.out.println("thread sets counter to 1: main reads " + main.memory().get("counter"));
    child.memory().put("counter", 2);
    System.out.println("child sets counter to 2: main reads " + main.memory().get("counter"));
  }
}

In Java: Task is a record that holds a reference to its map, so the thread and main point at one HashMap, while new HashMap<>(...) copies it for the child.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <map>
#include <memory>
#include <print>
#include <set>
#include <string>

using Memory = std::map<std::string, int>;

// What Linux keeps for every thread and every process.
struct Task {
  int tid;                        // gettid()
  int tgid;                       // getpid(): the ID of the thread group
  std::shared_ptr<Memory> memory; // the address space: shared with CLONE_VM
};

const std::set<std::string> thread_flags = {"CLONE_VM", "CLONE_FILES",
                                            "CLONE_SIGHAND", "CLONE_THREAD"};

class Kernel {
public:
  Task clone(const Task &parent, const std::set<std::string> &flags) {
    const int tid = next_tid_++;
    auto memory = flags.contains("CLONE_VM")
                      ? parent.memory
                      : std::make_shared<Memory>(*parent.memory);
    return {tid, flags.contains("CLONE_THREAD") ? parent.tgid : tid, memory};
  }

private:
  int next_tid_ = 101;
};

int main() {
  Kernel kernel;
  const Task main_task{100, 100,
                       std::make_shared<Memory>(Memory{{"counter", 0}})};
  const Task thread = kernel.clone(main_task, thread_flags); // pthread_create
  const Task child = kernel.clone(main_task, {});            // fork
  std::println("task    getpid  gettid");
  for (const auto &[name, task] :
       {std::pair{"main", main_task}, {"thread", thread}, {"child", child}})
    std::println("{:<7}{:>7}{:>8}", name, task.tgid, task.tid);
  (*thread.memory)["counter"] = 1;
  std::println("thread sets counter to 1: main reads {}",
               main_task.memory->at("counter"));
  (*child.memory)["counter"] = 2;
  std::println("child sets counter to 2: main reads {}",
               main_task.memory->at("counter"));
}

In C++: std::shared_ptr<Memory> lets two tasks own one map: copying the pointer shares it, and std::make_shared<Memory>(*parent.memory) copies the map itself.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

var kernel = new Kernel();
var main = new TaskEntry(100, 100, new() { ["counter"] = 0 });
var thread = kernel.Clone(main, Kernel.ThreadFlags); // what pthread_create asks for
var child = kernel.Clone(main, []); // what fork asks for
Console.WriteLine("task    getpid  gettid");
foreach (var (name, task) in new[] { ("main", main), ("thread", thread), ("child", child) })
{
    Console.WriteLine($"{name,-7}{task.Tgid,7}{task.Tid,8}");
}
thread.Memory["counter"] = 1;
Console.WriteLine($"thread sets counter to 1: main reads {main.Memory["counter"]}");
child.Memory["counter"] = 2;
Console.WriteLine($"child sets counter to 2: main reads {main.Memory["counter"]}");

// What Linux keeps for every thread and every process: Tid is gettid(), Tgid is getpid(),
// and Memory is the address space, shared with CLONE_VM, else copied.
sealed record TaskEntry(int Tid, int Tgid, Dictionary<string, int> Memory);

sealed class Kernel
{
    public static readonly HashSet<string> ThreadFlags =
        ["CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"];

    private int nextTid = 101;

    public TaskEntry Clone(TaskEntry parent, HashSet<string> flags)
    {
        var tid = nextTid++;
        var memory = flags.Contains("CLONE_VM") ? parent.Memory : new(parent.Memory);
        return new TaskEntry(tid, flags.Contains("CLONE_THREAD") ? parent.Tgid : tid, memory);
    }
}

In C#: The record is TaskEntry because Task is already .NET's own type for asynchronous work, and new(parent.Memory) copies the dictionary.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdio.h>
#include <stdlib.h>

enum { CLONE_VM = 1, CLONE_FILES = 2, CLONE_SIGHAND = 4, CLONE_THREAD = 8 };

typedef struct {
  int counter;
} Memory; // the address space, reduced to one variable

// What Linux keeps for every thread and every process.
typedef struct {
  int tid;        // gettid()
  int tgid;       // getpid(): the ID of the thread group
  Memory *memory; // shared with CLONE_VM, else copied
} Task;

static int next_tid = 101;

static Task clone_task(const Task *parent, int flags) {
  Task task = {next_tid++, parent->tgid, parent->memory};
  if (!(flags & CLONE_THREAD)) {
    task.tgid = task.tid;
  }
  if (!(flags & CLONE_VM)) {
    task.memory = malloc(sizeof(Memory));
    *task.memory = *parent->memory;
  }
  return task;
}

int main(void) {
  Memory memory = {0};
  const Task main_task = {100, 100, &memory};
  const Task thread = clone_task(&main_task, CLONE_VM | CLONE_FILES |
                                                 CLONE_SIGHAND | CLONE_THREAD);
  const Task child = clone_task(&main_task, 0); // what fork asks for
  printf("task    getpid  gettid\n");
  const char *names[] = {"main", "thread", "child"};
  const Task *tasks[] = {&main_task, &thread, &child};
  for (int i = 0; i < 3; i++) {
    printf("%-7s%7d%8d\n", names[i], tasks[i]->tgid, tasks[i]->tid);
  }
  thread.memory->counter = 1;
  printf("thread sets counter to 1: main reads %d\n", memory.counter);
  child.memory->counter = 2;
  printf("child sets counter to 2: main reads %d\n", memory.counter);
  free(child.memory);
  return 0;
}

In C: Sharing is copying the pointer, copying is malloc and a struct assignment, and the flags are a bit mask, as the real clone takes them.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

const THREAD = ['CLONE_VM', 'CLONE_FILES', 'CLONE_SIGHAND', 'CLONE_THREAD'];

// The address space, as an object: tasks that hold the same object share it.
final class Memory
{
    /** @param array<string, int> $values */
    public function __construct(public array $values) {}
}

// What Linux keeps for every thread and every process.
final class Task
{
    public function __construct(
        public readonly int $tid, // gettid()
        public readonly int $tgid, // getpid(): the ID of the thread group
        public readonly Memory $memory, // shared with CLONE_VM, else copied
    ) {}
}

final class Kernel
{
    private int $nextTid = 101;

    /** @param list<string> $flags */
    public function clone(Task $parent, array $flags): Task
    {
        $tid = $this->nextTid++;
        $memory = in_array('CLONE_VM', $flags, true) ? $parent->memory : clone $parent->memory;
        $tgid = in_array('CLONE_THREAD', $flags, true) ? $parent->tgid : $tid;
        return new Task($tid, $tgid, $memory);
    }
}

$kernel = new Kernel();
$main = new Task(100, 100, new Memory(['counter' => 0]));
$thread = $kernel->clone($main, THREAD); // what pthread_create asks for
$child = $kernel->clone($main, []); // what fork asks for
echo "task    getpid  gettid\n";
foreach (['main' => $main, 'thread' => $thread, 'child' => $child] as $name => $task) {
    printf("%-7s%7d%8d\n", $name, $task->tgid, $task->tid);
}
$thread->memory->values['counter'] = 1;
echo "thread sets counter to 1: main reads {$main->memory->values['counter']}\n";
$child->memory->values['counter'] = 2;
echo "child sets counter to 2: main reads {$main->memory->values['counter']}\n";

In PHP: PHP copies arrays on assignment, so the address space is an object: tasks that hold the same object share it, and clone makes the child a copy.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

use std::cell::RefCell;
use std::collections::BTreeMap;
use std::rc::Rc;

const THREAD: [&str; 4] = ["CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"];

/// What Linux keeps for every thread and every process.
struct Task {
    tid: u32,                                   // gettid()
    tgid: u32,                                  // getpid(): the ID of the thread group
    memory: Rc<RefCell<BTreeMap<String, i32>>>, // the address space: shared with CLONE_VM
}

struct Kernel {
    next_tid: u32,
}

impl Kernel {
    fn clone_task(&mut self, parent: &Task, flags: &[&str]) -> Task {
        let tid = self.next_tid;
        self.next_tid += 1;
        let memory = if flags.contains(&"CLONE_VM") {
            Rc::clone(&parent.memory)
        } else {
            Rc::new(RefCell::new(parent.memory.borrow().clone()))
        };
        let tgid = if flags.contains(&"CLONE_THREAD") {
            parent.tgid
        } else {
            tid
        };
        Task { tid, tgid, memory }
    }
}

fn main() {
    let mut kernel = Kernel { next_tid: 101 };
    let memory = BTreeMap::from([("counter".to_string(), 0)]);
    let main = Task {
        tid: 100,
        tgid: 100,
        memory: Rc::new(RefCell::new(memory)),
    };
    let thread = kernel.clone_task(&main, &THREAD); // what pthread_create asks for
    let child = kernel.clone_task(&main, &[]); // what fork asks for
    println!("task    getpid  gettid");
    for (name, task) in [("main", &main), ("thread", &thread), ("child", &child)] {
        println!("{name:<7}{:>7}{:>8}", task.tgid, task.tid);
    }
    thread.memory.borrow_mut().insert("counter".to_string(), 1);
    println!(
        "thread sets counter to 1: main reads {}",
        main.memory.borrow()["counter"]
    );
    child.memory.borrow_mut().insert("counter".to_string(), 2);
    println!(
        "child sets counter to 2: main reads {}",
        main.memory.borrow()["counter"]
    );
}

In Rust: Rc<RefCell<...>> gives two tasks one map: Rc::clone shares it, borrow_mut changes it, and cloning the borrowed map makes the copy.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

const THREAD = new Set(["CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"]);

// What Linux keeps for every thread and every process.
interface Task {
  tid: number; // gettid()
  tgid: number; // getpid(): the ID of the thread group
  memory: Map<string, number>; // the address space: shared with CLONE_VM, else copied
}

class Kernel {
  nextTid = 101;

  clone(parent: Task, flags: Set<string>): Task {
    const tid = this.nextTid++;
    const memory = flags.has("CLONE_VM") ? parent.memory : new Map(parent.memory);
    const tgid = flags.has("CLONE_THREAD") ? parent.tgid : tid;
    return { tid, tgid, memory };
  }
}

const kernel = new Kernel();
const main: Task = { tid: 100, tgid: 100, memory: new Map([["counter", 0]]) };
const thread = kernel.clone(main, THREAD); // what pthread_create asks for
const child = kernel.clone(main, new Set()); // what fork asks for
console.log("task    getpid  gettid");
const tasks: [string, Task][] = [
  ["main", main],
  ["thread", thread],
  ["child", child],
];
for (const [name, task] of tasks) {
  console.log(name.padEnd(7) + String(task.tgid).padStart(7) + String(task.tid).padStart(8));
}
thread.memory.set("counter", 1);
console.log(`thread sets counter to 1: main reads ${main.memory.get("counter")}`);
child.memory.set("counter", 2);
console.log(`child sets counter to 2: main reads ${main.memory.get("counter")}`);

In TypeScript: Task is an interface for the plain object that clone returns; the rest is the JavaScript version.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"maps"
	"slices"
)

var threadFlags = []string{"CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"}

// task is what Linux keeps for every thread and every process.
type task struct {
	tid    int            // gettid()
	tgid   int            // getpid(): the ID of the thread group
	memory map[string]int // the address space: shared with CLONE_VM, else copied
}

type kernel struct{ nextTid int }

func (k *kernel) clone(parent *task, flags []string) *task {
	t := &task{tid: k.nextTid, tgid: parent.tgid, memory: parent.memory}
	k.nextTid++
	if !slices.Contains(flags, "CLONE_THREAD") {
		t.tgid = t.tid
	}
	if !slices.Contains(flags, "CLONE_VM") {
		t.memory = maps.Clone(parent.memory)
	}
	return t
}

func main() {
	k := &kernel{nextTid: 101}
	mainTask := &task{tid: 100, tgid: 100, memory: map[string]int{"counter": 0}}
	thread := k.clone(mainTask, threadFlags) // what pthread_create asks for
	child := k.clone(mainTask, nil)          // what fork asks for
	fmt.Println("task    getpid  gettid")
	names := []string{"main", "thread", "child"}
	for i, t := range []*task{mainTask, thread, child} {
		fmt.Printf("%-7s%7d%8d\n", names[i], t.tgid, t.tid)
	}
	thread.memory["counter"] = 1
	fmt.Printf("thread sets counter to 1: main reads %d\n", mainTask.memory["counter"])
	child.memory["counter"] = 2
	fmt.Printf("child sets counter to 2: main reads %d\n", mainTask.memory["counter"])
}

In Go: Maps are references in Go, so assigning the map shares it, and maps.Clone copies it for the child.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

let threadFlags: Set = ["CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD"]

// The address space. A dictionary is a value in Swift, so it lives in a class: tasks that
// hold the same object share it.
final class Memory {
  var values: [String: Int]
  init(_ values: [String: Int]) { self.values = values }
}

// What Linux keeps for every thread and every process.
struct Task {
  let tid: Int  // gettid()
  let tgid: Int  // getpid(): the ID of the thread group
  let memory: Memory  // shared with CLONE_VM, else copied
}

struct Kernel {
  var nextTid = 101

  mutating func clone(_ parent: Task, flags: Set<String>) -> Task {
    let tid = nextTid
    nextTid += 1
    let memory = flags.contains("CLONE_VM") ? parent.memory : Memory(parent.memory.values)
    return Task(tid: tid, tgid: flags.contains("CLONE_THREAD") ? parent.tgid : tid, memory: memory)
  }
}

func padded(_ value: Int, _ width: Int) -> String {
  let text = String(value)
  return String(repeating: " ", count: max(0, width - text.count)) + text
}

var kernel = Kernel()
let main = Task(tid: 100, tgid: 100, memory: Memory(["counter": 0]))
let thread = kernel.clone(main, flags: threadFlags)  // what pthread_create asks for
let child = kernel.clone(main, flags: [])  // what fork asks for
print("task    getpid  gettid")
for (name, task) in [("main", main), ("thread", thread), ("child", child)] {
  let label = name + String(repeating: " ", count: 7 - name.count)
  print(label + padded(task.tgid, 7) + padded(task.tid, 8))
}
thread.memory.values["counter"] = 1
print("thread sets counter to 1: main reads \(main.memory.values["counter"] ?? 0)")
child.memory.values["counter"] = 2
print("child sets counter to 2: main reads \(main.memory.values["counter"] ?? 0)")

In Swift: Swift dictionaries are values that copy on assignment, so the address space is a final class: tasks that hold the same object share it.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

THREAD = %w[CLONE_VM CLONE_FILES CLONE_SIGHAND CLONE_THREAD].freeze

# What Linux keeps for every thread and every process: tid is gettid(), tgid is getpid(), and
# memory is the address space, shared with CLONE_VM, else copied.
Task = Struct.new(:tid, :tgid, :memory)

# Hands out thread IDs and makes new tasks.
class OsKernel
  def initialize
    @next_tid = 101
  end

  def clone_task(parent, flags)
    tid = @next_tid
    @next_tid += 1
    memory = flags.include?('CLONE_VM') ? parent.memory : parent.memory.dup
    Task.new(tid, flags.include?('CLONE_THREAD') ? parent.tgid : tid, memory)
  end
end

kernel = OsKernel.new
main = Task.new(100, 100, { 'counter' => 0 })
thread = kernel.clone_task(main, THREAD) # what pthread_create asks for
child = kernel.clone_task(main, []) # what fork asks for
puts 'task    getpid  gettid'
{ 'main' => main, 'thread' => thread, 'child' => child }.each do |name, task|
  puts name.ljust(7) + task.tgid.to_s.rjust(7) + task.tid.to_s.rjust(8)
end
thread.memory['counter'] = 1
puts "thread sets counter to 1: main reads #{main.memory['counter']}"
child.memory['counter'] = 2
puts "child sets counter to 2: main reads #{main.memory['counter']}"

In Ruby: The class is OsKernel, because Kernel is Ruby's own module of global methods such as puts; dup copies the hash for the child.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

val threadFlags = setOf("CLONE_VM", "CLONE_FILES", "CLONE_SIGHAND", "CLONE_THREAD")

// What Linux keeps for every thread and every process: tid is gettid(), tgid is getpid(), and
// memory is the address space, shared with CLONE_VM, else copied.
class Task(
    val tid: Int,
    val tgid: Int,
    val memory: MutableMap<String, Int>,
)

class Kernel {
    private var nextTid = 101

    fun clone(
        parent: Task,
        flags: Set<String>,
    ): Task {
        val tid = nextTid++
        val memory = if ("CLONE_VM" in flags) parent.memory else parent.memory.toMutableMap()
        return Task(tid, if ("CLONE_THREAD" in flags) parent.tgid else tid, memory)
    }
}

fun main() {
    val kernel = Kernel()
    val main = Task(100, 100, mutableMapOf("counter" to 0))
    // What pthread_create asks for, then what fork asks for.
    val thread = kernel.clone(main, threadFlags)
    val child = kernel.clone(main, emptySet())
    println("task    getpid  gettid")
    for ((name, task) in listOf("main" to main, "thread" to thread, "child" to child)) {
        println(name.padEnd(7) + task.tgid.toString().padStart(7) + task.tid.toString().padStart(8))
    }
    thread.memory["counter"] = 1
    println("thread sets counter to 1: main reads ${main.memory["counter"]}")
    child.memory["counter"] = 2
    println("child sets counter to 2: main reads ${main.memory["counter"]}")
}

In Kotlin: toMutableMap() copies the map for the child, while the thread gets the parent's MutableMap itself.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

const threadFlags = {
  'CLONE_VM',
  'CLONE_FILES',
  'CLONE_SIGHAND',
  'CLONE_THREAD',
};

// What Linux keeps for every thread and every process: tid is gettid(), tgid is getpid(), and
// memory is the address space, shared with CLONE_VM, else copied.
typedef Task = ({int tid, int tgid, Map<String, int> memory});

class Kernel {
  int _nextTid = 101;

  Task clone(Task parent, Set<String> flags) {
    final tid = _nextTid++;
    return (
      tid: tid,
      tgid: flags.contains('CLONE_THREAD') ? parent.tgid : tid,
      memory: flags.contains('CLONE_VM')
          ? parent.memory
          : Map.of(parent.memory),
    );
  }
}

void main() {
  final kernel = Kernel();
  final Task main = (tid: 100, tgid: 100, memory: {'counter': 0});
  // What pthread_create asks for, then what fork asks for.
  final thread = kernel.clone(main, threadFlags);
  final child = kernel.clone(main, {});
  print('task    getpid  gettid');
  for (final (name, task) in [
    ('main', main),
    ('thread', thread),
    ('child', child),
  ]) {
    print(
      name.padRight(7) + '${task.tgid}'.padLeft(7) + '${task.tid}'.padLeft(8),
    );
  }
  thread.memory['counter'] = 1;
  print('thread sets counter to 1: main reads ${main.memory['counter']}');
  child.memory['counter'] = 2;
  print('child sets counter to 2: main reads ${main.memory['counter']}');
}

In Dart: Task is a record type with named fields, and Map.of copies the map for the child, while the thread gets the same map.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart