99 Resources
Keywords: Java Books, JVM Tools, Profiling, Benchmarking, NIO, Concurrency, Reflection, Class Loading, Event Loops, Backpressure, Official Docs, Specs, RFCs, Mechanical Sympathy, Production Debugging, Performance Engineering
This page is the reference backbone of the Exploring Java Libraries wiki.
It exists for one reason:
to collect the highest-value books, tools, specifications, papers, and practical references in one place.
The rest of the wiki explains the system.
This page supports it.
Use this page when you need to:
- verify a concept against official documentation
- choose the right profiling or benchmarking tool
- revisit a book or manual that deepens your understanding
- connect theory to production-grade practice
- find the right reference before making an architectural decision
This is not a random bookmark list.
It is a curated engineering reference layer for the entire Exploring Java Libraries system.
Use the resources in this order depending on your need:
Start with the books and official documentation.
Jump to JVM tools, profilers, heap analyzers, and diagnostics.
Use the specs, papers, and low-level references.
Use the performance tools, benchmarks, and observability references.
A good workflow is:
Understand the concept
→ Verify with official docs
→ Test with tools
→ Measure in your own workload
→ Apply only what your system actually needs
These are the primary companion resources for the project.
This is the foundation volume.
It focuses on:
- NIO
- selectors
- channels and buffers
- concurrency
- thread pools
- the Java Memory Model
- runtime behavior
- performance foundations
| Platform | Link |
|---|---|
| Gumroad | https://solisdynamics.gumroad.com/l/java-libraries-guide-1 |
| Leanpub | https://leanpub.com/java-libraries-guide-1 |
| Amazon | https://www.amazon.com/dp/B0GWWXB5BV |
| Google Play Books | https://play.google.com/store/books/details?id=xKDPEQAAQBAJ |
| Shopier | https://www.shopier.com/SolisDynamics/45633747 |
| GitHub Repository | https://github.com/SolisDynamics/exploring-java-libraries-1 |
- Java I/O architecture
- blocking vs non-blocking design
- selector internals
- buffer mechanics
- thread pool design
- executor internals
- memory visibility
- class loading and runtime structure
- profiling and tuning foundations
This volume expands into advanced runtime and UI-related systems.
It focuses on:
- Swing
- AWT
- Event Dispatch Thread
- advanced runtime behavior
- desktop architecture
- broader JVM system design
| Platform | Link |
|---|---|
| Gumroad | https://solisdynamics.gumroad.com/l/java-libraries-guide-2 |
| Leanpub | https://leanpub.com/java-libraries-guide-2 |
| Google Play Books | https://play.google.com/store/books/details?id=gBHUEQAAQBAJ |
| Shopier | https://www.shopier.com/SolisDynamics/46354129 |
| GitHub Repository | https://github.com/SolisDynamics/exploring-java-libraries-2 |
- desktop application architecture
- event dispatching
- advanced runtime design
- UI responsiveness
- system-level behavior in GUI applications
These tools are essential for diagnosing real systems.
Use this for low-overhead production profiling.
- CPU hotspots
- allocation pressure
- GC events
- thread state analysis
- latency spikes
- runtime events
Use this to analyze JFR recordings.
- visual inspection
- profiling timelines
- event correlation
- GC and allocation patterns
Use this for CPU, wall-clock, allocation, and lock profiling.
- flame graphs
- hidden contention
- hot paths
- lock analysis
- sampling-based profiling
Use this to understand HotSpot JIT behavior.
- JIT log analysis
- inlining behavior
- compilation decisions
- bytecode-to-assembly visibility
Use this for controlled microbenchmarks.
- comparing implementations
- testing JIT behavior
- avoiding benchmark mistakes
- measuring hot-path changes
A practical all-purpose diagnostic tool.
- thread dumps
- class loading inspection
- JVM flags
- GC triggering
- runtime diagnostics
Use for thread dump analysis.
- deadlocks
- blocked threads
- executor saturation
- event loop freezes
Use for heap inspection.
- heap dumps
- memory leak analysis
- object histogram analysis
Use for live GC and memory monitoring.
- collection frequency
- generational behavior
- occupancy trends
- GC overhead checks
Useful for:
- quick inspection
- thread views
- heap views
- live monitoring
Use this to visualize verbose GC logs.
- Stop-The-World pause analysis
- allocation pressure
- promotion behavior
- collection trends
Use GC logs to understand:
- pause behavior
- allocation pressure
- promotion patterns
- collection frequency
- memory pressure
Use heap dumps to understand:
- retained objects
- leak sources
- object dominators
- long-lived references
Use flame graphs to understand:
- where CPU time goes
- which methods dominate execution
- how call stacks behave under load
Reading these books is considered a rite of passage for senior Java engineers.
| Book Title | Author(s) | Core Focus | Why You Must Read It |
|---|---|---|---|
| Java Concurrency in Practice | Brian Goetz et al. | Concurrency, JMM | The definitive bible for Java multithreading. The code style is older, but the principles of the Java Memory Model remain absolute. |
| Optimizing Java | Ben Evans et al. | Performance, JVM | A strong bridge between JVM internals, hardware interactions, and performance tuning. |
| Effective Java (3rd Ed.) | Joshua Bloch | API Design, Best Practices | Essential for understanding why standard Java libraries make the trade-offs they do. |
| Systems Performance | Brendan Gregg | OS, Hardware | Not Java-specific, but critical for understanding CPU caches, disk I/O, and networking bottlenecks. |
| Designing Data-Intensive Applications | Martin Kleppmann | Distributed Systems | Excellent for durability, consistency, replication, and system design under load. |
| Reactive Design Patterns | Roland Kuhn, Jamie Allen, Brian Hanafee | Reactive Systems | Useful for understanding message-driven systems, backpressure, and resilience patterns. |
| Mechanical Sympathy essays | Martin Thompson | Hardware-Aware Design | Core reading for cache-friendly, latency-sensitive engineering. |
When stack overflow fails, you must read the rules that govern the compiler and runtime.
| Document | Purpose | Impact on this Wiki |
|---|---|---|
| The Java Language Specification (JLS) | Defines language syntax and behavior. | Chapter 17 defines the Memory Model and concurrency rules. |
| The JVM Specification (JVMS) | Defines how bytecode is executed. | Explains class loading, reflection boundaries, and execution areas. |
| JSR-133 (Java Memory Model) | The original memory model revision. | The foundation of volatile, synchronized, and happens-before. |
| Reactive Streams Specification | Defines demand-driven reactive flow control. | The conceptual basis for backpressure in modern Java reactive systems. |
Throughout the Exploring Java Libraries wiki, you will encounter terminology that belongs to system engineering rather than standard application development.
Use this dictionary to bridge the gap:
Coined by Martin Thompson.
It means designing software that plays nicely with the underlying hardware, such as CPU caches and memory controllers, rather than fighting it.
The response time experienced by the slowest 1% of your users.
In distributed systems, ignoring tail latency often leads to catastrophic cascading failures.
A guarantee by the Java Memory Model (JMM).
If action A happens-before action B, the JVM guarantees that the results of A are visible to the thread executing B.
A resilience mechanism in asynchronous systems where a fast data producer is told to slow down by a slow consumer to prevent overload and OutOfMemory crashes.
A severe flaw in many load testing tools where the tool fails to record time spent waiting in a queue while the system was stalled.
It makes bad systems look falsely fast.
A phase during Garbage Collection where all application threads are paused completely.
The primary enemy of low-latency system design.
A JVM state where threads must reach a safe coordination point before certain runtime operations can proceed.
The JVM invalidates speculative optimizations and falls back to a safer execution mode when assumptions no longer hold.
Independent variables on the same cache line causing unnecessary cache invalidation and performance loss.
A data movement strategy that avoids extra copying between kernel and user space whenever possible.
A readiness-driven coordination model where one or a few threads manage many connections efficiently.
The JVM subsystem that creates runtime identity, isolation, and visibility for classes.
A standard for asynchronous stream processing with explicit backpressure and demand signaling.
When you encounter these terms in the wiki, this is the kind of thing you should verify and understand.
| Term | What to Investigate |
|---|---|
| Mechanical Sympathy | How software aligns with CPU, cache, and OS behavior |
| Tail Latency | Why the slowest requests matter most |
| Backpressure | How a system resists overload |
| Safepoint | Why JVM-wide pauses occur |
| Deoptimization | Why optimized code can fall back |
| False Sharing | How cache lines can harm concurrency |
| Zero-Copy | When data avoids extra copying |
| Event Loop | How readiness-driven coordination works |
| Class Loader | How runtime identity and isolation are created |
| Happens-Before | Why memory visibility is not automatic |
These are the topics worth revisiting often.
- blocking vs non-blocking I/O
- selectors and readiness
- channels and buffers
- zero-copy data transfer
- event loop design
- thread pools and executor internals
- futures and cancellation
- thread lifecycle
- memory visibility
- happens-before
- atomicity and locks
- JIT compilation
- garbage collection
- class loading
- reflection
- runtime profiling
- module boundaries
- bottleneck analysis
- backpressure
- load shedding
- cache locality
- contention
- tail latency
- warmup behavior
These are the primary references when correctness matters.
- Java Language Specification
- Java Virtual Machine Specification
- Java Platform Module System documentation
- Java standard library documentation
- java.util.concurrent documentation
- ExecutorService API documentation
- ForkJoinPool documentation
- CompletableFuture documentation
- java.util.concurrent.Flow documentation
- java.nio documentation
- Selector documentation
- Channel and ByteBuffer documentation
- FileChannel documentation
- SocketChannel documentation
- java.lang.reflect documentation
- java.lang.invoke documentation
- MethodHandles documentation
- VarHandle documentation
These are especially useful for architecture and performance thinking.
- TCP/IP behavior references
- reactive streams specification
- operating system polling models
- event notification mechanisms such as epoll and kqueue
- IO completion models such as IOCP
- class loading and linking behavior
- garbage collection design references
- safepoint mechanics
- JIT compilation and profiling discussions
- memory model and ordering references
- Mechanical Sympathy references
- latency engineering notes
- throughput and queueing theory references
- backpressure and load shedding references
- tail latency discussions
- high-load service design papers
Where to go when you finish the wiki?
Follow the engineers who write the JVM.
Martin Thompson's legendary blog on high-performance engineering.
Deep dives into the Java Memory Model and JVM internals.
Practical masterclasses in scale, resilience, and architecture.
Essential for system-level performance tracing and analysis.
If you are using this wiki as a study system, a good route is:
01-Core-Overview
→ 01-NIO-Blocking-vs-NonBlocking
→ 01-NIO-Channel-Buffer-Model
→ 01-NIO-Selector-Architecture
→ 02-Concurrency-Overview
→ 02-Thread-Pool-Mechanics
→ 02-ExecutorService-Internals
→ 02-Java-Memory-Model
→ 03-Runtime-Overview
→ 03-Reflection-Internals
→ 03-ClassLoader-Architecture
→ 04-Performance-Overview
→ 04-Event-Loop-Design
→ 04-Backpressure-Strategies
This order moves from raw data flow to execution, then runtime behavior, then performance and resilience.
Use the tools and references in this page with a clear goal.
Ask:
- What am I trying to measure?
- What behavior am I trying to explain?
- What failure mode am I trying to eliminate?
- What is the bottleneck?
- What layer of the system is responsible?
Do not tune blindly.
Do not benchmark casually.
Do not rely on a single reference.
Always cross-check with:
- official documentation
- runtime diagnostics
- workload measurements
- architectural reasoning
Continue exploring:
- 01-Core-Overview
- 01-NIO-Selector-Architecture
- 01-NIO-Blocking-vs-NonBlocking
- 01-NIO-Channel-Buffer-Model
- 02-Concurrency-Overview
- 02-Thread-Pool-Mechanics
- 02-ExecutorService-Internals
- 02-Java-Memory-Model
- 03-Runtime-Overview
- 03-Reflection-Internals
- 03-ClassLoader-Architecture
- 04-Performance-Overview
- 04-Event-Loop-Design
- 04-Backpressure-Strategies
Maintained by engineers, for engineers.
© 2026 SolisDynamics — Java Libraries Wiki