Concurrency & Asynchronous Performance Questions

# Python 3.11 TaskGroup
async def handle_request(req):
    async with asyncio.TaskGroup() as tg:
        tg.create_task(fetch_a(req))
        tg.create_task(fetch_b(req))
    # If any child raises, others are cancelled and exception propagates

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
  Future<String> a = scope.fork(() -> fetchA());
  Future<String> b = scope.fork(() -> fetchB());
  scope.join(); scope.throwIfFailed();
  String ra = a.resultNow();
  String rb = b.resultNow();
}

const { performance } = require('perf_hooks');
const interval = 100;
setInterval(() => {
  const start = performance.now();
  setImmediate(() => {
    const delay = performance.now() - start - interval;
    if (delay > 20) console.warn('event-loop-blocked-ms', { delay });
  });
}, interval).unref();

package workerpool

import (
    "context"
    "sync"
    "sync/atomic"
)

// Job is a unit of work; must respect ctx for cancellation.
type Job func(ctx context.Context)

// Pool manages workers and a bounded queue.
type Pool struct {
    maxWorkers int
    queue      chan Job
    ctx        context.Context
    cancel     context.CancelFunc

    activeWorkers int32 // atomic
    queued        int32 // atomic

    wg sync.WaitGroup
}

// NewPool creates a pool with bounded queue size N.
func NewPool(parent context.Context, maxWorkers, queueSize int) *Pool {
    ctx, cancel := context.WithCancel(parent)
    p := &Pool{
        maxWorkers: maxWorkers,
        queue:      make(chan Job, queueSize),
        ctx:        ctx,
        cancel:     cancel,
    }
    // start worker launcher
    for i := 0; i < maxWorkers; i++ {
        p.wg.Add(1)
        go p.worker()
    }
    return p
}

// Submit enqueues a job, returns error if context done or queue full.
func (p *Pool) Submit(job Job) error {
    select {
    case <-p.ctx:
        return context.Canceled
    case p.queue <- job:
        atomic.AddInt32(&p.queued, 1)
        return nil
    default:
        return context.DeadlineExceeded // or custom ErrQueueFull
    }
}

// worker runs jobs until pool context is cancelled and queue drained.
func (p *Pool) worker() {
    defer p.wg.Done()
    for {
        select {
        case <-p.ctx:
            return
        case job := <-p.queue:
            atomic.AddInt32(&p.queued, -1)
            atomic.AddInt32(&p.activeWorkers, 1)
            // give job the pool context so it can be cancelled
            job(p.ctx)
            atomic.AddInt32(&p.activeWorkers, -1)
        }
    }
}

// Shutdown requests graceful shutdown: stops accepting new jobs, waits for in-flight.
func (p *Pool) Shutdown() {
    p.cancel()    // signal cancellation to jobs and workers
    // draining queue: optionally let workers finish queued jobs; if you want immediate stop, skip draining
    p.wg.Wait()
}

// Metrics accessors
func (p *Pool) QueueLength() int { return int(atomic.LoadInt32(&p.queued)) }
func (p *Pool) ActiveWorkers() int { return int(atomic.LoadInt32(&p.activeWorkers)) }

setTimeout(() => console.log('timeout 0'), 0);
setImmediate(() => console.log('setImmediate'));
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));