For enterprise developers, Java presents many obstacles to achieving optimal performance, and when you factor in the challenges of scalability and integrating complex business logic, authoritative help is sorely needed. In this book, two leading Java developers, both former members of IBM's vaunted SanFrancisco frameworks team, offer proven techniques for maximizing the performance of any Java enterprise application, especially those that impact Java server-side and application-server development. Just some of the topics covered include: the best techniques for identifying root causes of performance problems; problems that are inadvertent side effects of Java's strengths, such as object-orientation, garbage collection, and Java's similarities to C/C++; performance problems that can arise in distributed, n-tier development, such as the performance costs of transparency and the careful use of object affinity, placement, and granularity; the performance impacts of persistence infrastructure, distributed object infrastructure, Java Virtual Machines, and application-layer components, presenting powerful benchmarking techniques that can be used to choose the best possible options. Four full chapters address key real-world Java-related projects and the performance issues associated with them. The book also includes detailed coverage of system tuning, memory, disk, and network configuration; the impact of multiprocessors and network clustering; and replication issues in shared, large-scale environments.
Book Description
Editorial Reviews
Amazon.com Review
Any software developer knows Murphy's Law all too well: if anything can go wrong, it will. When it comes to today's enterprise-level, multitiered applications written in Java, there's a lot more that can go wrong in regard to performance. Written by two experts in enterprise Java (both veterans of IBM's SanFrancisco Java class frameworks), Enterprise Java Performance examines performance from beyond a single workstation. Filled with useful insights for designing Java applications on multiple servers, this book offers a timely and very useful guide suitable for any intermediate to advanced Java programmer.
While there are a number of titles on Java performance, this one stands out because of its enterprise-level perspective. Of course, you'll find some hints for writing better Java code at the micro level (which the authors call "low-hanging fruit") with instructions for optimizing string and loop performance. But this is just the beginning.
The heart of the book is its thorough discussion of performance and design issues for using remote objects, which allow distributed applications to do their work on multiple servers. The authors delve first into the issues of object design, including the correct granularity of objects. (Having a lot of small objects can cause too many round trips on the servers, but big ones can be clumsy for programmers.) Examples drawn from the authors' experience designing IBM's SanFrancisco application framework (a robust set of classes designed to automate entire businesses, like inventory and manufacturing) lend more credence to the discussion. The performance issues surrounding the crossvendor Enterprise JavaBean (EJB) standard are also examined.
Besides describing performance issues in enterprise applications, the book also gives you a number of tools to measure performance in your own code, including custom classes for performance monitoring, as well as the authors' enterprise-level benchmark--Business Object Benchmark (BOB). (They also survey existing Java benchmarks.) Later chapters include a succinct taxonomy of application styles for Java, like Web-based clients or applications that wrap legacy systems; performance hints are offered for each. There is also an excellent guide to running CORBA on Java and plenty of hints for optimizing servers, including memory configuration. A final chapter glances at performance issues with clustered servers.
In all, Enterprise Java Performance offers a valuable perspective on issues that all Java developers will likely face when creating distributed applications. This book will help you avoid many of the gotchas in deploying Java code on the enterprise, and it gives you the tools and techniques you'll need to write faster applications, even for very large systems. --Richard Dragan
Topics covered:
- Performance and optimization primer
- The performance life cycle
- Types of performance problems ("low-hanging fruit," application model problems, "physics")
- The Sun Java profiler and third-party tools
- A custom performance monitor class
- Using the Windows NT Performance Monitor
- Hints for writing faster Java code
- Using the String and StringBuffer classes correctly
- Loop optimizations
- Hints for synchronization and garbage collection
- Local vs. remote application partitioning
- Remote Method Invocation (RMI)
- Object granularity and object affinity
- Enterprise JavaBeans
- The IBM SanFrancisco application frameworks
- Performance issues for remote objects
- Performance bottlenecks (synchronization, avoiding deadlocks, distributed garbage collection)
- Survey of third-party benchmarks
- Custom distributed business object benchmark (BOB)
- Performance issues with the SanFrancisco architecture for objects
- Performance issues with Enterprise JavaBeans (EJBs)
- Types of EJBs
- Tutorial for Java and CORBA
- Performance issues for Jini
- Overview of today's Java application architectures (Web Out, Web In, Application Glue, Database Up, Application Wrapper, and Objects Down) and performance issues with each
- Hints for tuning EJB and SanFrancisco application servers (including memory, system, and disk configuration)
- Performance issues for clustered and "large-scale" systems
From the Inside Flap
Preface
The area of using Sun's Java technology for business needs is rapidly expanding. And with that expansion, of course, comes the need to address performance issues in this relatively new environment. Java itself has many performance pitfalls so that when you add the complexity of trying to run business code and scaling systems to meet the demands of many users, guidance is clearly needed. In fact, even very experienced Java programmers can make performance design mistakes in the enterprise environment. The purpose of this book is to describe methods of improving the performance of Enterprise applications developed in the Java programming language. The book will follow a pattern of working from basic examples and then building upon those examples to present the more complex topics within enterprise performance.
The authors have been part of the IBM SanFrancisco Project development team (SanFrancisco provides a common object-oriented infrastructure and application logic for Java application developers). We have watched the Java platform and SanFrancisco mature. As members of the SanFrancisco performance team, we have worked with both JVM/JIT technology suppliers and domain experts developing business object frameworks. This vantage point has given us some deep insights into the do's and don'ts of using Sun's Java technology for enterprise applications. It is this experience that we want to share with IT professionals.About This Book
This book is aimed at programmers who want to make this technology work most efficiently in the enterprise environment. We assume that readers already have a basic knowledge of the programming language, its syntax, and general class libraries.Organization
Part 1 lays the foundation for the rest of the book with a general introduction to enterprise performance and Java enterprise performance in particular. Chapter 1, "Performance in General," provides an introduction to performance in general. In Chapter 2, "Tools for Identifying Java Performance," we discuss some common tools for identifying the causes of performance problems, and Chapter 3, "Java Performance Problem Areas," gives some background on common performance problems specific to Java programming. Many of the strengths of Java, such as objects, garbage collection, and similarity to C/C++, can also be pitfalls if not used correctly. By the time you have finished the first three chapters, you will have the ideas and concepts in place that provide a foundation for well-performing Java and for understanding the more in-depth coverage within the remainder of the book.
Part 2 goes into detail on specific areas of Java performance physics. Chapter 4, "Local/Remote Issues," delves into issues of Local vs. Remote objects. Java provides powerful mechanisms (such as RMI) that aid in making the programming model for local objects the same as for remote objects. However, there can be a cost to this transparency, and it is essential to put the objects in the right place. Chapter 5, "Granularity," may also be thought of as expanding on the concept of "put the objects in the right place," but this time it is approached in terms of the granularity of objects, that is, how to decide which objects should be bound together tightly versus being loosely associated. In Chapter 6, "Bottlenecks," we introduce the topic of bottlenecks and how to deal with them. Eliminating bottlenecks is key to well-performing applications. One bottleneck can undo all the best efforts of programming farther down the stream. There are many opportunities for introducing bottlenecks into code.
Part 3 presents information on benchmarking. In Chapter 7, "Java Benchmarking Overview," we overview Java benchmarking tools and look at the plumbing behind it all, including the Java Virtual Machine (JVM), the kind of persistence infrastructure being used, and the distributed object infrastructure. An appropriate benchmark can go a long way toward revealing just how much can be expected from your enterprise application. Chapter 8, "An Application-Level Benchmark," expands on the benchmarking ideas of Chapter 7 and applies them to the application layer.
Part 4 covers four application environments currently used in or with enterprise Java programming. Chapters 9, 10, 11, and 12 detail the SanFrancisco, Enterprise Java Beans, CORBA/Java, and Jini environments, respectively, and how there are various choices in each that can affect the performance of an application running in the environment it defines.
In Part 5, we introduce a way of conceptualizing application models for the Java platform. Chapter 13, "How Java Is Used," reviews different ways in which Java is used, and how Java adapts to these environments: Web Out, Web In, Application Glue, Database Up, Application Wrapper, and Objects Down. Chapter 14, "Performance Implications," explores the performance implications of the various environments presented in Chapter 13.
Part 6 concludes the book with a look at problems and solutions involved in scaling up Java applications. Chapter 15, "System Tuning," examines the effects of the memory, disk, and network configuration on your Java application, and gives tips for system tuning. Chapter 16, "Large-Scale Effects," looks at SMP and cluster effects as well as what happens to Java environments as applications scale up. As the complexity of an application expands, it places greater and greater demands upon the Java infrastructure, such as the Java heap and garbage collection. We also look at how the correct placement, access, and replication of objects within a shared large-scale environment can be critical.Companion FTP Site
Complete code for the examples presented in this book can be downloaded from the following FTP site:ftp://ftp.prenhall/pub/ptr/sunsoft_books.w-053/enterprise_java_performance
Steven L. Halter is a Senior Staff Software Engineer for Imation Corp, working in the Software Research and Development Rochester Laboratory. He was a Staff Software Engineer for the IBM Software Systems Division and a member of the SanFrancisco Performance group during much of the writing of this book. He has worked in the areas of object persistence and object infrastructures, in which he holds five issued U.S. patents. He has also worked in the architecture and design area for system software for the IBM AS/400. He received his BS and MS degrees in Computer Science from Iowa State University.
Steven Jay Munroe is currently a Senior Software Engineer with IBM and was a member of the SanFrancisco Performance team during the writing of this book. Steve is currently a member of the SanFrancisco Application Deployment team, working with independent software developers and customers deploying SanFrancisco applications. Before joining the SanFrancisco team, Steve worked in various architecture and design roles in system software development for IBM's System/38 and AS/400 products. Steve is an inventor with twelve issued patents. He received a BS degree in Computer Science from Washington State University, Pullman, Washington.
Product Details
Would you like to update product info or give feedback on images?
|
More About the Author
Discover books, learn about writers, read author blogs, and more.
Customer Reviews
|
Share your thoughts with other customers:
|
||||||||||||||||||||||
|
Most Helpful Customer Reviews
5 of 5 people found the following review helpful:
5.0 out of 5 stars
practical tips for advanced Java programmer,
By Boris Aleksandrovsky (San Francisco, CA United States) - See all my reviews
This review is from: Enterprise Java Performance (Paperback)
The book gives good overview of Java performance bootleneck stemming both from the language design constraints and the inherent design issues in distributed systems. What I like best is a list of practical implementation tips, which this book abounds with. Those tips would be a usefull addition to anybody's Java Coding Standards.
7 of 8 people found the following review helpful:
5.0 out of 5 stars
Great book for dealing with performance.,
By A Customer
This review is from: Enterprise Java Performance (Paperback)
This book did a really good job in explaining the concepts of performance. It had good specific examples, but also showed how to deal with performance in general. The chapters on performance tools and how to benchmark code were particularly helpful.
4 of 5 people found the following review helpful:
3.0 out of 5 stars
Too much overview,
By A Customer
This review is from: Enterprise Java Performance (Paperback)
There isn't enough detail for my tastes. The EJB chapter is brief at best with very few actual tips. I would recommend Dov Bulka's book (even though there isn't any EJB in this book either)
Share your thoughts with other customers: Create your own review
|
|
Suggested Tags from Similar Products(What's this?)Be the first one to add a relevant tag (keyword that's strongly related to this product).
|
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
