Concurrency & Threads

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

/* The thread function takes/returns void*; to hand data in or results
 * out you pass POINTERS, so the heap (or stack of a still-live frame)
 * is the shared channel. Here each worker owns one heap-allocated long. */
typedef struct { long n, sum; } Work;

static void *worker(void *arg) {
    Work *w = arg;                    /* the void* we passed to pthread_create */
    w->sum = 0;
    for (long i = 1; i <= w->n; i++)  /* sum 1..n */
        w->sum += i;
    return NULL;                      /* could also return a heap pointer */
}

int main(void) {
    pthread_t t1, t2;
    Work *a = malloc(sizeof *a);      /* heap so both threads see live storage */
    Work *b = malloc(sizeof *b);
    if (!a || !b) { free(a); free(b); return 1; }
    a->n = 1000; b->n = 2000;

    pthread_create(&t1, NULL, worker, a);  /* spawn; 'a' is shared with t1 */
    pthread_create(&t2, NULL, worker, b);

    pthread_join(t1, NULL);          /* block until t1 finishes... */
    pthread_join(t2, NULL);          /* ...then t2; now results are visible */

    printf("%ld %ld\n", a->sum, b->sum);  /* 500500 2001000 */
    free(a);                          /* main owns the buffers; free after join */
    free(b);
    return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <memory>
#include <numeric>

// std::thread runs any callable; arguments are COPIED into the thread
// unless you opt into std::ref. We capture a unique_ptr's payload by
// reference and write the result through it -- ownership stays in main.
long sum_to(long n) {                  // pure compute, returned by value
    long s = 0;
    for (long i = 1; i <= n; ++i) s += i;
    return s;
}

int main() {
    auto r1 = std::make_unique<long>(0);   // results live on the heap, owned by main
    auto r2 = std::make_unique<long>(0);

    // Spawn two threads; the lambda captures the raw target by reference.
    std::thread t1([&, p = r1.get()] { *p = sum_to(1000); });
    std::thread t2([&, p = r2.get()] { *p = sum_to(2000); });

    t1.join();                          // must join (or detach) before ~thread,
    t2.join();                          // else terminate(); join syncs the writes

    std::cout << *r1 << ' ' << *r2 << '\n';  // 500500 2001000
    return 0;                           // unique_ptrs free the longs (RAII)
}

// HolyC/TempleOS is cooperatively multitasked and single-core: you spawn
// a "task" with Spawn(fp, data), and it yields cooperatively. There is no
// preemption and no memory protection, so all tasks share ring-0 memory
// directly -- the data pointer IS the shared channel, no copy is made.

class Work { I64 n, sum; };

U0 Worker(Work *w)            // a task entry point: takes the data pointer
{
  I64 i, s = 0;
  for (i = 1; i <= w->n; i++) // sum 1..n
    s += i;
  w->sum = s;                 // write the result straight into shared memory
}

Work *a = MAlloc(sizeof(Work)); // heap shared with the spawned task
a->n = 1000; a->sum = 0;

CTask *t = Spawn(&Worker, a);   // create + start a task running Worker(a)
while (TaskValidate(t))         // no real join: poll until the task dies
  Yield;                        // cooperatively give it CPU time

Print("%d\n", a->sum);          // 500500
Free(a);

const std = @import("std");

// std.Thread.spawn takes a config, a function, and a tuple of args that
// are passed by value -- to mutate shared state you pass a pointer. No
// hidden allocation: the thread's stack size comes from SpawnConfig.
fn worker(n: u64, out: *u64) void {
    var s: u64 = 0;
    var i: u64 = 1;
    while (i <= n) : (i += 1) s += i; // sum 1..n
    out.* = s;                        // write result through the pointer
}

pub fn main() !void {
    var r1: u64 = 0;
    var r2: u64 = 0;

    // spawn returns !std.Thread; args is a tuple matching worker's params.
    const t1 = try std.Thread.spawn(.{}, worker, .{ 1000, &r1 });
    const t2 = try std.Thread.spawn(.{}, worker, .{ 2000, &r2 });

    t1.join(); // blocks until the thread returns; no error to handle
    t2.join();

    std.debug.print("{d} {d}\n", .{ r1, r2 }); // 500500 2001000
}

use fmt;

// Hare's standard library has NO threading module yet -- there is no
// pthread-style create/join wrapper. The only primitive is the raw Linux
// clone(2) syscall in sys::linux:
//
//   use sys::linux;
//   // share the address space (CLONE_VM) so memory crosses the boundary;
//   // the child continues inline from the call (fork-style, not an fp entry):
//   let stack = alloc([0u8...], 64 * 1024)!;  // manual child stack you own
//   match (sys::linux::clone(&stack[len(stack)], flags, null, &ctid, 0)) {
//   case let pid: int => /* parent: futex-wait on ctid to "join" */;
//   case void         => /* child: do work, then sys::linux::exit(0) */;
//   case let e: errno => /* handle */;
//   };
//
// That is verbose and Linux-only, so the honest minimal answer is the
// single-task computation -- the shared-memory idiom is still a pointer
// into storage main owns.
type work = struct { n: u64, sum: u64 };

fn worker(w: *work) void = {
	let s = 0u64;
	for (let i = 1u64; i <= w.n; i += 1) {
		s += i;            // sum 1..n
	};
	w.sum = s;                 // write result through the pointer
};

export fn main() void = {
	let a = alloc(work { n = 1000, sum = 0 })!; // heap, owned by main
	defer free(a);                              // reclaimed after use

	worker(a);                                  // (would be the cloned child)
	fmt::printfln("{}", a.sum)!;                // 500500
};

package main

import "core:fmt"
import "core:thread"

// core:thread wraps OS threads. A ^thread.Thread carries user_index/data
// fields, but the idiomatic way to share is a pointer in a struct you own
// (memory routes through the implicit context.allocator).
Work :: struct { n: int, sum: int }

worker :: proc(t: ^thread.Thread) {
	w := cast(^Work)t.data   // the pointer we stashed before starting
	s := 0
	for i in 1..=w.n do s += i  // sum 1..n
	w.sum = s                // write result into shared memory
}

main :: proc() {
	a := new(Work); a.n = 1000  // heap via context.allocator
	b := new(Work); b.n = 2000
	defer free(a)               // main owns the buffers
	defer free(b)

	t1 := thread.create(worker); t1.data = a  // create paused...
	t2 := thread.create(worker); t2.data = b
	defer thread.destroy(t1)
	defer thread.destroy(t2)

	thread.start(t1); thread.start(t2)  // ...then start
	thread.join(t1);  thread.join(t2)   // block until both finish

	fmt.println(a.sum, b.sum)   // 500500 2001000
}

\ Standard ANS/Forth has NO portable threading model -- the language is
\ deliberately tiny and single-task. Concurrency is an environmental
\ extension: cooperative MULTITASKER words (PAUSE/ACTIVATE) on classic
\ systems like Gforth/SwiftForth, or raw OS threads via an FFI. Below is
\ the closest idiom: a cooperative task that yields, sharing one cell.

VARIABLE result            \ a single shared cell (the "channel")

: sum-to ( n -- )          \ sum 1..n into 'result'
  0 swap                   ( 0 n )
  1+ 1 ?DO  I +  LOOP      \ accumulate 1..n
  result ! ;               \ store the total into the shared variable

\ On a multitasker you would: build a task, ACTIVATE it on sum-to,
\ then PAUSE in a loop until it signals done -- cooperative, not
\ preemptive, so the worker must PAUSE to let others run. With no such
\ extension this simply runs inline (one task), which is the honest answer:
1000 sum-to
result @ .                 \ 500500