Run a mock round

Memory is divided into heap (shared objects) and per-thread stacks (frames, locals). The heap has a young generation (Eden plus two survivor spaces) and an old generation.

GC roots (stack references, statics, JNI references) mark reachable objects; everything else is collectible. Minor GC copies surviving young objects between survivor spaces and promotes long-lived ones to old gen. Major/full GC handles old gen and can pause the application.

Collectors: Serial, Parallel, G1 (default in recent JDKs, region-based with pause targets), ZGC and Shenandoah for very low pause times. Tuning knobs include heap size (-Xmx), pause goals (-XX:MaxGCPauseMillis) and region size. Diagnose with jstat, GC logs, JFR and heap dumps.

Dependency injection means a component receives its collaborators from outside rather than creating them itself. The Spring container builds and wires the object graph from annotations such as @Component, @Service and @Repository, injecting through constructor, setter or field.

@Service
public class OrderService {
  private final PaymentGateway gateway;
  public OrderService(PaymentGateway gateway) { this.gateway = gateway; }
}

Benefits: loose coupling, easier testing with mocks, centralised configuration and lifecycle management. Constructor injection is preferred because dependencies are explicit, objects can be immutable and missing beans fail fast at startup. Spring Boot adds auto-configuration and a starter-based dependency model.

• An interface declares a contract. It supports abstract methods plus default and static methods (Java 8+), private methods (Java 9+) and constants. A class can implement many interfaces.
• An abstract class is a partially implemented base class. It can hold state (fields), constructors and any mix of abstract and concrete methods. A class extends only one.

Choose an interface to define capabilities across unrelated types and to keep inheritance flexible. Choose an abstract class to share implementation and state among closely related subclasses.

• ArrayList: array-backed, O(1) random access, amortised O(1) append, O(n) insertion/removal in the middle. Best default for ordered lists.
• LinkedList: doubly linked, O(1) insertion/removal at the ends or given a node, O(n) random access and poor cache locality. Rarely the best choice in practice; ArrayDeque is preferred for queues.
• HashMap: hash table with average O(1) get/put, no ordering guarantee, one null key allowed. Collisions are handled with buckets that treeify to red-black trees past a threshold. Use LinkedHashMap for insertion order and TreeMap for sorted keys.

Other essentials: HashSet is a HashMap key set; ConcurrentHashMap for thread-safe maps; choose initial capacity and load factor to avoid rehashing.

A deadlock needs four conditions: mutual exclusion, hold-and-wait, no preemption and circular wait.

Classic case: thread A locks X then waits for Y while thread B locks Y then waits for X.

Prevention:

• Establish a global lock ordering and always acquire in that order.
• Use tryLock with a timeout and back off, or lock-free structures.
• Keep critical sections small and avoid calling external code while holding a lock.
• Prefer higher-level concurrency utilities (java.util.concurrent) over manual synchronized.
• Use immutable objects and message passing where possible.

Diagnose with thread dumps (jstack) and JConsole, which detect deadlock cycles.