Java 2 SDK 1.2.1_03

These enhancements are new in the Solaris 7 11/99 software release. For more information, see Java 2 SDK Developer's Guide for Solaris.

Heap Inspection Tool

This diagnostic tool for interactively killed programs is accessible from the SIGQUIT handler menu. It can be used to find memory leaks in your programs. A memory leak occurs when a program inadvertently retains objects, preventing the garbage collector from reclaiming the memory. Heap inspection presents a per-class breakdown of the objects in the heap, sorted by total amount of memory consumed. You can then examine reference chains to selected objects to see what is keeping them alive.

Double-Word Alignment to 8-Byte Boundaries in the Heap

Double-word (longs and doubles) values are now aligned to 8-byte boundaries in the heap. This improves the performance of both native code and JIT-compiled Java code while ensuring correctness of volatile double-word values on SPARC systems. However, if your application allocates and retains many small objects, you may need to increase your heap size(s) slightly, since these objects will be allocated in multiples of 8 bytes, increasing your memory usage.

Optimizing JIT Compiler

The Java 2 SDK includes an optimizing JIT compiler which improves performance without sacrificing application start-up time. Specifically, the JIT compiler has improved in its ability to identify optimization opportunities, translating frequently invoked methods and methods with loops into highly efficient native code.

Enhanced Memory Management System

The Java Virtual Memory (JVM) also includes a highly optimized memory system, making memory allocation and garbage collection more efficient. It is a non-conservative, fully compacting, generational memory system which uses direct pointers. This feature increases batch program performance and reduces disruptive garbage collection pauses in interactive programs.

Faster Thread Synchronization

The JVM has significantly improved implementations of the Java platform's synchronization primitives. These implementations make concurrent programs more efficient and decrease the impact of the synchronization primitives on single-threaded application performance.