| 商家名称 | 信用等级 | 购买信息 | 订购本书 |
 |
 |
Oracle JRockit: The Definitive Guide |  |
 |
|
Oracle JRockit: The Definitive Guide | |
网友对Oracle JRockit: The Definitive Guide的评论
This book has really impressed me. It goes into deep details of JVM and describes different approaches to various topics related to memory management, threads management, code analysis, subtle details within low level code that are the result of optimization. Authors really dive into details. What's more important, this book could still surprise long time developer like me myself. I have found few, really interesting ideas in terms of memory optimization and threads management. Even though book covers JRockit, you can still get a loot of information related to JVMs in general.
Apart from JVM itself, book covers very comprehensively benchmarking, JRockit Mission Control, runtime analyzer and memory leak detector. And this is done really good. You get like 250 pages of knowledge related to code analysis, JRockit's tools usage and useful ideas from the authors.
What's important here is that JRockit is already one of the Oracle's platforms and even more important is the fact it will be partially integrated into Java 1.8. That said, it's worth to become more familiar with it if you consider yourself a serious Java developer.
Just one remark on the content. This book can be sometimes demanding as authors dive deep into assembler code level. So, it's rather recommended for engineers or people who are familiar with this kind of details.
Highly recommended.
I have been involved in developing both the JRockit JVM and JRockit Mission Control for nine years and I am thus very familiar with the subject of this book. I already knew that the authors are brilliant engineers who know what they are talking about. This book also shows that they can talk about it well. Marcus and Marcus have managed to condense years of research and development into one book and translate it to "human readable" format. This book takes you under the hood and behind the scenes of JRockit. It digs deep and goes personal, explaining not only how the JVM works but also why.
This is a book for Java developers who take their craft seriously and want to open the black box beneath them and make friends with the mystical creature that resides inside. This is a book for Java administrators who want hands-on tips on how to make their life easier and their applications run better and faster. This is a book for the computer science geek who simply needs to know how all the magic is done.
The first part of the book opens up the JVM, pulls out the parts and puts them on display. These chapters describe code generation, memory management, threads and locks, both in general and in the specific example of the JRockit JVM. This is more than a whitepaper on JRockit internals, this is a complete schoolbook in JVMs. With each chapter you also get pointers for what to do and especially what not to do in order to work with the black box rather than against it.
After a chapter on benchmarking and tuning comes the probably most comprehensive guide available to the JRockit tools - JRockit Mission Control and JRCMD. Plenty of screenshots and example outputs take you through the tools, how to use them and even how to extend them.
The last chapter introduces JRockit Virtual Edition that takes the JVM closer to the hardware by eliminating the operating system. It also takes a look at where JVM development may be heading in the future.
Personally, I especially enjoyed reading the history of the JRockit JVM, and the authors' own comments on Java and software development. These are the details that take the book beyond a technical description of JRockit and help you understand the design choices behind this complex piece of technology.
This one was on my list of things to buy for quite some time. The only reason for this is simple: Oracle JRockit is one of the industry's highest performing Java Virtual Machines and I loved it's JIT everything approach since the beginning. I did not manage to do this, since it was published. But a few days ago, the digital edition arrived on my iPad and I finally found the time to read it. Sit back and relax. This is my personal view about the most stunning Java related book of 2010!
The Authors
As usual, I start with a short introduction of the authors. In this special case, I feel this is very important to understand the book. Both started out with Appeal Virtual Machines where they were founders. This was the company, which initially developed JRockit. Marcus Lagergren holds a M.Sc. in computer science from the Royal Institute of Technology in Stockholm, Sweden. He has a background in computer security but has worked with runtimes since 1999. Marcus has been team lead and architect for the JRockit code generators and has been involved in pretty much every other aspect of the JRockit JVM internals. Since 2007 Marcus works for Oracle on fast Virtualization technology.
Marcus Hirt is currently working for Oracle as Team Lead, Engineering Manager and Architect for the JRockit Mission Control team. Marcus has been an appreciated speaker on Oracle Open World, eWorld, BEAWorld, EclipseCon, Nordev and Expert Zone Developer Summit, and has contributed JRockit related articles and webinars to the JRockit community. Marcus Hirt got his M.Sc. education in computer science from the Royal Institute of Technology in Stockholm.
The Content
Java developers are always on the lookout for better ways to analyze application behavior and gain performance. As we all know, this is not as easy as it looks. If you are trying to understand more about all this you need to know far more than simple Java. The big things in terms of performance happen elsewhere: In the JVM. If you are looking for the best Server JVM out there, you'll come across JRockit. And this book is there to reveal it's secrets. This book helps you gain in-depth knowledge of Java from the JVM's point of view. It explains how to write code that works well with the JVM to gain performance and scalability.
The first chapter get's you started. You learn about the real basics. Cmd-line options and JRockit versioning. The real content starts with chapter 2. It brings you down to the inner workings of the JVM and the adaptive code generation ürinciples. If you are not used to assembly code examples, you will learn it. Examples are explained with bytecode and assemly code. If necessary instruction by instruction. Further on, code generation strategies, JIT compiling and runtime optimizations are explained as concepts with additional JRockit details. Chapter 3 takes you over to adaptive memory management. Here you will learn about the basics of heap management and garbage collection algorithms. Also scaling and performance are touched here. You get a glimpse at pitfalls and things, that will not work. Chapter 4 follows with everything about threads and synchronization and topics that are hard to debug and difficult to optimize. You get a more detailed look at special JRockit flags which help optimizing the topic. Chapter 5 gives your everything about benchmarking and tuning. You get basic hints about what to think about while creating a benchmark and about which measures to take. It also contains a brief overview about industry-standard benchmarks. After that you get to know about common bottlenecks and how to avoid them. Chapter 6 presents an overview about the JRockit Mission Control. Followed by chapter 7 which dives into the management console, touching MBeans, the runtime and further topics. The runtime analyzer is detailed in chapter 8. Learn about the recordings and how to analyze them in terms of memory, code, threads/locks and latency findings. As expected the flight recorder follows in chapter 9. Another JRockit tool, the memory leak detector is the major player in chapter 10. Chapter 11 dives into the JRCMD cmd-line utility and shows how it can be used for listing and sending diagnostic cmds to one or more locally running instance of the JVM. It's an alphabetical reference guide to the JRCMD commands. Chapter 12 contains everything you need to know about using the JRockit management APIs by showcasing examples. The last chapter 13 summarizes the basics about the JRockit Virtual Edition and gives some basics about the challenges by virtualizing Java. If needed you can dive deeper with the bibliography or even look through the glossary or index. 477 pages of content without the preface and the appendix is a big hit for your weekend. You better have some very silent times to follow this stuff!
Writing and style
As you might have guessed already: I am impressed by the book. Being used to read complex and detailed stuff which takes time, I really flew through this book. You get used to the direct and technical style very easy and it's still personal enough to be interesting so you keep on reading page after page. Even non native speakers should be able to follow, if they know the technical terms. I needed to lookup some very uncommon and hardware near things but this did not disturb the overall reading experience.
This was my fist eBook as PDF from Packt Publishing and I am not sure, if I am still willing to have the printed version, too. The many assembly and other code examples always makes you want to scroll back. If you are using a book you just need your thumb to solve this problem :) But I still like the digital reading experience in general.
My expectations
The structure is a bit different from the one I expected. The tooling around JRockit is covered a lot; something I wasn't expecting. But this is the only part, that did not fulfill my expectations. Especially because even those parts are excellent.
I expected to read some very technical content. But it was far more than that. It goes down to the metal and handles and registers and the JVM internals. If you thought, you know anything about the inner workings of a JVM ... here is what really happens. Don't ask what you can do for your JVM; ask, what your JVM can do for you :)
Conclusion and recommendation
Buy one! No .. better two! The digital edition and of course the paperback. It's worth it. If you have both, you can always carry the digital edition around and recall the basics and optimizations to yourself every time you think about writing optimized code for the JVM. Make shure, you have a silent place to read this one. And you should get a recent JRockit R28 to play around with. I wrote articles about it and I have seen it in the wild since some time. I thought I know a bit. Now, I know even more!
If you are a beginner, you probably need some more basics before reading this one.
Just like the title establish, this is the definitive guide of JRockit, including the last features of version R28.
It starts with the canonical knowledge to work and understand the JVM, showing details from the most basic until the advanced topics. Describing how and why certain features were made, how it was improved and plus several Best Practices lists to take the best of the suite of tools bundle with JRockit.
The book is wisely divided in two parts, the first is about JVM and the second part is regarding to JRockit Mission Control. Which is a powerful set to dissect JRockit Beauvoir to find out memory leaks, performance, bottlenecks, etc.
It gives an extended explanation of the parameters to take better of this tools suite with a low overhead, many of the areas referred can't be found somewhere else in such deeply detail form.
Everything in only one compendium of information done by the same creators of JRockit.
The target audience for Oracle JRockit: The Definitive Guide is developers and administrators with a few years of experience working with Java installations. Anyone doing design or performance work with JRockit (or any other JVM, for that matter) should read this book. Those new to the subject will still gain much from the book and can expect to refer to it as they work with Java. A good grounding in Java and systems in general will allow the reader to fully utilize the material in this guide.
There are two main sections, the first 5 chapters on the JRockit JVM, and chapters 6 through 12 on the tool suite, JRockit Mission Control. In addition, a 13th chapter supplements the main body of the book with a discussion of new technology, emphasizing virtualization. A bibliography, glossary, and index round out the volume. The book is well made, clearly printed on stock of adequate weight and opacity. One could quibble that paper should be completely opaque, but that would mean a thicker, heavier book. This is already a substantial tome. The text is written with a straightforward conversational tone. American spellings are used throughout.
The content is well structured, with overview and background material to balance the technical detail. Emphasis throughout is placed on practical performance, with frequent notes that add illustrative anecdotes or insights gained from the authors' experience consulting on real systems.
Chapter 1, Getting Started is brief, covering such necessities as how to obtain the product and supported platforms. Notes on command-line options and interpretation of product version numbers provide useful background.
Chapter 2, Adaptive Code Generation gets into technical details of the JRockit JVM after a general discussion of platform independence, Java bytecodes, and various compilation strategies. The JIT compilation strategy used in JRockit is covered in depth, and provides insight into the optimizations employed in the JVM, including the tradeoff between compilation speed and execution speed. Methods of controlling the code generation behavior through command-line flags and directive files are explained.'
Chapter 3, Adaptive Memory Management introduces the concept of automatic and adaptive memory management in the Java runtime. The discussion of garbage collection is detailed and quite complete. The section on false optimizations ought to be required reading. The command-line options that are commonly used to control memory management in the JVM are introduced, with forward references to where they are discussed further later in the book.
Chapter 4, Threads and Synchronization covers the mechanisms used to control parallelism in Java and the JRockit JVM in particular. The discussion of the Java Memory Model will be invaluable to those working on multithreaded applications. Common pitfalls in parallel Javva programming are identified and ways to avoid them are explained. Command-line options to instrument and examine threads and synchronization in the JVM are described.
Chapter 5, Benchmarking and Tuning explains the application benchmarking process and how it is used to find bottlenecks, detect regressions, and ensure that performance goals are met. Micro benchmarks, industry standard benchmarks, and application benchmarks are compared, and the uses and applicability of each is discussed. This chapter introduces the concept of profiling to identify bottlenecks and validate that external benchmarks address these. The parameters that are used to tune the behavior of the JVM's memory system, code generator, and so on to the application are covered. A section on common bottlenecks is presented.
Chapter 6, JRockit Mission Control introduces the tool suite that can be used to monitor, manage, and profile running JRockit JVMs, either standalone or inside the Eclipse IDE. Background on the product and its components is provided
The next several chapters treat each of the major components of JRockit Mission Control in turn: the Management Console, the Runtime Analyzer, the Flight Recorder, the Memory Leak Detector, and the JRCMD command-line utility. These tools grew out of a set of internal tools used by the JRockit developers that turned out to be useful for solving customers' problems. To a performance analyst or an application developer they are powerful tools indeed.
Chapter 12, Using the JRockit Management APIs discusses how to use the unsupported APIs to programmatically access the JRockit management features.
The closing chapter, JRockit Virtual Edition, deals with the concept of virtualization and the issues specific to virtualizing Java. JRockit Virtual Edition is a relatively new product that allows Java applications to be run in a virtual environment without a client operating system between the JVM and the hypervisor. In that regard it is like an OS that only supports a single process, the JVM.
喜欢Oracle JRockit: The Definitive Guide请与您的朋友分享,由于版权原因，读书人网不提供图书下载服务
