Zalando technical round: Java, JVM and concurrency 9 questions in 4 chapters

The memory model defines when one thread's writes become visible to another. Without a happens-before edge, the compiler and CPU may reorder or cache values, so a thread can see stale or half-published data. Edges come from program order, unlocking then locking the same monitor, a volatile write then a read of it, starting and joining threads, and final fields set in a constructor.

I use a bounded ThreadPoolExecutor rather than unbounded factories. I pick core and maximum sizes from the work: near the core count for CPU-bound tasks, larger for blocking I/O, then confirm by measuring. A bounded queue gives backpressure, and a rejection policy says what happens when it is full. I shut it down in order and make tasks respond to interruption.

A read-write lock lets many readers proceed together while a writer gets exclusive access, so it helps when reads vastly outnumber writes and each read takes a while. Otherwise a plain lock is simpler and often faster. A blocking queue is the standard producer-consumer handoff: producers put, consumers take, and a bounded capacity gives you backpressure.

Immutable objects can be shared between threads without locks once they are safely published, and they make reasoning and caching easier. An unmodifiable view, like Collections.unmodifiableList, only blocks writes through that reference; if someone changes the backing list, the view changes too. An immutable copy, like List.copyOf, owns its data. To make a class immutable, copy mutable inputs and never expose them.

ArrayList gives constant-time index access and amortized constant-time append, but inserting in the middle shifts elements. LinkedList only wins when you already hold the position, and it has poor cache behaviour. HashMap gives expected constant-time get and put without order; TreeMap gives guaranteed log n and keeps keys sorted. Pick the contract you need, then check the cost.

A binary search tree finds a key in time proportional to its height. Insert sorted keys into a plain one and the height becomes n, so lookups turn linear. Balanced trees such as red-black trees keep the height logarithmic. Java's TreeMap is one, with guaranteed log n operations and sorted keys. I choose it when I need order or ranges, and HashMap otherwise.

A trie stores strings by shared prefix: each edge is a character, and a node marks where a word ends. Finding all words with a prefix costs the prefix length plus the nodes you visit, regardless of how many other words exist. The cost is memory, one node per character. For a compact read-only dictionary, search engines use finite-state transducers instead.

A hash set solves it in one pass with linear time and space. To use constant space, I find the rotation point with binary search, which is the index of the smallest element. Then I run the usual two-pointer search, starting at the smallest and the largest elements and moving the pointers around the array with modulo arithmetic. That keeps linear time and constant extra space.

Class loaders find class bytes and define classes. Java has three built-in ones: bootstrap for the core platform, platform for the rest of the Java SE modules, and the application loader for the class path. Each loader asks its parent first, so core classes cannot be replaced. ClassNotFoundException means an explicit lookup failed; NoClassDefFoundError means a class that existed at compile time is missing at run time.