Context, Cancellation & Concurrency Patterns

package ctxdemo

import (
    "context"
    "time"
)

func Work(parent context.Context) error {
    ctx, cancel := context.WithTimeout(parent, 2*time.Second)
    defer cancel()
    select {
    case <-ctx.Done():
        return ctx.Err()
    case <-time.After(100 * time.Millisecond):
        return nil
    }
}

export async function work(signal?: AbortSignal) {
  const ctrl = AbortSignal.any([
    signal ?? new AbortController().signal,
    AbortSignal.timeout(2000),
  ]);
  await new Promise((resolve, reject) => {
    const timer = setTimeout(resolve, 100);
    ctrl.addEventListener("abort", () => {
      clearTimeout(timer);
      reject(ctrl.reason);
    });
  });
}

import asyncio

async def work() -> None:
    async with asyncio.timeout(2.0):
        await asyncio.sleep(0.1)

package eg

import (
    "context"
    "golang.org/x/sync/errgroup"
)

func FetchBoth(ctx context.Context) error {
    g, ctx := errgroup.WithContext(ctx)
    g.Go(func() error { return fetchA(ctx) })
    g.Go(func() error { return fetchB(ctx) })
    return g.Wait()
}

func fetchA(context.Context) error { return nil }
func fetchB(context.Context) error { return nil }

export async function fetchBoth(parent: AbortSignal) {
  const ctrl = new AbortController();
  const signal = AbortSignal.any([parent, ctrl.signal]);
  const fail = (err: unknown) => {
    ctrl.abort(err);
    throw err;
  };
  try {
    await Promise.all([fetchA(signal).catch(fail), fetchB(signal).catch(fail)]);
  } finally {
    ctrl.abort();
  }
}
async function fetchA(_signal: AbortSignal) {}
async function fetchB(_signal: AbortSignal) {}

import asyncio

async def fetch_both() -> None:
    async with asyncio.TaskGroup() as tg:
        tg.create_task(fetch_a())
        tg.create_task(fetch_b())

async def fetch_a() -> None:
    return None

async def fetch_b() -> None:
    return None