Enterprise Java Performance - Softcover

Halter, Steven; Munroe, Steven

Softcover

ISBN 10: 0130172960 ISBN 13: 9780130172969

Publisher: Prentice Hall Ptr, 2000

Synopsis

The authors present a guide to the complexity of running business codes on a massive system with a large, heterogeneous user population. They explore performance issues and offer instruction on designing a framework suitable to a growing business. They outline general concepts and offer specific suggestions, illustrated with actual code. Technologies discussed include JVM/JIT, SanFrancisco, Enterprise JavaBeans, CORBA, and Jini connection technology. Annotation c. Book News, Inc., Portland, OR (booknews.com)

About this title

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.

Edition details

• Publisher: Prentice Hall Ptr
• Publication date: 2000
• ISBN 10: 0130172960
• ISBN 13: 9780130172969
• Binding: Paperback
• Language: English
• Edition number: 1
• Number of pages: 402