Knowledge Planet: Old Dock's Tech Chronicles Zhihu: SamDeepThinking A technical manager who still codes heavily on the front line. From junior developer to tech lead, then tech manager, now leading the whole front‑ and back‑end development team—leveling up along the way. I have some insights on programming, career development, and tech management.
This article demonstrates how Java's final keyword enables immutable objects that remove the need for synchronization in concurrent code, using a config hot-reload example that shows race conditions in mutable objects and zero errors with immutable design.
This article explains how Java's final keyword ensures cross-thread visibility of final fields through the JMM's freeze action at constructor end, provided the this reference does not escape during construction, demonstrating with a code example that shows a race condition when this escapes and the correct behavior when final fields are properly frozen.
This article introduces thread safety by explaining threads, shared memory, and thread switching, then demonstrates a race condition where a Java counter loses increments due to non-atomic count++, and shows how synchronized fixes it by serializing access.
This article traces the complete lifecycle of a Java thread from new Thread() through start() to sleep and interrupt, revealing how the JVM creates OS threads via C++ JavaThread and OSThread objects, and demonstrating the 1:1 thread model with executable verification code.
This article explains how the JVM handles threads that fail to acquire a synchronized lock, detailing the three-tier upgrade from lightweight CAS-based spinning to adaptive ObjectMonitor spinning and finally OS-level blocking, with Java 17's simplified lock states and Mark Word transitions.
This article demystifies Java's happens-before rules, showing why temporal order doesn't guarantee visibility, and how volatile combined with program order ensures a non-volatile variable's visibility across threads through a concrete code example.
This article explains Java memory barriers using a simple two-thread example, detailing how compiler reordering, CPU out-of-order execution, and cache inconsistency cause visibility issues, and shows how volatile and VarHandle provide acquire/release semantics to guarantee correct ordering in Java 17.
The article argues technical taste differs from coding ability; it's about making appropriate trade-offs for specific project contexts rather than applying best practices blindly, illustrated by examples like over-engineering a small internal tool with microservices or over-designing urgent projects. Good taste comes from extensive project experience and amplifies effectiveness in the AI era.
The article illustrates Separation of Concerns beyond AOP by refactoring a reconciliation service that mixes WeChat Pay and Alipay SDK calls with business logic, introducing a wrapper layer with custom types to isolate SDK-specific parsing from core matching rules, enabling independent evolution of each concern.
The article demonstrates how deep if nesting (over 3 levels) obscures bugs using a payment callback example where error messages are swapped, then refactors with guard clauses to flatten logic; it also addresses loop nesting by extracting methods to reduce cognitive load, emphasizing keeping conditions close to their handling.
