What are the structural mechanics of standard Memoization, and what are its hidden thread-safety traps?

Memoization caches expensive calculations using the ||= operator. In multi-threaded environments, this pattern is susceptible to race conditions, leading to duplicate calculations.

The standard memoization pattern @result ||= calculate_expensive_thing checks if @result has a value; if not, it runs the computation and assigns it. However, this statement is not atomic. In a multi-threaded system, if two threads evaluate the expression simultaneously while @result is still nil, both threads will enter the calculate_expensive_thing block, leading to duplicate evaluations or inconsistent states. Furthermore, if the method validly returns false or nil, the calculation re-runs on every invocation.