Code Explainers

Code explainers tagged #concurrency

go 
func (w *Watcher) resetDebounce(d time.Duration) {
	if !w.timer.Stop() {
		select {
		case <-w.timer.C:

Debouncing a stream of events in Go

debounce timers channels
Advanced 7 steps
rust 
use std::collections::VecDeque;
use std::sync::{Arc, Condvar, Mutex};
use std::time::{Duration, Instant};
 

Building a counting semaphore in Rust

concurrency synchronization condition-variable
Advanced 9 steps
rust 
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::time::{interval, MissedTickBehavior};
 

A token-bucket rate limiter in Tokio

rate-limiting channels async
Advanced 8 steps
ruby 
class Coupon < ApplicationRecord
  has_many :redemptions, dependent: :destroy
 
  validates :code, presence: true, uniqueness: { case_sensitive: false }

Safe coupon redemption in Rails

validation contexts pessimistic locking scopes
Advanced 10 steps
rust 
use axum::{
    extract::FromRequestParts,
    http::{request::Parts, HeaderMap, StatusCode},
};

Building a replay-guard extractor in Axum

custom-extractor replay-protection shared-state
Advanced 8 steps
go 
type Counter struct {
	counts sync.Map
}
 

A concurrent counter with sync.Map in Go

concurrency atomics sync.map
Advanced 8 steps
javascript 
const express = require('express');
const crypto = require('crypto');
const router = express.Router();
 

Optimistic locking with ETags in Express

optimistic-locking etag conditional-requests
Intermediate 7 steps
python 
import asyncio
import logging
from dataclasses import dataclass
 

A concurrent batch geocoder in asyncio

asyncio producer-consumer rate-limiting
Advanced 8 steps
java 
public final class RetryExecutor {
 
    private final int maxAttempts;
    private final Duration baseDelay;

Retry with exponential backoff in Java

retry exponential-backoff jitter
Intermediate 7 steps
go 
package routing
 
import (
	"net/http"

Region-aware upstream routing in Gin

middleware concurrency load-balancing
Advanced 8 steps
java 
public final class ThrottledLogger {
 
    private final Logger delegate;
    private final long windowMillis;

Rate-limiting log spam with per-message windows

concurrency rate-limiting throttling
Advanced 8 steps
python 
import hashlib
import json
from functools import wraps
from flask import g, request, jsonify, current_app

Building an idempotency decorator in Flask

idempotency decorators redis
Advanced 7 steps
rust 
use std::sync::Mutex;
use std::time::{Duration, Instant};
 
#[derive(Debug, Clone, Copy, PartialEq)]

Building a circuit breaker in Rust

circuit-breaker state-machine concurrency
Advanced 8 steps
rust 
use std::collections::HashMap;
use std::sync::Arc;
 
use axum::body::Bytes;

A concurrent webhook dispatcher in Axum

trait-objects concurrency shared-state
Intermediate 9 steps
javascript 
class RequestDeduplicator {
  constructor(fetcher) {
    this.fetcher = fetcher;
    this.inFlight = new Map();

Deduplicating in-flight requests in JavaScript

promises caching async
Intermediate 6 steps
go 
package retry
 
import (
	"errors"

How a retry budget caps retries in Go

rate-limiting sliding-window concurrency
Intermediate 7 steps
typescript 
import {
  CallHandler,
  ExecutionContext,
  Injectable,

Deduping in-flight requests in NestJS

interceptor request-deduplication rxjs
Advanced 6 steps
python 
from flask import Blueprint, request, jsonify, abort
from sqlalchemy import update
 
from .models import db, Document

Optimistic locking in a Flask PATCH endpoint

optimistic-locking concurrency rest-api
Intermediate 7 steps