Runtimes

import asyncio

async def worker(i: int) -> int:
    return i * i                       # a trivial async task

async def main() -> None:
    # create_task schedules them; gather awaits all, in order
    tasks = [asyncio.create_task(worker(i)) for i in range(4)]
    results = await asyncio.gather(*tasks)
    print(results)                     # [0, 1, 4, 9]

asyncio.run(main())                    # starts + drives the loop

#[tokio::main]                       // sets up the async runtime
async fn main() {
    let mut handles = Vec::new();
    for i in 0..4 {
        // each worker is a lightweight task (~hundreds of bytes)
        handles.push(tokio::spawn(async move { i * i }));
    }
    // .await yields instead of blocking the thread
    let mut results = Vec::new();
    for h in handles {
        results.push(h.await.unwrap());
    }
    println!("{:?}", results); // [0, 1, 4, 9]
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	results := make([]int, 4)
	var wg sync.WaitGroup
	for i := 0; i < 4; i++ {
		wg.Add(1)
		go func(i int) { // no async keyword, just "go"
			defer wg.Done()
			results[i] = i * i
		}(i)
	}
	wg.Wait()            // join all goroutines
	fmt.Println(results) // [0 1 4 9]
}

fn main() {
    // block_on drives the futures; no #[main] macro needed
    smol::block_on(async {
        let mut handles = Vec::new();
        for i in 0..4 {
            handles.push(smol::spawn(async move { i * i }));
        }
        let mut results = Vec::new();
        for h in handles {
            results.push(h.await);   // smol tasks return the value directly
        }
        println!("{:?}", results);   // [0, 1, 4, 9]
    });
}

import asyncio

class OutboxRelayWorker:
    def __init__(self, worker_count: int = 4):
        self._worker_count = worker_count

    async def _listen_loop(self, wakeup: asyncio.Event) -> None:
        while True:
            await asyncio.sleep(1)      # stand-in for pg LISTEN/NOTIFY
            wakeup.set()                # wake every waiter at once

    async def _relay_loop(self, wakeup: asyncio.Event) -> None:
        while True:
            await wakeup.wait()         # suspend until signalled
            wakeup.clear()              # must reset the flag manually
            print("relaying outbox batch...")

    async def run(self) -> None:
        wakeup = asyncio.Event()
        # create_task schedules coroutines on the single event loop
        tasks = [
            asyncio.create_task(self._listen_loop(wakeup), name="listen"),
            *[
                asyncio.create_task(self._relay_loop(wakeup), name=f"relay-{i}")
                for i in range(self._worker_count)
            ],
        ]
        await asyncio.gather(*tasks)    # join all tasks

asyncio.run(OutboxRelayWorker().run())

use tokio::sync::Notify;
use std::sync::Arc;

// Notify is shared via Arc because tasks run on different threads
async fn listen_loop(wakeup: Arc<Notify>) {
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        wakeup.notify_waiters();        // wake all current waiters
    }
}

async fn relay_loop(wakeup: Arc<Notify>) {
    loop {
        wakeup.notified().await;        // no manual clear needed
        println!("relaying outbox batch...");
    }
}

#[tokio::main]
async fn main() {
    let wakeup = Arc::new(Notify::new());
    let mut set = tokio::task::JoinSet::new();

    set.spawn(listen_loop(wakeup.clone()));    // onto the thread pool
    for _ in 0..4 {
        set.spawn(relay_loop(wakeup.clone())); // Send + 'static required
    }
    while set.join_next().await.is_some() {}   // join the whole set
}

package main

import (
	"fmt"
	"sync"
	"time"
)

type OutboxRelayWorker struct {
	workerCount int
}

func (w *OutboxRelayWorker) listenLoop(wakeup chan struct{}) {
	for {
		time.Sleep(1 * time.Second)
		select {
		case wakeup <- struct{}{}: // non-blocking send
		default:                   // drop if no worker is ready
		}
	}
}

func (w *OutboxRelayWorker) relayLoop(wakeup chan struct{}, wg *sync.WaitGroup) {
	defer wg.Done()
	for range wakeup { // ranges until the channel closes
		fmt.Println("relaying outbox batch...")
	}
}

func (w *OutboxRelayWorker) Run() {
	wakeup := make(chan struct{}, 1) // the channel *is* the signal
	var wg sync.WaitGroup

	go w.listenLoop(wakeup) // no async keyword, just "go"

	for i := 0; i < w.workerCount; i++ {
		wg.Add(1)
		go w.relayLoop(wakeup, &wg)
	}
	wg.Wait()
}

func main() {
	(&OutboxRelayWorker{workerCount: 4}).Run()
}

use event_listener::Event;
use std::sync::Arc;

// event_listener::Event is smol's stand-in for Tokio's Notify
async fn listen_loop(wakeup: Arc<Event>) {
    loop {
        smol::Timer::after(std::time::Duration::from_secs(1)).await;
        wakeup.notify(usize::MAX);      // wake all listeners
    }
}

async fn relay_loop(wakeup: Arc<Event>) {
    loop {
        wakeup.listen().await;          // register + wait for a signal
        println!("relaying outbox batch...");
    }
}

fn main() {
    let wakeup = Arc::new(Event::new());
    // no runtime macro: build a multi-thread executor by hand
    let ex = Arc::new(smol::Executor::new());
    smol::block_on(ex.run(async {
        ex.spawn(listen_loop(wakeup.clone())).detach();
        for _ in 0..4 {
            ex.spawn(relay_loop(wakeup.clone())).detach();
        }
        futures_lite::future::pending::<()>().await;
    }));
}