GeezerVison

C

C with Classes

C#

using System;
using System.Threading.Channels;
using System.Threading.Tasks;

Channel<string> channel = Channel.CreateBounded<string>(capacity: 10);

// Producer task
Task producer = Task.Run(async () =>
{
    for (int i = 0; i < 20; i++)
    {
        await channel.Writer.WriteAsync($"Message {i}");
    }
    channel.Writer.Complete();
});

// Consumer task
Task consumer = Task.Run(async () =>
{
    await foreach (string message in channel.Reader.ReadAllAsync())
    {
        Console.WriteLine(message);
    }
});

await Task.WhenAll(producer, consumer);

C++

import std;

using std::bounded_queue;
using std::jthread;
using std::string;

bounded_queue<string> q(10);

// Producer thread
jthread producer([&q] -> void {
    for (int i = 0; i < 20; ++i) {
        q.push_wait(std::format("Message {}", i));
    }
    q.close(); // Signals consumer to finish
});

// Consumer thread
jthread consumer([&q] -> void {
    string message;
    while (q.pop_wait(message) { // Blocks if empty
        std::println("{}", message);
    }
});

Go

c := make(chan int)

go func() {c <- 42}()

x := <- c

Java

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

BlockingQueue<String> q = new ArrayBlockingQueue<>(10); // capacity of 10

// Producer thread
Thread producer = new Thread(() -> {
    try {
        for (int i = 0; i < 20; i++) {
            q.put("Message " + i); // Blocks safely until consumer makes space
        }
        q.put("DONE"); // Poison pill to signal completion
    } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
    }
});

// Consumer thread
Thread consumer = new Thread(() -> {
    try {
        while (true) {
            String message = q.take(); // Blocks safely until item arrives
            if (message.equals("DONE")) {
                break;
            }
            System.out.println(message);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

producer.start();
consumer.start();

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.channels.produce

fun main() = runBlocking {
    val channel: ReceiveChannel<String> = produce(Dispatchers.Default, capacity = 10) {
        for (i in 0 until 20) {
            channel.send("Message $i")
        }
    }

    // Consumer coroutine
    launch(Dispatchers.Default) {
        for (message in channel) {
            println(message)
        }
    }
}

Lua Love2D

-- A string containing code which will be interpreted by a function such as loadstring(),
-- but on the C side to start a native thread.

local threadCode = [[
    love.thread.getChannel("test"):push("Hello world!")
]]


function love.load()
    -- Start the thread.
    
    thread = love.thread.newThread(threadCode)
    thread:start()
    
    -- The thread will block until "Hello world!" is popped off channel test's stack.
    -- Because the channel can be popped from before the thread first executes, there may not be data on the stack.
    -- in that case use :demand() instead of :pop() because :demand() will block until there is data on the stack and then return the data.
    
    print(love.thread.getChannel("test"):demand())
    
    -- The thread can now finish.
end

OCaml

Rust

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        tx.send(123).unwrap();
    });

    let result = rx.recv();
    println!("{result:?}");
}

XMOS XC

chan c;
int x;
par {
  c <: 42;
  c :> x;
}