skip to content
java.lang.everything
everything.glossary

glossary

285 terms, one line each. every one links to the chapter that explains it properly.

#

<clinit>
a class's static initializer: static fields and static blocks, run once on first active use. read more

a

ABA problem
a value goes A → B → A, and a CAS that only checks for A can't tell anything happened. read more
access order
a LinkedHashMap mode where every get moves the entry to the end, so the head is least recently used. read more
algebraic data type
data built from products (records: this and that) and sums (sealed interfaces: this or that). read more
amortized O(1)
constant on average over many calls, even though an occasional call (like a resize) costs O(n). read more
annotation
metadata on code. @Override, @Deprecated, or your own. read more
annotation processor
a plugin that runs inside javac, reads declarations and can generate new source files, in rounds. read more
AOT cache
Leyden's startup archive: classes already loaded and linked, plus method profiles, from a training run. java 24+. read more
AQS
AbstractQueuedSynchronizer: a volatile int plus a queue of parked threads. most j.u.c locks are built on it. read more
async-profiler
an open-source java profiler that samples at the real instruction via OS signals, so it avoids safepoint bias. read more
auto-vectorization
C2 turning a simple array loop into SIMD instructions by itself. it can't for float reductions, which is where the Vector API helps. read more
autoboxing
the compiler quietly converting int ↔ Integer for you. read more
AutoCloseable
the one-method interface that lets an object go in a try-with-resources. read more

b

BigDecimal
an exact decimal number: an unscaled BigInteger plus a scale. what money should be. read more
binary heap
a tree where every parent beats its children, stored level by level in an array. PriorityQueue. read more
bootstrap method
the method the JVM calls the first time an invokedynamic runs. it returns the CallSite the instruction is linked to. read more
bounded type parameter
<T extends Number>: callers may only pick Number or a subtype, and the code can call Number's methods on T. read more
branch prediction
the CPU guessing which way an if goes so its pipeline doesn't stall. random branches mispredict and cost time. read more
breakpoint
a line where the debugger pauses the program so you can look around. read more
bridge method
a synthetic method javac adds so overriding still works after erasure, like compareTo(Object) calling your compareTo(Name). read more
bucket
one slot of a hash table's array. keys whose hashes map to the same index share it. read more
bytecode
the instruction set of the JVM. what javac produces, what the JVM runs. read more

c

C1 / C2
the JVM's two JIT compilers. C1 compiles fast, C2 compiles well. read more
cache line
the unit memory moves in between RAM and the CPU caches, 64 bytes on most CPUs. read in order and the prefetcher keeps up. read more
canonical constructor
the record constructor that takes every component in order. the compact form validates without repeating the parameters or assignments. read more
carrier class
an exploratory generalization of records from amber's 2026 design note: a component list without records' restrictions. read more
carrier thread
the platform thread a virtual thread is currently mounted on. read more
CAS
compare-and-swap. an atomic cpu instruction: set it to B, but only if it's still A. read more
casting
converting between types. widening (int → long) is automatic, narrowing (long → int) needs a cast and can lose bits. read more
catastrophic backtracking
a regex that can match the same text many ways, making a failing match exponential. read more
CDS
class data sharing: parsed class metadata saved to an archive and mapped in at startup. read more
check-then-act
deciding on a value, then acting after it may already have changed. a race even when each call is thread-safe. read more
checked exception
an exception the compiler makes callers catch or declare. Exception, minus RuntimeException. read more
circular buffer
an array used as a ring: head and tail indexes wrap around, so nothing ever shifts. ArrayDeque. read more
class file
the binary file javac produces. starts with CAFEBABE. read more
class file version
the major version in a .class header. java version + 44, so java 25 is 69. read more
class loader
the object that finds a class's bytes and turns them into a Class. read more
class loader leak
one reference from long-lived code into an undeployed app keeps its class loader, and so every one of its classes, alive. read more
Class-File API
java.lang.classfile, java 24: parse, build and transform class files with elements, builders and transforms. read more
classpath
the list of folders and jars the JVM searches for classes. the current directory by default. read more
code reflection
project babylon's idea: a library reads a java method as a code model and transforms it, say into a GPU kernel. research, no JEP. read more
collector
a recipe for folding a stream into a result: a list, a map, a string. read more
common pool
the JVM-wide ForkJoinPool that every parallel stream shares. cores minus one threads. read more
compact object headers
an 8-byte object header with the class pointer folded into the mark word. product in 25, default in 27. read more
compact source file
a .java file with methods and fields but no class around them. java 25. read more
compact strings
since java 9 a String stores one byte per char when every char fits in latin-1, two otherwise. read more
CompletableFuture
a future you attach stages to (thenApply, thenCompose, allOf) instead of blocking on it. read more
composition
holding an object in a field and forwarding calls to it, instead of extending its class. read more
compressed oops
storing references in 32 bits by shifting 8-byte-aligned addresses. works for heaps up to about 32 GB. read more
condenser
leyden's long-term idea: a transformation that shifts work ahead of time in exchange for constraints you choose. a design note, not a feature. read more
constant pool
the numbered table of names, types and literals at the front of a class file. most of the file points into it. read more
constructor
the code new runs on a freshly zeroed object. same name as the class, no return type, never inherited. read more
continuation
a piece of code that can pause itself (yield) and be resumed later from the same spot. every virtual thread runs inside one. read more
coordinated omission
a load tool that waits for each response stops sending while the system is slow, so the slow period is never measured. read more
copy-on-write
every write copies the whole backing array, so readers iterate a stable snapshot with no locking. read more
covariant arrays
a String[] is an Object[], so every array store is checked at run time and can throw ArrayStoreException. read more
CRaC
coordinated restore at checkpoint: save a warmed-up JVM process to disk and restore it in milliseconds. vendor builds on linux, not mainline. read more

d

data-oriented programming
modelling data as immutable records under sealed interfaces, with behaviour in exhaustive pattern-matching switches. read more
dead code elimination
the JIT deleting work whose result nobody uses. the reason a timing loop can report 0 ns. read more
deadlock
two or more threads each waiting for a lock the other holds. forever. read more
default method
an interface method with a body. implementers get it unless they override it. java 8. read more
defensive copy
copying a mutable argument or return value so callers can't change your object's state behind its back. read more
deoptimization
the JVM throwing away compiled code when an assumption it made turns out wrong. read more
derived record creation
the proposed `record with { x = 0; }` expression: a copy of a record with some components changed. JEP 468, a candidate. read more
diamond problem
inheriting the same method from two places. java's rules: class wins, then the more specific interface, else you must override. read more
direct buffer
a ByteBuffer whose bytes live outside the heap, freed only when the GC collects its small heap object. capped by -XX:MaxDirectMemorySize. read more
dominance
a switch case that can never match because an earlier case always matches first. a compile error, not a warning. read more
dominator tree
a tree of objects where each parent is on every path from the GC roots to its children. sorted by retained size, it points at leaks. read more
downstream collector
a collector that runs inside each group of another, like counting() in groupingBy. read more
DST gap
local times that never happen when clocks jump forward. java shifts them forward. read more
dynamic constant
a constant pool entry computed by a bootstrap method on first ldc, then cached. java 11, JEP 309. read more
dynamic dispatch
picking which override to run at runtime, from the object's actual class. read more
dynamic proxy
an object generated at runtime that implements given interfaces and sends every call to one InvocationHandler. read more

e

effectively final
a local that's never reassigned after it's set. the only kind a lambda may capture. read more
enum
a final class with a fixed set of singleton instances, one per constant, created at class init. read more
EnumSet
a set of enum constants stored as bits in a long, one bit per ordinal. read more
escape analysis
the JIT proving an object never leaves a method, so it doesn't need the heap. read more
exception chaining
wrapping a lower-level exception as the cause of a new one, so the log keeps the root. read more
exception table
per-method rows of from, to, target, type in the class file. how the JVM finds a catch. read more
exhaustive switch
a switch that covers every possible input. pattern switches must be; over a sealed type, a case per subtype is enough. read more
expression problem
classes make new types easy and new operations hard; switches over sealed data make it the other way around. read more

f

fail-fast
iterators that throw ConcurrentModificationException when the collection changes under them. read more
false sharing
two threads writing different variables that share a cpu cache line, slowing each other down. read more
FFM
the foreign function and memory api. call C and manage off-heap memory from java. read more
field hiding
a subclass field with the same name as a parent's. both exist in the object; the variable's declared type picks one. read more
flame graph
all sampled stacks merged into one picture: width is share of samples, height is call depth. the x axis is not time. read more
flatMap
turns each element into a stream of zero or more elements and splices them into one stream. read more
flattening
storing a value object's fields directly inside an array or field instead of a pointer to a separate object. valhalla's payoff. read more
flexible constructor bodies
statements before super(...) or this(...): validate, prepare arguments and set your own fields before the superclass runs. java 25. read more
flow scoping
a pattern variable exists exactly where the compiler can prove the match succeeded, even after if (!(o instanceof T t)) return; read more
fragile base class
a subclass breaking when its superclass changes, because overriding couples it to the parent's implementation. read more
fully qualified name
a class's real name, package included: java.util.ArrayList. imports are just shorthand for it. read more
functional interface
an interface with exactly one abstract method. lambdas target these. read more

g

G1
the garbage-first collector. region-based, the default since java 9. read more
garbage collection
finding objects nothing can reach anymore, and reusing their memory. read more
gatherer
a custom intermediate stream operation. java 24. read more
GC overhead limit
Parallel GC's rule: more than 98% of time in GC while freeing under 2% of the heap throws OutOfMemoryError: GC overhead limit exceeded. read more
GC root
a starting point for reachability: locals on stacks, statics, JNI handles. read more
generational hypothesis
most objects die young. the reason heaps are split into young and old. read more
generics
type parameters like List<String>. checked at compile time, erased at runtime. read more
guard
a when clause on a switch case: case Integer i when i > 0. the case only matches if the pattern and the condition both hold. read more

h

handshake
a JVM operation that stops just one thread at its next poll instead of all of them. java 10. read more
happens-before
the memory model's guarantee that one action's effects are visible to another. read more
hash collision
two different keys landing in the same bucket. guaranteed to happen; the table chains them. read more
hashCode
an int summary of an object. equal objects must have equal hash codes. read more
heap
the shared memory where every object lives. cleaned up by the garbage collector. read more
heap dump
a snapshot of every object in the heap and every reference between them, in an .hprof file. how you find leaks. read more
heap pollution
a variable of a parameterized type pointing at an object that isn't that type. caused by raw types, unchecked casts, generic varargs. read more
helpful NullPointerException
since java 14, NPE messages name exactly what was null. read more

i

identity
the starting value of a reduction, one that changes nothing: 0 for +, 1 for *. read more
IEEE 754
the binary floating-point standard behind float and double. why 0.1 + 0.2 != 0.3. read more
immutable
can't change after construction. String, Integer, records (shallowly). read more
incubator module
an early, changeable API in a jdk.incubator.* module, enabled with --add-modules. the vector API has been one since java 16. read more
inlining
the JIT pasting a called method's body into the caller. the mother of all optimizations. read more
instance initializer
a bare { } block in a class body. javac pastes it into every constructor that calls super(...). read more
instance main method
a main that isn't static. the launcher creates the object first. java 25. read more
integer cache
Integer.valueOf reuses objects for -128..127, which is why == works there and nowhere else. read more
integer overflow
int or long math that doesn't fit wraps around silently. Integer.MAX_VALUE + 1 is Integer.MIN_VALUE. read more
integrator
the part of a gatherer that sees each element, pushes results downstream and can stop the stream. read more
interface
a type that only describes what something can do. can have default methods since java 8. read more
intermediate operation
a lazy stream step like filter or map. it only adds a stage, no work happens yet. read more
intrinsic
a JDK method the JIT replaces with hand-written machine code, like System.arraycopy or Integer.bitCount. read more
invariance
List<Integer> is not a List<Number>, even though Integer is a Number. generics are invariant, arrays are covariant. read more
invokedynamic
a bytecode whose call target is decided at runtime by a bootstrap method. read more
IO.println
java.lang.IO: println, print and readln for simple console programs, in every file without an import. java 25. read more
itable
a per-class table of method pointers grouped by interface, used by invokeinterface. read more

j

jagged array
a 2d array whose rows have different lengths. possible because int[][] is an array of separate arrays. read more
java memory model
the rules (JLS 17.4) for when one thread's writes are guaranteed visible to another. read more
JAVA_HOME
an environment variable pointing at one JDK's folder. build tools and IDEs read it, your shell doesn't. read more
javac
the java compiler. .java in, .class out. read more
javap
the JDK's class file disassembler. javap -c shows the bytecode javac produced. read more
jcstress
the OpenJDK harness that runs tiny concurrent programs billions of times and counts every outcome. read more
JDK
java development kit. the JVM plus javac, jar, jshell and the rest of the tools. read more
JDK distribution
one vendor's build of OpenJDK. same code, different support, patches and license. read more
JDWP
java debug wire protocol. how a debugger talks to a running JVM over a socket. read more
JEP
JDK enhancement proposal: the document that tracks a feature from draft to candidate, targeted, integrated and delivered. read more
JFR
java flight recorder. a low-overhead event recorder built into the JVM. read more
JIT
just-in-time compiler. turns hot bytecode into native machine code while the program runs. read more
JMH
the java microbenchmark harness. the only sane way to benchmark small code. read more
JNI
the java native interface: native methods implemented in C against JNIEnv, loaded with System.loadLibrary. read more
joiner
the policy object of a StructuredTaskScope: when join() returns, what it returns, and what it throws. read more
JRE
java runtime environment. the JVM plus the standard library, without the dev tools. mostly historical now. read more
jshell
java's REPL. type a snippet, see its value, no class or main needed. java 9. read more
JVM
the java virtual machine. a program that runs bytecode on any OS. read more

l

labeled break
break outer; jumps out of the loop labelled outer, even from inside a nested loop. read more
lambda
an anonymous function. compiled with invokedynamic, not anonymous classes. read more
lazy constant
a value computed at most once, on first use, then treated like a constant. LazyConstant, preview in 27 (was StableValue in 25). read more
lightweight locking
HotSpot's uncontended lock: one CAS on the mark word's lock bits plus a push on the thread's lock stack. read more
livelock
threads that keep reacting to each other and never make progress, while staying busy. read more
load factor
how full a HashMap may get before it doubles. 0.75 by default. read more
local variable type inference
var: the compiler infers a local's type from its initializer. still statically typed. java 10. read more
lock inflation
turning a contended or waited-on lock into a full ObjectMonitor with entry and wait queues. read more
logging facade
an API like SLF4J or System.Logger that code logs through, with the backend chosen by the app. read more
LongAdder
a counter that spreads contended updates over padded cells and adds them up in sum(). read more
lost update
two threads write results computed from the same old value, so one write erases the other. read more
LRU cache
a cache that evicts the least recently used entry. a LinkedHashMap in access order plus removeEldestEntry. read more
LTS
long-term support. every 2 years a release gets years of updates. 21 and 25 are LTS. read more

m

mark word
the first header word of every object: hash, lock state, GC age. read more
MatchException
thrown when a pattern can't be decided at run time: an accessor threw, or a sealed hierarchy grew after the switch was compiled. read more
MaxRAMPercentage
the default max heap as a share of the memory the JVM sees: 25%, or the container's limit inside a container. read more
megamorphic call site
a virtual call that has seen three or more receiver classes. C2 stops inlining it. read more
MemorySegment
the FFM API's bounded, checked view of memory, on or off the heap, freed when its Arena closes. read more
meta-annotation
an annotation on an annotation type: @Retention, @Target, @Documented, @Inherited, @Repeatable. read more
metaspace
native memory where the JVM keeps class metadata. replaced permgen in java 8. read more
method overriding
a subclass replacing an inherited method with the same signature. the object's class picks which runs, at runtime. read more
method reference
a lambda that just calls one existing method, written as Class::method or expr::method. read more
MethodHandle
a typed, directly callable reference to a method, constructor or field, found once through a Lookup. read more
modCount
a counter every structural change bumps. iterators compare it to detect changes behind their back. read more
module
a named group of packages with explicit exports and requires. java 9. read more
module import declaration
import module java.base; imports every public type in every package a module exports. java 25, allowed in any file. read more
monitor
the lock every java object carries. what synchronized grabs. read more
mutable key
a hash map key or set element whose hashCode changes after insertion. the entry stays in the old bucket and can't be found or removed. read more
mutable reduction
folding a stream into a container that each chunk fills privately. what collect does. read more

n

NaN
not a number: what 0.0 / 0.0 gives. the only value not equal to itself, so test with Double.isNaN. read more
native memory tracking
a JVM feature that breaks the process's non-heap memory down by category. -XX:NativeMemoryTracking=summary, then jcmd VM.native_memory. read more
nestmates
classes from one source file that may use each other's private members directly. java 11, JEP 181. read more
null-restricted type
a type that can't hold null, written Foo! in valhalla's draft JEPs. lets the JVM drop the null flag and flatten more. read more

o

on-stack replacement
swapping a long-running loop from the interpreter into compiled code while it runs. the % in PrintCompilation. read more
OOMKilled
the kernel killing a process for exceeding its container's memory limit: exit code 137, no OutOfMemoryError. read more
OpenJDK
the open-source project the JDK is built from. temurin, corretto, oracle's JDK: all builds of it. read more
operand stack
the per-frame stack that bytecode instructions push to and pop from. the JVM's scratchpad, next to the local variable array. read more
operator precedence
which operators bind tighter, like * before +. it shapes the expression tree, not the evaluation order. read more
Optional
a box that holds one value or nothing. a return type for maybe-no-result. read more
OutOfMemoryError
thrown when the JVM can't get memory it needs. there are like seven kinds. read more
overloading
several methods with the same name and different parameter lists. the compiler picks one from the argument types. read more

p

package-private
the access you get with no modifier: visible to the same package, nobody else. read more
parent delegation
a class loader asks its parent first and only looks itself when the parent comes back empty. read more
pass-by-value
java copies the value of every argument. for objects, the value is the reference. read more
pattern matching
testing a value's shape and pulling it apart in one step. read more
PECS
producer extends, consumer super. how to pick between ? extends and ? super. read more
percentile
the latency that a given share of requests stay under. p99 = 99% were faster. report p50, p99, p99.9 and max, not the mean. read more
pinning
a virtual thread stuck to its carrier, unable to unmount while blocked. read more
pointer chasing
walking a structure where each element holds the address of the next, so every load waits for the previous one. why linked lists are slow. read more
polymorphism
one call site, different behaviour depending on the object's runtime class. read more
preview feature
a finished-but-not-final feature you can try with --enable-preview. read more
primitive
one of the 8 non-object types: byte, short, int, long, float, double, char, boolean. read more
primitive patterns
patterns, instanceof and switch for primitive types, matching only exact conversions: 1000 instanceof byte is false. preview in 27. read more
primitive stream
IntStream, LongStream or DoubleStream: a stream of raw numbers, no boxing. read more
protected
package-private plus subclasses in other packages, which may only use it through their own type. read more

r

race condition
a bug where the result depends on how threads happen to interleave. read more
raw type
a generic type used without type arguments, like List instead of List<String>. compiles for old code, switches the type checks off. read more
record
a class that's just its data. constructor, accessors, equals, hashCode and toString for free. read more
record pattern
a pattern that matches a record and takes it apart into its components by calling the accessors: Point(int x, int y). they nest. read more
recursion
a method calling itself. needs a base case. java never optimizes tail calls, so deep recursion overflows the stack. read more
red-black tree
a self-balancing binary search tree. recolors and rotates on insert so its height stays O(log n). TreeMap. read more
reentrancy
a thread that owns a lock can acquire it again. a hold count tracks how deep it is. read more
reference
a value that points at an object on the heap. never the object itself. read more
reflection
inspecting and calling classes, fields and methods at runtime by name. read more
rejection policy
what a saturated ThreadPoolExecutor does with a new task: throw, run it in the caller, or drop something. read more
restricted method
a method that can break java's safety, like System.loadLibrary or Linker.downcallHandle. warns unless native access is enabled. read more
retained size
what would become garbage if one object disappeared: itself plus everything reachable only through it. read more
retention policy
how long an annotation survives: SOURCE (javac only), CLASS (in the class file, the default) or RUNTIME (visible to reflection). read more
RSS
resident set size: memory pages actually in RAM. what top and container limits count, and always more than -Xmx. read more

s

safe publication
handing an object to another thread through a happens-before edge, so it sees it fully built. read more
safepoint
a point where a thread can be safely paused so the JVM can do global work. read more
safepoint bias
a profiler that can only sample at safepoint polls credits time in poll-free code to whatever runs after it. read more
scalar replacement
C2 skipping an allocation entirely and keeping a non-escaping object's fields in registers. read more
scoped value
an immutable value bound for the duration of a call. the ThreadLocal replacement, final in java 25. read more
scratch variable
the $1, $2... name jshell gives a result you didn't name. read more
sealed
a class or interface that lists exactly who may extend it. read more
self-invocation
a bean calling its own method through this, which bypasses the proxy and so skips @Transactional and friends. read more
semaphore
a counter of permits. acquire takes one or waits, release gives one back. limits concurrency. read more
sequenced collection
a collection with a defined first and last element: getFirst, getLast, reversed. java 21. read more
ServiceLoader
finds implementations of an interface on the class or module path through META-INF/services or provides/uses. read more
short-circuit evaluation
&& and || skip the right side when the left side already decides the answer. read more
short-circuiting
a stream operation that can finish without seeing every element: limit, findFirst, anyMatch. read more
Signature attribute
where a class file keeps generic types of classes, fields and methods after erasure. reflection reads it. read more
signature polymorphic
a method like invokeExact whose call sites each get their own descriptor from the argument and cast types. read more
SIMD
single instruction, multiple data: one CPU instruction working on a whole vector of numbers. what the vector API exposes. read more
source launcher
java Main.java: compiles the file in memory and runs it, no .class on disk. java 11, multi-file in 22. read more
spliterator
the iterator a stream's source provides. it can split itself in half for parallel work. read more
spurious wakeup
wait() returning with no notify at all. the reason wait always goes in a while loop. read more
stable sort
a sort that keeps equal elements in their original order. java's object sort is stable. read more
stack chunk
the heap object a parked virtual thread's frames are copied into (freeze) and copied back out of (thaw). read more
stack frame
the chunk of the thread's stack a method call gets for its locals and operands. read more
stack trace
the call stack when an exception was thrown, newest call first. read more
stack unwinding
popping frames one by one after a throw, running finally blocks, until a catch matches. read more
stateful operation
an intermediate op that remembers earlier elements: distinct, sorted, limit, skip. read more
static initializer
a static { } block. runs once, when the class is initialized, collected with static field initializers into <clinit>. read more
stop-the-world
a pause where every application thread is frozen so the GC can work. read more
store buffer
a per-core queue where writes wait before reaching the cache. why the impossible r1 = r2 = 0 happens. read more
stream
a lazy pipeline over a source. nothing runs until a terminal operation. read more
string pool
the JVM's table of interned strings. every literal lives there once. read more
StringBuilder
a growable byte[] for building text. grows as old * 2 + 2, so appends are amortized O(1). read more
strong encapsulation
since java 17 the JDK's private members are closed to reflection. setAccessible throws unless the package is opened. read more
structured concurrency
subtasks confined to a block: forked inside it, all finished when it ends, cancelled together. read more
super type token
an anonymous subclass like new TypeRef<List<String>>() {} that captures a full generic type at run time. read more
suppressed exception
a close() failure attached to the body's exception instead of replacing it. getSuppressed(). read more
switch expression
a switch with case X -> arms that produces a value. no fallthrough, and it must cover every input. java 14. read more

t

target type
the functional interface a lambda becomes, decided by where it's written: assignment, argument or cast. read more
terminal operation
the stream step that pulls elements through and produces a result: toList, count, forEach. read more
text block
a multi-line string in triple quotes. java strips the indentation your code added. java 15. read more
this$0
the hidden field an inner class uses to reach the outer object that created it. a classic memory leak. read more
thread
an independent path of execution with its own stack. read more
thread pool
a fixed crew of threads that pull tasks off a queue. read more
tiered compilation
running code at levels 0 to 4: interpreter, three flavours of C1, then C2, climbing as it gets hotter. read more
time to safepoint
how long the JVM waits for every running thread to reach a poll before a global pause can start. read more
TimSort
the stable merge sort java uses for objects. finds runs that are already sorted and merges them. read more
TLAB
thread-local allocation buffer. each thread's private slice of eden for fast allocation. read more
training run
a normal run of your app that records what it loads, links, profiles and compiles, so an AOT cache can give later runs a head start. read more
treeification
a HashMap bucket turning from a linked list into a red-black tree after 8 collisions. read more
two's complement
how integers store negative numbers: flip the bits and add 1. why the range is -128 to 127. read more
type erasure
the compiler removing generic type arguments after checking them. read more
type inference
javac working out a generic call's type arguments from the arguments and the target type. read more
type parameter
the T in class Box<T>: a placeholder type. the String in Box<String> is the type argument. read more
type token
a Class<T> passed in so generic code has a real type to check and cast with at run time. read more

u

unchecked exception
RuntimeException, Error and their subclasses. nobody is forced to catch them. read more
unchecked warning
javac telling you it can't verify a generic operation, so a cast it inserted elsewhere might fail at run time. read more
uncommon trap
the exit C2 compiles in for cases its profile said never happen. hitting one deoptimizes the method. read more
unified logging
the JVM's -Xlog system (java 9): pick tags and levels, an output and decorators. GC logs are -Xlog:gc*. read more
unmodifiable view
a read-only wrapper around a collection. blocks writes through itself, but shows changes to the original. read more
unnamed variable
_ for a pattern, lambda parameter, catch variable or loop variable you have to declare but never use. java 22. read more

v

value object
an object without identity, so the JVM can flatten it. valhalla. read more
varargs
a T... parameter that accepts any number of arguments, delivered to the method as an array. read more
VarHandle
a handle to a field or array slot with CAS and per-access memory ordering: plain, opaque, acquire/release, volatile. read more
virtual thread
a cheap thread managed by the JVM, mounted on a platform thread only while running. read more
volatile
a field whose writes are immediately visible to other threads, and never reordered around. read more
vtable
a per-class table of method pointers the JVM uses for fast virtual calls. read more

w

warmup
the first calls of a method run interpreted or lightly compiled. benchmarks discard them before measuring. read more
wildcard
? in a type argument: List<?>, List<? extends T> (read only) or List<? super T> (write only). read more
wildcard capture
javac naming the unknown type behind a ? (CAP#1 in errors). a generic helper method can capture it as a real T. read more
work stealing
idle workers take tasks from the far end of busy workers' deques. how ForkJoinPool balances load. read more
wrapper class
the object version of a primitive: Integer for int, Long for long, and so on. read more

z

ZGC
a concurrent collector with sub-millisecond pauses, using colored pointers. read more