深入解析Java性能：权威指南

需积分: 13 28 浏览量更新于2024-07-18 1 收藏 13.9MB PDF 举报

"Java Performance: The Definitive Guide by Scott Oaks" 本书《Java Performance: The Definitive Guide》由Scott Oaks撰写，旨在深入探讨Java性能优化的各个方面。尽管作者最初对于编写一本关于Java性能调优的书籍有所疑虑，认为Java性能问题已经得到解决，但他承认在实际工作中，无论是Java应用还是其他应用，性能优化仍然是一个持续关注的话题。书中可能涵盖了以下几个重要的Java性能优化知识点： 1. **JVM基础**：Java虚拟机（JVM）是Java性能的关键所在。作者可能会讨论JVM的工作原理，包括类加载机制、内存模型（堆、栈、方法区等）、垃圾收集器（如新生代、老年代GC）以及JVM的内存配置参数。 2. **性能分析工具**：了解如何使用各种工具（如JVisualVM、JProfiler、VisualGC等）进行性能监控和分析，以识别内存泄漏、CPU消耗过高等问题。 3. **代码优化**：优化Java代码以提高执行效率，包括减少对象创建、有效使用集合类、避免不必要的同步等。 4. **JVM调优**：学习如何调整JVM参数以适应不同的应用需求，例如设置合适的堆大小、GC策略、线程池大小等。 5. **算法与数据结构**：强调算法和数据结构的重要性，说明它们对程序性能的直接影响，如何选择合适的数据结构以提高程序效率。 6. **并发与多线程**：深入理解Java的并发模型，如线程池、锁、并发容器等，并学习如何避免并发问题导致的性能瓶颈。 7. **热点代码探测与编译优化**：JVM的即时编译器（JIT）会将频繁执行的代码编译为本地机器码，提升执行效率。讨论如何识别和利用这一特性。 8. **外部系统瓶颈**：除了Java本身，作者可能还会讨论网络、数据库、磁盘I/O等外部系统的性能影响，以及如何与Java应用配合优化整体性能。 9. **监控与日志**：有效的监控系统可以帮助识别性能问题，而日志则为问题排查提供关键信息。这部分可能会介绍如何设置和使用监控和日志系统。 10. **错误与异常处理**：不当的错误处理可能导致性能下降，作者可能会讲解如何优雅地处理错误和异常，以减少性能损失。本书的发布日期为2014年4月，第一版。读者可以通过O'Reilly Media获取更多关于此书的信息，包括任何更新和勘误。作为一本权威指南，它将为Java开发者和性能工程师提供宝贵的实践经验和指导。

CHAPTER 1

Introduction

This is a book about the art and science of Java performance.

The science part of this statement isn’t surprising; discussions about performance in‐

clude lots of numbers and measurements and analytics. Most performance engineers

have a background in the sciences, and applying scientific rigor is a crucial part of

achieving maximum performance.

What about the art part? The notion that performance tuning is part art and part science

is hardly new, but it is rarely given explicit acknowledgment in performance discussions.

This is partly because the idea of “art” goes against our training.

Part of the reason is that what looks like art to some people is fundamentally based on

deep knowledge and experience. It is said that magic is indistinguishable from suffi‐

ciently advanced technologies, and certainly it is true that a cell phone would look

magical to a knight of the Round Table. Similarly, the work produced by a good per‐

formance engineer may look like art, but that art is really an application of deep knowl‐

edge, experience, and intuition.

This book cannot help with the experience and intuition part of that equation, but its

goal is to help with the deep knowledge—with the view that applying knowledge over

time will help you develop the skills needed to be a good Java performance engineer.

The goal is to give you an in-depth understanding of the performance aspects of the

Java platform.

This knowledge falls into two broad categories. First is the performance of the Java

Virtual Machine (JVM) itself: the way in which the JVM is configured affects many

aspects of the performance of a program. Developers who are experienced in other

languages may find the need for tuning to be somewhat irksome, though in reality tuning

the JVM is completely analogous to testing and choosing compiler flags during com‐

pilation for C++ programmers, or to setting appropriate variables in a php.ini file for

PHP coders, and so on.

The second aspect is to understand how the features of the Java platform affect perfor‐

mance. Note the use of the word platform here: some features (e.g., threading and syn‐

chronization) are part of the language, and some features (e.g., XML parsing perfor‐

mance) are part of the standard Java API. Though there are important distinctions

between the Java language and the Java API, in this case they will be treated similarly.

This book covers both facets of the platform.

The performance of the JVM is based largely on tuning flags, while the performance of

the platform is determined more by using best practices within your application code.

In an environment where developers code and a performance group tests, these are

often considered separate areas of expertise: only performance engineers can tune the

JVM to eke out every last bit of performance, and only developers worry about whether

their code is written well. That is not a useful distinction—anyone who works with Java

should be equally adept at understanding how code behaves in the JVM and what kinds

of tuning is likely to help its performance. Knowledge of the complete sphere is what

will give your work the patina of art.

A Brief Outline

First things first, though: Chapter 2 discusses general methodologies for testing Java

applications, including pitfalls of Java benchmarking. Since performance analysis re‐

quires visibility into what the application is doing, Chapter 3 provides an overview of

some of the tools available to monitor Java applications.

Then it is time to dive into performance, focusing first on common tuning aspects: just-

in-time compilation (Chapter 4) and garbage collection (Chapter 5 and Chapter 6). The

remaining chapters focus on best practice uses of various parts of the Java platform:

memory use with the Java heap (Chapter 7), native memory use (Chapter 8), thread

performance (Chapter 9), Java Enterprise Edition APIs (Chapter 10), JPA and JDBC

(Chapter 11), and some general Java SE API tips (Chapter 12).

Appendix A lists all the tuning flags discussed in this book, with cross-references to the

chapter where they are examined.

Platforms and Conventions

This book is based on the Oracle HotSpot Java Virtual Machine and the Java Platform,

Standard Edition (Java SE), versions 7 and 8. Within versions, Oracle provides update

releases periodically. For the most part, update releases provide only bug fixes; they

never provide new language features or changes to key functionality. However, update

releases do sometimes change the default value of tuning flags. Oracle will doubtless

provide update releases that postdate publication of this book, which is current as of

Java 7 update 40 and Java 8 (as of yet, there are no Java 8 update releases). When an

2 | Chapter 1: Introduction

update release provides an important change to JVM behavior, the update release is

specified like this: 7u6 (Java 7 update 6).

Sections on Java Enterprise Edition (Java EE) are based on Java EE 7.

This book does not address the performance of previous releases of Java, though of

course the current versions of Java build on those releases. Java 7 is a good starting point

for a book on performance because it introduces a number of new performance features

and optimizations. Chief among these is a new garbage collection (GC) algorithm called

G1. (Earlier versions of Java had experimental versions of G1, but it was not considered

production-ready until 7u4.) Java 7 also includes a number of new and enhanced

performance-related tools to provide vastly increased visibility into the workings of a

Java application. That progress in the platform is continued in Java 8, which further

enhances the platform (e.g., by introducing lambda expressions). Java 8 offers a big

performance advantage in its own right—the performance of Java 8 itself is much faster

than Java 7 in several key areas.

There are other implementations of the Java Virtual Machine. Oracle has its JRockit

JVM (which supports Java SE 6); IBM offers its own compatible Java implementation

(including a Java 7 version). Many other companies license and enhance Oracle’s Java

technology.

Oracle’s Commercial JVM

Java and the JVM are open source; anyone may participate in the development of Java

by joining the project at http://openjdk.java.net. Even if you don’t want to actively par‐

ticipate in development, source code can be freely downloaded from that site. For the

most part, everything discussed in this book is part of the open source version of Java.

Oracle also has a commercial version of Java, which is available via a support contract.

That is based on the standard, open source Java platform, but it contains a few features

that are not in the open source version. One feature of the commercial JVM that is

important to performance work is Java Flight Recorder (see “Java Flight Recorder” on

page 60).

Unless otherwise mentioned, all information in this book applies to the open source

version of Java.

Although all these platforms must pass a compatibility test in order to be able to use the

Java name, that compatibility does not always extend to the topics discussed in this book.

This is particularly true of tuning flags. All JVM implementations have one or more

garbage collectors, but the flags to tune each vendor’s GC implementation are product-

specific. Thus, while the concepts of this book apply to any Java implementation, the

Platforms and Conventions | 3

specific flags and recommendations apply only to Oracle’s standard (HotSpot-based)

JVM.

That caveat is applicable to earlier releases of the HotSpot JVM—flags and their default

values change from release to release. Rather than attempting to be comprehensive and

cover a variety of now-outdated versions, the information in this book covers only Java

7 (up through 7u40) and Java 8 (the initial release only) JVMs. It is possible that later

releases (e.g., a hypothetical 7u60) may slightly change some of this information. Always

consult the release notes for important changes.

At an API level, different JVM implementations are much more compatible, though

even then there might be subtle differences between the way a particular class is imple‐

mented in the Oracle HotSpot Java SE (or EE) platform and an alternate platform. The

classes must be functionally equivalent, but the actual implementation may change.

Fortunately, that is infrequent, and unlikely to drastically affect performance.

For the remainder of this book, the terms Java and JVM should be understood to refer

specifically to the Oracle HotSpot implementation. Strictly speaking, saying “The JVM

does not compile code upon first execution” is wrong; there are Java implementations

that do compile code the first time it is executed. But that shorthand is much easier than

continuing to write (and read) “The Oracle HotSpot JVM…”

JVM Tuning Flags

With a few exceptions, the JVM accepts two kinds of flags: boolean flags, and flags that

require a parameter.

Boolean flags use this syntax: -XX:+FlagName enables the flag, and -XX:-FlagName

disables the flag.

Flags that require a parameter use this syntax: -XX:FlagName=something, meaning to

set the value of FlagName to something. In the text, the value of the flag is usually

rendered with something indicating an arbitrary value. For example, -XX:NewRatio=N

means that the NewRatio flag can be set to some arbitrary value N (where the implications

of N are the focus of the discussion).

The default value of each flag is discussed as the flag is introduced. That default is often

a combination of different factors: the platform on which the JVM is running and other

command-line arguments to the JVM. When in doubt, “Basic VM Information” on page

47 shows how to use the -XX:+PrintFlagsFinal flag (by default, false) to determine

the default value for a particular flag in a particular environment given a particular

command line. The process of automatically tuning flags based on the environment is

called ergonomics.

4 | Chapter 1: Introduction

Client Class and Server Class

Java ergonomics is based on the notion that some machines are “client” class and some

are “server” class. While those terms map directly to the compiler used for a particular

platform (see Chapter 4), they apply to other default tunings as well. For example, the

default garbage collector for a platform is determined by the class of a machine (see

Chapter 5).

Client-class machines are any 32-bit JVM running on Microsoft Windows (regardless

of the number of CPUs on the machine), and any 32-bit JVM running on a machine

with one CPU (regardless of the operating system). All other machines (including all

64-bit JVMs) are considered server class.

The JVM that is downloaded from Oracle and OpenJDK sites is called the “product”

build of the JVM. When the JVM is built from source code, there are many different

builds that can be produced: debug builds, developer builds, and so on. These builds

often have additional functionality in them. In particular, developer builds include an

even larger set of tuning flags so that developers can experiment with the most minute

operations of various algorithms used by the JVM. Those flags are generally not con‐

sidered in this book.

The Complete Performance Story

This book is focused on how to best use the JVM and Java platform APIs so that pro‐

grams run faster, but there are many outside influences that affect performance. Those

influences pop up from time to time in the discussion, but because they are not specific

to Java, they are not necessarily discussed in detail. The performance of the JVM and

the Java platform is a small part of getting to fast performance.

Here are some of the outside influences that are at least as important as the Java tuning

topics covered in this book. The Java knowledge-based approach of this book comple‐

ments these influences, but many of them are beyond the scope of what we’ll discuss.

Write Better Algorithms

There are a lot of details about Java that affect the performance of an application, and

a lot of tuning flags are discussed. But there is no magical -XX:+RunReallyFast option.

Ultimately, the performance of an application is based on how well it is written. If the

program loops through all elements in an array, the JVM will optimize the array bounds-

checking so that the loop runs faster, and it may unroll the loop operations to provide

an additional speedup. But if the purpose of the loop is to find a specific item, no

The Complete Performance Story | 5

剩余423页未读，继续阅读

nn123456789

粉丝: 14
资源: 128

深入解析Java性能：权威指南

深入理解Java性能优化：权威指南

Java线程第三版：CHM转PDF实现跨设备阅读

Java性能优化权威指南

Java Performance: The Definitive Guide, Scott Oaks

Java Performance

java 性能权威指南.pdf [美]scott Oaks著

Java Performance The Definitive Guide

java performance, the definitive guide

Java Performance: The Definitive Guide

Java Performance_The_Definitive_Guide.zip

最新资源