38 docs tagged with "concurrency"

A comprehensive, detailed list of tricky and real-world Java Multithreading interview questions for experienced developers (2–7 years).

Real interview questions and practical Java answers from an Accenture first-round discussion.

A senior deep dive into the JVM's AbstractQueuedSynchronizer: exploring the CLH queue, LockSupport.park(), and CAS state transitions in ReentrantLock.

Comprehensive Lambda study guide for DVA-C02. Covers invocation types, concurrency, cold starts, event source mappings, layers, container images, environment variables, VPC integration, destinations, and Java handler patterns.

Full coverage of Java concurrency: platform threads, virtual threads (Java 21), Runnable vs Callable, ExecutorService, Future, atomic classes, synchronized, ReentrantLock, volatile, concurrent collections, deadlock, and parallel streams — with real-world thread-safety traps.

Functional programming's core discipline — immutability — eliminates entire classes of concurrency bugs. Learn how immutability, segregation of mutability, and event sourcing shape modern system design.

A beginner-friendly guide explaining the difference between concurrency and parallelism, using real-world analogies, visual diagrams, and Java code examples.

Master engineering guide to the 16 core concurrency concepts: Processes vs Threads, Race Conditions, Mutexes, Deadlocks (Coffman), CAS, Thread Pools (Little's Law), Event Loops, Database Pessimistic/Optimistic Locks, Distributed Locks, and Fencing Tokens.

A comprehensive architectural guide to Synchronous vs Asynchronous, Blocking vs Non-blocking (the 2x2 Matrix), Concurrency vs Parallelism, and Asynchronous vs Multi-threading execution models.

Concurrent collection fundamentals and ConcurrentHashMap internals for interview preparation.

Advanced concurrent collection interview topics including modCount behavior and CopyOnWriteArrayList usage.

A deep-dive guide to ACID properties — Atomicity, Consistency, Isolation, Durability — covering isolation levels, MVCC, 2PL, WAL, write skew, distributed ACID, and practical interview questions. Includes the real priority order (I → C → D → A), the AI PR story, and the link to the full isolation levels deep-dive.

Deep-dive into all 5 isolation anomalies (dirty read, non-repeatable, phantom, lost update, write skew), the 4 standard isolation levels, PostgreSQL vs MySQL vs Oracle implementation differences, snapshot scope (per-statement vs per-transaction), practical fix strategies without raising isolation, and the spec vs implementation distinction.

Deep-dive into core banking debit posting — ledger mechanics, memo vs. hard post, balance contention, idempotency, locking strategies, saga compensation, and production Java/Spring implementation patterns.

A comprehensive guide covering real technical interview questions and answers from a Deloitte Java Developer interview (4 years experience). Covers Core Java, Concurrency, Spring Boot, Microservices, and System Design.

Notes from the freeCodeCamp course on designing systems like a senior engineer. Covers the 5-step framework, tradeoff discussion, and a full Booking.com-style hotel reservation design (idempotency, double-booking, sharding, search, multi-region).

Strategies for dealing with race conditions, concurrent writes, hot spots, and lock contention in distributed systems including optimistic locking, MVCC, distributed locks, and queue-based serialization.

Deep dive into high-concurrency inventory reservation architectures — why Redis dual-writes cause overselling and underselling, how MySQL 8 SKIP LOCKED eliminates row contention, and how Shopify scaled to $5.1M GMV/minute during Black Friday.

Comprehensive guide to Java concurrency, covering concurrent utilities, thread pools, the Fork/Join framework, and async programming.

Comprehensive answers to Java Multithreading and Concurrency interview questions.

Deep dive into Java locks and synchronization primitives — synchronized, volatile, ReentrantLock, ReadWriteLock, StampedLock, AQS, CountDownLatch, CyclicBarrier, Semaphore, Exchanger, and Phaser.

Covers the Java Memory Model (JMM), Happens-Before relationships, instruction reordering, StampedLock optimistic locking, and ThreadLocal internals.

Senior-level Java multithreading interview questions covering threading models, OS context switching, thread lifecycle, and HotSpot JVM native integration.

A complete guide to threads, processes, lifecycles, and basic thread coordination (join, interrupt, daemon threads) in Java.

Comprehensive principal engineering guide to the LMAX Disruptor pattern, lock-free circular ring buffers, power-of-two bitwise indexing, sequence barriers, wait strategies, and sub-microsecond trading benchmarks.

Comprehensive principal engineering guide to lock-free vs wait-free data structures, hardware CMPXCHG instructions, ABA problem resolution with AtomicStampedReference, and Java 9 VarHandle memory ordering modes.

Comprehensive senior architectural guide to on-us transaction mechanics, direct ledger book transfers, lexicographical lock ordering to prevent deadlocks, cross-shard 2PC, and card scheme bypass routing.

Exhaustive analysis of the 5 lock types: version column, SELECT FOR UPDATE, advisory locks, lock columns, and Redis locks; physical lifespans, failure modes, and why optimistic retry storms crush high-contention ticketing systems.

Deep-dive into the Confluent Parallel Consumer model (now unmaintained), its internals, ordering modes, offset bitmap mechanics, and practical migration paths — Spring Boot virtual threads, manual executor dispatch, and the upcoming Kafka Share Groups (KIP-932).

A complete guide to processes and threads — memory layout, lifecycles, IPC, threading models, context switching, Java concurrency, virtual threads, thread pool tuning, memory visibility, and production patterns. Beginner through senior depth.

A comprehensive list of technical interview questions and answers from a real PwC Java Developer interview for a candidate with 3 years of experience. Covers Concurrency, Spring Boot, Microservices, and Database Locking.

Deep dive into Redis Lua script execution: solving data corruption between batch imports and point updates, production-grade distributed lock release, Redis TIME as a monotonic cluster clock, cooperative pod handovers, and the network RTT math.

Master senior-level resilience patterns for mission-critical distributed systems — Idempotency engines, Two-Phase Reservation (TCC) with timeout reapers, Virtual Waiting Rooms, Adaptive Concurrency Limits, Bulkheading, and Fenced Distributed Sagas.

Race conditions, critical sections, mutexes, semaphores, monitors, classic synchronization problems, deadlock detection/prevention, and Java concurrency utilities.

A comprehensive deep dive into Java thread pools, Netty's event loop model, Tomcat's connector architecture, HikariCP connection pooling, and how they all relate in a Spring Boot application.

ACID properties, isolation levels, locking mechanisms, MVCC, deadlocks, and optimistic vs pessimistic concurrency.

A comprehensive deep dive into Java 21 Virtual Threads, Carrier Threads, continuations, and avoiding synchronized pinning for senior engineers.

Deep dive into MySQL InnoDB storage engine locking mechanics: why two users updating distinct draft carts trigger Deadlock 1213, decoding the 3 access paths of a WHERE clause, and why READ COMMITTED won't save you.