Realistically real-time
Javolution creator Jean-Marie Dautelle benchmarks various methods to reduce the worst-case execution time of Java applications.
Jean-Marie Dautelle,
April 2008
Multicore processing for client-side Java applications
Is it acceptable that Java collection-sorting routines typically perform no faster on newer multicore machines than on single-core
ones? No it's not! Kirill Grouchnikov shows you how to leverage the JDK 6 concurrency utilities to improve the processing
speed of core array-sorting algorithms by up to 35 percent.
Kirill Grouchnikov,
September 2007
Java Kernel plan proceeds
The kernel formerly known as Java Browser Edition is planned for release in early 2008.
Paul Krill,
August 2007
Introducing continuous integration
How continuous is your integration and what could your team be doing to improve it? A JavaWorld excerpt from Continuous Integration:
Improving Software Quality and Reducing Risk (Addison-Wesley Professional, June 2007).
Paul Duvall, Steve Matyas, Andrew Glover,
June 2007
The wise work manager for context-based scoping
This article examines the possibilities for high-performance Java Platform Enterprise Edition applications using context-scoped
threads created by the application server with the Work Manager API.
Ravi Shankar Nair, Adrian Farolan, and Narendra Govindu,
January 2007
Accelerate WSS applications with VTD-XML
Real-world implementations of the Web Services Security standards generally exhibit poor performance characteristics. VTD-XML
can solve some of these performance issues by speeding up parsing.
Jimmy Zhang,
January 2007
Hyper-threaded Java
Computer systems capable of true concurrency are becoming increasingly affordable. This article shows you how to make time-consuming
tasks concurrent using the Java concurrency API, so your programs will run as fast as possible on newer systems.
Randall Scarberry,
November 2006
Solving common Java EE performance problems
In this article, an excerpt from Pro Java EE 5 Performance
Management and Optimization, (Apress, May 2006) Steven Haines
shares the common problems he faces when performance-tuning
enterprise Java applications.
Steven Haines,
June 2006
Improve availability in Java enterprise applications
In today's 24-7 world, high-availability is an important
requirement for any Web application. Specially designed
infrastructures can help increase the availability of Web
applications, but infrastructures by themselves do not make
applications highly available. This article focuses on the design
of high availability applications. The authors discuss best
practices drawn from their work in designing Java EE (Java
Platform, Enterprise Edition) applications that maintain 100
percent availability.
Ajay Raina, John Jimenez, Govind Nishar and Ning Yan,
December 2005
Maximize J2EE and database interoperability for performance
Most application performance management (APM) solutions target and
analyze the performance issues of only a single tier in a J2EE
application. This approach is not enough for solving the
performance problems of complex architectures. The right APM tool
should let you drill down from the J2EE tier into the database tier
to ensure performance issues are quickly resolved.
Robert Maness,
February 2005
Boost Tomcat performance for static content
PippoProxy is a 100 percent pure Java HTTP proxy designed and
implemented for Tomcat that can be used instead of standard
Apache-Tomcat solutions. It addresses the need for a Java HTTP
proxy in those cases where standard Apache-Tomcat configurations
cannot be deployed because of internal security policies, because
no Apache Web server is available, or because higher performance is
required. Thanks to its static content caching, PippoProxy provides
a higher performance for static content delivery. It does not
require any optional modules or even a Web server for connecting
Tomcat, and it can be easily configured and deployed using Apache
Ant.
Gino Tesei,
February 2005
Tackle Java server capacity problems
Improving Java server capacity requires simulating the server under
load. Creating a simulation, collecting data, and analyzing the
results can prove challenging to many developers. This article's
simple concrete example introduces the concepts and tools of
performance analysis for Java servers. Author Ivan Small then uses
this example to study the effects of excessive request-time memory
usage and synchronization contention.
Ivan Small,
February 2005
Pool resources using Apache's Commons Pool Framework
Resource pooling is not new and is being widely used to conserve
and optimize the usage of resources like threads, sockets, and
database connections. Web server implementations routinely use
thread pool implementations for performance and scalability
reasons. Commons Pool, from the Apache Software Foundation, may not
be the first when it comes to implementation, but it deserves its
own place for defining a framework that allows any arbitrary object
to be pooled. This article discusses Commons Pool and shows how to
use it to implement a thread pool.
Murali Kosaraju,
January 2005
The timestamp-based caching framework: Current data with peak performance
Java developers frequently must create numerous complex objects
from JDBC (Java Database Connectivity) result sets retrieved from a
database. This operation's performance often proves suboptimal,
because of object churning: complex objects are created,
used, and garbage-collected by the JVM with every user request.
Caching these objects seems an obvious solution. However, in most
real-time systems, objects often have time-sensitive information,
such as pricing or availability, which may change randomly but
cannot be returned as stale. These types of objects pose unique
challenges, because they have no reliable time-to-live attribute,
and thus cannot be stored in a simple cache. To address the
challenge of caching time-sensitive objects, author Greg Nudelman
created a timestamp-based caching framework, which he presents in
this article. This framework guarantees delivery of the most
up-to-date information, yet decreases object churning. The use of
this handy caching code in those trouble spots where object
churning rears its ugly head can dramatically boost your
application performance, and put a smile on the face of your users
and your boss.
Greg Nudelman,
January 2005
Achieve bottleneck-free grid applications
Though grid computing can benefit compute-heavy applications,
bottlenecks between grid applications and databases can negate its
advantages. In this article, Christopher Keene explains how to
tackle the data management bottlenecks associated with grid
computing.
Christopher Keene,
August 2004
Recent top five:
Let's talk about exceptions ...
How do you handle exceptions? Do you think upfront about the type of exceptions that you want to catch or do you just let
the outside world handle it?
-- Jeroen van Bergen in JW Blogs
