1 views collected around this technical thread.
This article explains how to create three Java threads that print the characters A, B, and C in strict order, repeat the sequence twenty times, and demonstrates three implementations—unordered printing, ordered printing with Semaphore, and a looped version—complete with full source code examples.
This article explains how to perform HTTP load testing using Postman, Apache Bench, JMeter, and Java concurrency classes such as CountDownLatch and Semaphore, providing step‑by‑step setup, configuration, and code examples for simulating high‑traffic scenarios.
This article explains Java's Semaphore concurrency primitive, its core methods, fair vs. non‑fair modes, typical scenarios such as rate limiting and resource pooling, and provides two complete code examples demonstrating thread coordination and download throttling.
The article explains how Hystrix uses thread‑pool and semaphore isolation to prevent cascading failures in microservice architectures, detailing implementation, configuration defaults, suitable scenarios, and recommendations for building resilient distributed systems.
This comprehensive guide explores why locks are essential in concurrent programming, explains the principles behind mutexes, semaphores, read‑write locks, and re‑entrant locks, provides Python code examples, discusses common pitfalls like deadlocks, and offers best‑practice strategies for production environments.
This tutorial explains how to containerize a simple Go web application with Docker, set up a development workflow using Docker and Bee, build and run images, and automate continuous integration and deployment with Semaphore, covering prerequisites, Dockerfile creation, testing, and production deployment steps.
This article explains how to print numbers from 1 to 100 with two Java threads—one handling odd numbers and the other even numbers—by first using a synchronized block with wait/notify and then by employing Semaphore for thread coordination.
This article explains how to use Python's asyncio library to synchronize and communicate between coroutines, covering Event, Lock, Semaphore, Condition, and Queue primitives with clear code examples demonstrating each mechanism in practice.
This article provides a comprehensive overview of Linux thread synchronization, explaining core concepts such as mutexes, condition variables, semaphores, and futexes, describing their implementation details, code examples, and common usage scenarios like producer‑consumer and reader‑writer problems.
This article explains how a PHP script uses a named semaphore for process mutual exclusion, demonstrates why a second concurrent process can acquire the semaphore after the first finishes, and clarifies that PHP automatically releases held semaphores when a process terminates.
This article details how a large‑scale lottery service was architected and tuned for extreme traffic spikes by applying server‑side rate limiting, application‑level throttling, behavior‑based filtering, caching strategies, database optimizations, and hardware upgrades, resulting in a ten‑fold performance improvement.
The article systematically explains Linux kernel synchronization primitives—from basic atomic operations through queued spinlocks, counting semaphores, and sleeping mutexes to read‑write semaphores and per‑CPU variants—detailing their underlying data structures, memory‑barrier semantics, and the fast‑path and slow‑path acquisition and release APIs.
This article explains essential techniques for managing concurrent access and race conditions in PHP, covering mutex locks, semaphores, atomic operations, queue-based processing, database access optimization, and transaction management to improve system reliability and performance.
This article explains how to create three Java threads that print the characters A, B, and C in order, first without synchronization, then using Semaphore for ordered output, and finally extending the solution to repeat the ABC sequence twenty times.
This article shares a detailed account of a Tencent testing engineer interview, covering self‑introduction, Go knowledge, Redis performance, distributed lock implementation, semaphore mechanics, RPC vs HTTP, concurrency usage, Git security practices, Linux commands, and a few brain‑teaser and algorithm questions.
This article introduces the four essential Java concurrency utilities—CountDownLatch, CyclicBarrier, Semaphore, and Exchanger—explaining their functions, underlying principles, typical usage patterns, and practical scenarios such as thread synchronization, resource limiting, and data exchange in multithreaded applications.
The article explains how Redis cache expiration can cause a cache avalanche, describes typical scenarios, and presents mitigation techniques such as semaphore-based rate limiting and fault tolerance, accompanied by a Java service example demonstrating lock, semaphore, and cache handling.
The article explains how Redis cache expiration can cause a request avalanche that overloads databases, and presents mitigation techniques such as semaphore rate limiting, per‑key locking, fault‑tolerant cache rebuilding, and example Java code using Spring and Redis.
This article provides a comprehensive overview of Java's core concurrency utilities—CyclicBarrier, CountDownLatch, Semaphore, and Exchanger—explaining their purposes, internal mechanisms, constructors, usage patterns, and code examples to help developers master multithreaded programming.
This article explains three Java concurrency tools - CountDownLatch, CyclicBarrier, and Semaphore - detailing their mechanisms, source code analysis, and practical usage scenarios with code examples.