30 câu hỏi OS/JVM runtime

Program là executable/static code; process là running instance với PID, address space, credentials, FDs, threads và kernel state. exec thay program image trong process.

Thường copy page tables/mappings với copy-on-write; physical page copy khi write. Kernel/runtime metadata vẫn có cost.

Child chỉ có calling thread nhưng locks có thể ở trạng thái owner biến mất; trước exec chỉ async-signal-safe operations.

Minimal exit status/accounting/PID entry chờ parent wait; không giữ normal heap/FD. Nhiều zombie exhaust process table/PIDs.

Virtual mapped range; resident pages with shared double-count; proportional shared allocation. Không cái nào riêng lẻ là heap/live data.

Minor resolve không disk I/O, major cần load backing storage. Faults normal; rates/latency/working set determine impact.

Allocator arenas/cache, fragmentation, page cache/shared mappings or runtime retention; free to allocator không đảm bảo return kernel.

Kernel/cgroup kills process vs JVM throws error on managed/native allocation path. Inspect cgroup events/exit/kernel and JVM evidence.

Writes dirty pages, including allocator/runtime/GC activity after fork; large managed runtimes can lose sharing quickly.

File/anonymous/shared/private mappings, memory-mapped I/O and allocation; page faults, synchronization, durability and address-space lifecycle apply.

Threads share VM/files/handlers but have TID, registers, stack, scheduler state, signal mask and TLS; processes have stronger isolation.

Often create/communicate cheaper, but stacks/tasks/context switches and shared-state correctness cost remain; measure workload.

Block/yield vs scheduler preemption. Counts need reason and workload; cache/locality cost varies.

Runnable queue or uninterruptible I/O tasks; quota/throttling and D-state can raise load without host CPU saturation.

No; scheduling class/weight only CPU competition, locks/I/O/IRQ/quota and system pressure still dominate.

Locality/isolation vs reduced balancing/hotspots/NUMA mistakes. Use measured reason and cpuset/container awareness.

Fast user-space atomic path plus kernel wait/wake on contention; primitive under many locks/conditions, not complete mutex protocol alone.

Spurious wakeups and predicate can change before lock reacquire; always recheck condition under mutex.

Shared memory low-copy/high throughput but synchronization/crash/layout complexity; sockets isolate/frame/backpressure and work across hosts.

Wait cycle/no progress, active reactions/no progress, and one task denied progress. Evidence and mitigations differ.

FD per-process index; multiple FDs/processes may reference shared kernel open description with offset/status. FD flags can be per descriptor.

Per-process descriptor limit vs system-wide open file table exhaustion.

Operation may make progress, not full read/write guarantee; edge-trigger must drain until EAGAIN and handle races.

TERM handleable for drain/cleanup; KILL immediate kernel termination. Grace deadline usually escalates TERM→KILL.

Namespace init must reap orphans and signal behavior differs; exec entrypoint/minimal init and process-tree shutdown tests.

cpu.max quota exhaust causes throttled intervals even if host has spare CPU elsewhere; inspect cpu.stat/PSI and latency.

Not necessarily; JVM RUNNABLE may be native socket/I/O. Map per-thread CPU and stacks over time.

Reduces platform-thread scarcity for blocking concurrency, but downstream/CPU/memory must be bounded; semaphore/rate controls still needed.

Heap, metaspace, code cache, stacks, GC/JIT structures, direct/JNI/native/mmap/shared libraries and allocator state.

Impact/time/scope → host+cgroup CPU/run queue/throttle → process/TID → sampled Java/native stacks → correlate load/release → bounded mitigation → SLI verification.