Skip to product information
Digging into the JVM's Underside
Digging into the JVM's Underside
Description
Book Introduction
“An exciting adventure deep into the Java Virtual Machine.”

Back when programming was primarily done using C and C++, the difficult memory management and platform portability issues were a significant burden for developers.
In such a situation, Java, which appeared with the slogan “Write once, run anywhere,” was considered a groundbreaking language.
And the technology that laid the foundation for making that slogan a reality was the Java Virtual Machine (JVM). While the JVM seemed to grant developers the gift of automatic memory management and platform independence, it came at a price: poor performance and out-of-memory errors.
And the reality is that even today we are not free from such problems.
To solve these problems, we need to understand the core principles of how the JVM handles complex, low-level problems.

『Understanding the JVM』 examines the core operating principles of automatic memory management, execution subsystem, compilation, and concurrency, which are the four main topics of the JVM, and introduces how these principles affect the execution of software actually written in Java and how the JVM operating mechanism can be applied to problems encountered in the development field.
Developers who wish to build robust systems using Java, which has grown from the days of creating small applets to a language that supports a corner of the Internet world, will find many ideas and inspiration in this book.

index
Translator's Note
introduction
Acknowledgements

Part 1: Getting to Know Java

Chapter 1: Introduction to the Java Technology System

1.1 Introduction
1.2 Java Technology System
1.3 Java's Past and Present
1.4 Java Virtual Machine Family
1.5 The Future of Java Technology
1.6 Real-World: Building the JDK with My Own Hands
1.7 In conclusion

Part 2 Automatic Memory Management

Chapter 2 Java Memory Areas and Memory Overflow

2.1 Introduction
2.2 Runtime Data Area
2.3 Looking at Objects in the Hotspot Virtual Machine
2.4 Practice: OutOfMemoryError Exception
2.5 In conclusion

Chapter 3: Garbage Collector and Memory Allocation Strategies
3.1 Introduction
3.2 Is the subject dead?
3.3 Garbage Collection Algorithm
3.4 Detailed implementation of the hotspot algorithm
3.5 Classic Garbage Collector
3.6 Low-Latency Garbage Collector
3.7 Choosing the Right Garbage Collector
3.8 Practice: Memory Allocation and Reclaim Strategies
3.9 In conclusion

Chapter 4: Virtual Machine Performance Monitoring and Troubleshooting Tools
4.1 Introduction
4.2 Basic Troubleshooting Tools
4.3 GUI Tools
4.4 Hotspot Virtual Machine Plug-in and Tools
4.5 In conclusion

Chapter 5: Optimization Case Analysis and Practice
5.1 Introduction
5.2 Case Analysis
5.3 Practice: Reducing Eclipse Startup Time
5.4 In conclusion

Part 3 Virtual Machine Execution Subsystem

Chapter 6 Class File Structure

6.1 Introduction
6.2 The cornerstone toward platform independence
6.3 Class File Structure
6.4 Introduction to Bytecode Instructions
6.5 Design is public, implementation is private
6.6 Evolution of the Class File Structure
6.7 In conclusion

Chapter 7 Class Loading Mechanism
7.1 Introduction
7.2 Class Loading Points
7.3 Class loading process
7.4 Class Loader
7.5 Java Module System
7.6 In conclusion

Chapter 8 Bytecode Execution Engine
8.1 Introduction
8.2 Runtime Stack Frame Structure
8.3 Method Calls
8.4 Dynamically Typed Language Support
8.5 Stack-based bytecode interpretation and execution engine
8.6 In conclusion

Chapter 9: Class Loading and Execution Subsystems, Case Studies, and Practices
9.1 Introduction
9.2 Case Studies
9.3 Practice: Implementing Remote Execution Functions Yourself
9.4 In conclusion

Part 4 Compilation and Optimization

Chapter 10 Front-End Compilation and Optimization

10.1 Introduction
10.2 javac compiler
10.3 Interesting aspects of Java's convenient grammar
10.4 Practice: Creating a Plug-in Annotation Processor
10.5 In conclusion

Chapter 11 Backend Compilation and Optimization
11.1 Introduction
11.2 JIT Compiler
11.3 AOT Compiler
11.4 Compiler Optimization Techniques
11.5 Practice: Understanding the Graal Compiler in Depth
11.6 In conclusion

Part 5: Efficient Concurrency

Chapter 12: Java Memory Model and Threads

12.1 Introduction
12.2 Efficiency and Consistency in Hardware
12.3 Java Memory Model
12.4 Java and Threads
12.5 Java and Virtual Threads
12.6 In conclusion

Chapter 13: Thread Safety and Lock Optimization
13.1 Introduction
13.2 Thread Safety
13.3 Lock Optimization
13.4 In conclusion

Appendix List of Abbreviations
Search
GOODS SPECIFICS
- Date of issue: April 30, 2024
- Page count, weight, size: 688 pages | 1,280g | 188*240*34mm
- ISBN13: 9788966264414

You may also like

카테고리