tag

#concurrency

16 pages tagged

Practice › LeetCode › LeetCode 11xx ›

LeetCode 1115 - Print FooBar Alternately

LeetCode Problem 1115 Difficulty: 🟡 Medium Topics: Concurrency Solution Problem Understanding This problem is a classic concurrency synchronization task. We are given a class FooBar with two methods, foo() and bar() . Each method is executed by a separate thread: Thread A repeatedly calls foo() Thread B repeatedly calls bar() The goal is to ensure the output sequence becomes: foobarfoobarfoobar... exactly n times. The challenge is that threads execute asynchronously....
leetcode Medium concurrency May 28, 2026
Practice › LeetCode › LeetCode 11xx ›

LeetCode 1116 - Print Zero Even Odd

LeetCode Problem 1116 Difficulty: 🟡 Medium Topics: Concurrency Solution Problem Understanding The problem requires us to implement a multithreaded class ZeroEvenOdd that coordinates three separate threads to print numbers in a specific sequence. Thread A prints 0 s, Thread B prints even numbers, and Thread C prints odd numbers. The output must interleave zeros with increasing numbers starting from 1 up to n , producing a sequence like "010203..." of...
leetcode Medium concurrency May 28, 2026
Practice › LeetCode › LeetCode 11xx ›

LeetCode 1188 - Design Bounded Blocking Queue

LeetCode Problem 1188 Difficulty: 🟡 Medium Topics: Concurrency Solution Problem Understanding This problem asks us to implement a thread-safe bounded blocking queue, which is a data structure that stores elements in a first-in-first-out (FIFO) order, but with the added constraint that multiple threads may be concurrently accessing it. The queue has a fixed capacity, and two types of operations: enqueue , which adds elements to the queue, and dequeue ,...
leetcode Medium concurrency May 28, 2026
Practice › LeetCode › LeetCode 11xx ›

LeetCode 1195 - Fizz Buzz Multithreaded

LeetCode Problem 1195 Difficulty: 🟡 Medium Topics: Concurrency Solution Problem Understanding The problem asks us to coordinate four separate threads so they collectively print the correct Fizz Buzz sequence in order from 1 to n . Unlike the classic single threaded Fizz Buzz problem, this version introduces concurrency. Each thread is responsible for only one category of output: The fizz() thread prints "fizz" for numbers divisible by 3 but not...
leetcode Medium concurrency May 28, 2026
Practice › LeetCode › LeetCode 12xx ›

LeetCode 1226 - The Dining Philosophers

LeetCode Problem 1226 Difficulty: 🟡 Medium Topics: Concurrency Solution Problem Understanding This problem asks us to implement a concurrent synchronization mechanism for the classic Dining Philosophers problem. We have five philosophers sitting around a circular table, and between every pair of neighboring philosophers lies a single fork. To eat, a philosopher must acquire both their left and right forks. Since forks are shared resources, two neighboring philosophers cannot use the...
leetcode Medium concurrency May 28, 2026
Practice › LeetCode › LeetCode 11xx ›

LeetCode 1114 - Print in Order

LeetCode Problem 1114 Difficulty: 🟢 Easy Topics: Concurrency Solution Problem Understanding This problem asks us to coordinate three independent threads so that they execute in a strict order, regardless of how the operating system schedules them. We are given a class with three methods, first() , second() , and third() . Each method is called by a different thread, and the threads may start in any order. The goal is...
leetcode Easy concurrency May 28, 2026
Practice › LeetCode › LeetCode 12xx ›

LeetCode 1242 - Web Crawler Multithreaded

LeetCode Problem 1242 Difficulty: 🟡 Medium Topics: Depth-First Search, Breadth-First Search, Concurrency Solution Problem Understanding The problem asks us to implement a multi-threaded web crawler that starts from a given URL startUrl and visits all URLs reachable from it, but only those that share the same hostname . We are given an interface HtmlParser that can return all URLs on a page through its getUrls(url) method. The goal is to...
leetcode Medium depth-first-search breadth-first-search concurrency May 28, 2026
Practice › LeetCode › LeetCode 12xx ›

LeetCode 1279 - Traffic Light Controlled Intersection

LeetCode Problem 1279 Difficulty: 🟢 Easy Topics: Concurrency Solution Problem Understanding This problem asks us to design a thread-safe traffic light system for a road intersection where cars arrive concurrently from two different roads. The challenge is not about processing cars sequentially, but about correctly synchronizing multiple threads so that cars from different roads never cross the intersection simultaneously. There are two roads: Road A ( roadId = 1 ),...
leetcode Easy concurrency May 28, 2026
Practice › LeetCode › LeetCode 11xx ›

LeetCode 1117 - Building H2O

LeetCode Problem 1117 Difficulty: 🟡 Medium Topics: Concurrency Solution Problem Understanding This problem asks us to coordinate multiple concurrent threads so that they form water molecules correctly. A water molecule contains exactly two hydrogen atoms and one oxygen atom, so the synchronization logic must ensure that threads proceed only in groups of three consisting of exactly two hydrogen threads and one oxygen thread. Each hydrogen thread calls the hydrogen() method,...
leetcode Medium concurrency May 28, 2026
Programming › Algorithm Cookbook › Chapter 6. Sorting ›

6.22 Parallel Sorting

6.22 Parallel Sorting Parallel sorting distributes work across multiple processing units. The goal is to reduce wall-clock time while preserving correctness and scalability. The cost model includes total work, parallel time (span), communication, and synchronization. Problem You have an array A[0..n-1] and p processors. You want to sort faster than a single-threaded algorithm by exploiting parallelism. Models Two common models guide design: Shared-memory model: threads access a common address space...
algorithms sorting parallel concurrency May 4, 2026
Deep Reads › CPython Internals › 10. Advanced Topics ›

94. Per-Interpreter GIL

94. Per-Interpreter GIL The per-interpreter GIL is a CPython runtime design where each subinterpreter owns its own Global Interpreter Lock instead of all interpreters sharing one process-wide lock. The traditional model used one GIL for the whole process: process runtime global GIL interpreter A interpreter B interpreter C The per-interpreter model moves the lock down into each interpreter: process runtime interpreter A GIL A interpreter B GIL B interpreter C...
cpython python internals concurrency
Deep Reads › CPython Internals › 10. Advanced Topics ›

92. Free-Threaded CPython

92. Free-Threaded CPython Free-threaded CPython is a major redesign of the interpreter runtime that removes the traditional Global Interpreter Lock (GIL) and allows multiple threads to execute Python bytecode concurrently within the same interpreter. Historically, CPython relied on the GIL to serialize execution of Python code. The GIL simplified memory management, reference counting, object mutation, allocator coordination, and internal runtime invariants. Only one thread at a time executed Python bytecode...
cpython python internals concurrency
Deep Reads › CPython Internals › 6. Standard Library Interfaces to the Core ›

60. `asyncio`

60. asyncio The asyncio module is CPython’s standard library framework for asynchronous I/O. It provides an event loop, tasks, futures, transports, streams, synchronization primitives, subprocess integration, timers, and APIs for coordinating many waiting operations in one thread. For CPython internals, asyncio matters because it exposes how async def , coroutine objects, await , futures, event loops, callbacks, and I/O readiness fit together. 60.1 The Role of asyncio asyncio is built...
cpython python internals concurrency
Deep Reads › CPython Internals › 5. Runtime Systems ›

46. The GIL

46. The GIL The Global Interpreter Lock, usually called the GIL, is CPython’s process-level execution lock for Python bytecode in the traditional build. It ensures that only one thread at a time executes Python code in a given interpreter. The GIL is not the same as Python’s threading API. Python can create many operating system threads. The restriction is that, in the normal CPython runtime, those threads do not run...
cpython python internals runtime concurrency
Deep Reads › CPython Internals › 5. Runtime Systems ›

47. Threads

47. Threads A thread is an operating system execution context inside a process. CPython exposes threads through the threading module and implements lower-level support through _thread , platform thread APIs, interpreter thread state, locks, condition variables, and GIL coordination. Threads let a Python program perform multiple activities concurrently inside one process. In traditional CPython, threads do not usually execute Python bytecode in parallel because of the GIL. They are still...
cpython python internals runtime concurrency
Deep Reads › CPython Internals › 6. Standard Library Interfaces to the Core ›

59. `multiprocessing`

59. multiprocessing The multiprocessing module provides process-based concurrency. It lets Python programs create child processes, communicate between them, share limited state, coordinate execution, and distribute work across CPU cores. For CPython internals, multiprocessing matters because it is the standard library answer to a central runtime constraint: ordinary Python threads in one traditional CPython interpreter are limited by the Global Interpreter Lock during bytecode execution. Separate processes have separate interpreters, separate...
cpython python internals concurrency