自从Java 1.0版本首次受到开发人员欢迎以来，Java语言的语法就没有发生过太大的变化。虽然1.1版本增加了内部类和匿名内部类，1.4版本增加了带有新的assert关键字的assertion（断定）功能，但Java语法和关键字仍然保持不变--像编译时常量一样处于静态。它将通过J2SE 1.5（代号Tiger）发生改变。

过去的J2SE版本主要关注新类和性能，而Tiger的目标则是通过使Java编程更易于理解、对开发人员更为友好、更安全来增强Java语言本身，同时最大限度地降低与现有程序的不兼容性。该语言中的变化包括generics（泛化）、autoboxing、一个增强的“for”循环、 typesafe enums（类型安全的枚举类型）、一个静态导入工具（static import facility）和varargs。

通过generics来改进类型检查

generics使你能够指定一个集合中使用的对象的实际类型，而不是像过去那样只是使用Object。generics也被称为“参数化类型”，因为在generics中，一个类的类型接受影响其行为的类型变量。

generics并不是一个新概念。C++中有模板，但是模板非常复杂并且会导致代码膨胀。C++编码人员能够仅使用C++模板，通过一些小的技巧来执行阶乘函数，然后看着编译器生成C++源代码来处理模板调用。Java开发人员已经从C++语言中学到了很多关于generics的知识，并经过了足够长时间的实践，知道如何正确使用它们。Tiger的当前计划是从健壮的Generic Java (GJ)方案演变而来的。GJ方案的口号是“使Java的类型简化、再简化。”

为了了解generics，让我们从一个不使用generics的例子开始。下面这段代码以小写字母打印了一个字符串集合：

//获得一个字符串集合
public void lowerCase(Collection c) {
  Iterator itr = c.iterator();
  while (itr.hasNext()) {
    String s = (String) itr.next();
    System.out.println(s.toLowerCase());
  }
}

这个方法不保证只接收字符串。编程人员负责记住传给这个方法什么类型的变量。Generics通过显式声明类型来解决这个问题。Generics证明并执行了关于集合包含什么东西的规则。如果类型不正确，编译器就会产生一个错误。在下面的改写代码中，注意Collection和Iterator是如何声明它们只接收字符串对象的：

public void lowerCase(
     Collection<String> c)  {
  Iterator<String> itr = c.iterator();
  while (itr.hasNext()) {
    System.out.println(
      itr.next().toLowerCase());
  }
}

现在，该代码包含了更强大的类型，但它仍然包含许多键盘类型。我们将在后面加以介绍。注意，你可以存储类型参数的任何子类型。接下来，我们将使用这个特性draw()一个形状集合。

// 获得孩子集合...
public void drawAll(Collection<Shape> c) {
  Iterator<Shape> itr = c.iterator();
  while (itr.hasNext()) {
    itr.next().draw();
  }
}

尖括号中的值被称为类型变量。参数化类型能够支持任何数量的类型变量。例如，java.util.Map就支持两个类型变量--一个用于键类型，一个用于值类型。下面的例子使用了一个带有指向一列元素对象的字符串查找键的map：

public static void main(String[] args) {
  HashMap<String, List<Element>> map =
    new HashMap<String, 
          List<Element>>();
  map.put("root", 
    new ArrayList<Element>());
  map.put("servlet", 
    new LinkedList<Element>());
}

这个类定义声明了它支持多少个类型变量。类型参数的数量必须精确地与所期望的相匹配。而且，类型变量一定不能是原始类型（primitive types）。

List<String, String> // takes one
List<int>            // 无效的，原始类型

即使在期望使用一个普通类型（raw type）的时候，你也可以使用一个参数化类型。当然，你也可以反过来做，但这么做会收到一条编译时警告：

public static void oldMethod(List list) {
  System.out.println(list.size());
}

public static void main(String[] args) {
  List<String> words = 
    new ArrayList<String>();
  oldMethod(words);   // 没问题
}

这就实现了轻松的向后兼容：接受一个原始列表的老方法能够直接接受一个参数化List<String>。接受参数化List<String>的新方法也能够接受一个原始列表，但是因为原始列表不声明或执行相同的类型约束，所以这个动作会触发一个警告。可以保证的是：如果在编译时你没有得到名为unchecked（未检查）的警告，那么在运行时编译器生成的强制类型转换（cast）将不会失败。

有趣的是，参数化类型和普通类型被编译为相同的类型。没有专门的类来指定这一点，使用编译器技巧就可以完成这一切。instanceof检查可以证明这一点。

words instanceof List             // true
words instanceof ArrayList        //true
words instanceof ArrayList<String> // true

这个检查产生了一个问题：“如果它们是相同的类型，这种检查能起多大作用？”这是一条用墨水而不是用血写的约束。这段代码将产生一个编译错误，因为你不能向List<String>中添加新的Point：

List<String> list = 
  new ArrayList<String>();
list.add(new Point());  // 编译错误

但是这段代码被编译了！

List<String> list = 
  new ArrayList<String>();
((List)list).add(new Point());

它将参数化类型强制转换为一个普通类型，这个普通类型是合法的，避免了类型检查，但正如前面所解释的那样，却产生了一个调用未检查的警告：

warning: unchecked call to add(E) as a member of the raw type
 java.util.List
    ((List)list).add(new Point());
    ^

写一个参数化类型

Tiger提供了一个写参数化类型的新语法。下面显示的Holder类可以存放任意引用类型。这样的类很便于使用，例如，通过引用语义支持CORBA传递，而不需要生成单独的Holder类：

public class Holder<A> {
  private A value;
  Holder(A v) { value = v; }
  A get() { return value; }
  void set(A v) { value = v; }
}

使用一个参数化的Holder类型，你能够安全地得到和设置数据，而不需进行强制类型转换：

public static void main(String[] args) {
  Holder<String> holder = 
    new Holder<String>("abc");
  String val = holder.get();  // "abc"
  holder.set("def");
}

“A”类型参数名可以是任何标准的变量名。它通常是一个单一的大写字母。你也可以声明类型参数必须能够扩展另一个类，如下所示：

// 也可以
public class Holder<C extends Child>

关于是否能够声明任何其他的类型参数仍然存在争议。你对generics了解的越深，你需要的特殊规则就越多，但是特殊规则越多，generics就会越复杂。

Tiger中设计用来保存线程局部变量（thread local variable）的核心类java.lang.ThreadLocal，将可能变得与下面这个 Holder类的作用类似：

public class ThreadLocal<T> {
  public T get();
  public void set(T value);
}

我们也将看见java.lang.Comparable的变化，允许类声明与它们相比较的类型：

public interface Comparable<T> {
  int compareTo(T o);
}
public final class String implements Comparable<String> {
  int compareTo(String anotherString);
}

Generics不仅仅用于集合，它们有更为广泛的用途。例如，虽然你不能基于参数化类型（因为它们与普通类型没有什么不同）进行捕捉（catch），但是你可以抛出(throw)一个参数化类型。换句话说，你可以动态地决定throws语句中抛出什么。

下面这段令人思维混乱的代码来自generics规范。该代码通过扩展Exception的类型参数E定义了一个 Action接口。Action类有一个抛出作为E 出现的任何类型的run()方法。然后，AccessController类定义一个接受Action<E>的静态exec()方法，并声明exec()抛出E。声明该方法自身是参数化的需要该方法标记（method signature）中的特殊<E extends Exception>。

现在，事情变得有点棘手了。main()方法调用在Action 实例（作为一个匿名内部类实现）中传递的AccessController.exec()方法。该内部类被参数化，以抛出一个 FileNotFoundException。main()方法有一个捕捉这一异常类型的catch语句。如果没有参数化类型，你将不能确切地知道run()会抛出什么。有了参数化类型，你能够实现一个泛化的Action类，其中run()方法可以任意实现，并可以抛出任意异常（Exception）：

interface Action<E extends Exception> {
  void run() throws E;
}

class AccessController {
  public static <E extends Exception>
  void exec(Action<E> action) throws E {
    action.run();
  }
}

public class Main {
  public static void main(String[] args) {
    try {
      AccessController.exec(
      new Action<FileNotFoundException>() {
        public void run()
        throws FileNotFoundException {
          // someFile.delete();
        }
      });
    }
    catch (FileNotFoundException f) { }
  }
}

协变返回类型

下面进行一个随堂测验：下面的代码是否能够成功编译？

class Fruit implements Cloneable {
  Fruit copy() throws
    CloneNotSupportedException {
   return (Fruit)clone();
  }
}
class Apple extends Fruit 
           implements Cloneable {
  Apple copy() 
    throws CloneNotSupportedException {
   return (Apple)clone();
  }
}

答案：该代码在J2SE 1.4中不能编译，因为改写一个方法必须有相同的方法标记（包括返回类型）作为它改写的方法。然而，generics有一个叫做协变返回类型的特性，使上面的代码能够在Tiger中进行编译。该特性是极为有用的。

例如，在最新的JDOM代码中，有一个新的Child接口。Child有一个detach()方法，返回从其父对象分离的Child对象。在Child接口中，该方法当然返回Child：

public interface Child {
  Child detach();
  // etc
}

当Comment类实现detach()时，它总是返回一个Comment，但如果没有协变返回类型，该方法声明必须返回Child：

public class Comment {
  Child detach() {
    if (parent != null)
      parent.removeContent(this); 
    return this;
  }
}

这意味着调用者一定不要将返回的类型再向下返回到一个Comment。协变返回类型允许Comment 中的detach()返回 Comment。只要Comment是Child的子类就行。除了能够返回Document的DocType和能够返回Element的EntityRef，该特性对立刻返回Parent 的Child.getParent()方法也能派上用场。协变返回类型将确定返回类型的责任从类的用户（通过强制类型转换确认）转交给类的创建者，只有创建者知道哪些类型彼此之间是真正多态的。 这使应用编程接口(API)的用户使用起来更容易，但却稍微增加了API设计者的负担。

Autoboxing

Java有一个带有原始类型和对象（引用）类型的分割类型系统。原始类型被认为是更轻便的，因为它们没有对象开销。例如，int[1024]只需要4K存储空间，以及用于数组自身的一个对象。然而，引用类型能够在不允许有原始类型的地方被传递，例如，传递到一个List。这一限制的标准工作场景是在诸如list.add(new Integer(1))的插入操作之前，将原始类型与其相应的引用类型封装（box或wrap）在一起，然后用诸如((Integer)list.get(0)).intValue()的方法取出（unbox）返回值。

新的 autoboxing特性使编译器能够根据需要隐式地从int转换为Integer，从char 转换为Character等等。auto-unboxing进行相反的操作。在下面的例子中，我不使用autoboxing计算一个字符串中的字符频率。我构造了一个应该将字符型映射为整型的Map，但是由于Java的分割类型系统，我不得不手动管理Character和Integer封箱转换（boxing conversions）。

public static void countOld(String s) {
  TreeMap m = new TreeMap();
  char[] chars = s.toCharArray();
  for (int i=0; i < chars.length; i++) {
    Character c = new Character(chars[i]);
    Integer val = (Integer) m.get(c);
    if (val == null)
      val = new Integer(1);
    else
      val = new Integer(val.intValue()+1);
    m.put(c, val);
  }
  System.out.println(m);
}

Autoboxing使我们能够编写如下代码：

public static void countNew(String s) {
  TreeMap<Character, Integer> m =
    new TreeMap<Character, Integer>();
  char[] chars = s.toCharArray();
  for (int i=0; i < chars.length; i++) {
    char c = chars[i];
    m.put(c, m.get(c) + 1);  // unbox
  }
  System.out.println(m);
}

这里，我重写了map，以使用generics，而且我让autoboxing给出了map能够直接存储和检索char 和int值。不幸的是，上面的代码有一个问题。如果m.get(c)返回空值（null），会发生什么情况呢？怎样取出null值？在抢鲜版（early access release）(参见下一步)中，取出一个空的Integer 会返回0。自抢鲜版起，专家组决定取出null值应该抛出一个NullPointerException。因此，put()方法需要被重写，如下所示：

m.put(c, Collections.getWithDefault(
  m, c) + 1);

新的Collections.getWithDefault()方法执行get()函数，在该方法中，如果值为空值，它将返回期望类型的默认值。对于一个int类型来说，则返回0。

虽然autoboxing有助于编写更好的代码，但我的建议是谨慎地使用它。封箱转换仍然会进行并仍然会创建许多包装对象（wrapper-object）实例。当进行计数时，采用将一个int与一个长度为1的的 int数组封装在一起的旧方法更好。然后，你可以将该数组存储在任何需要引用类型的地方，获取intarr[0]的值并使用intarr[0]++递增。你甚至不必再次调用put()，因为会在适当的位置产生增量。使用这一方法和其他一些方法，你能够更有效地进行计数。使用下面的算法，执行100万个字符的对时间会从650毫秒缩短为30毫秒：

 
public static void countFast(String s) {
  int[] counts = new int[256];
  char[] chars = s.toCharArray();
  for (int i=0; i < chars.length; i++) {
    int c = (int) chars[i];
    counts[c]++;  // no object creation
  }
  for (int i = 0; i < 256; i++) {
    if (counts[i] > 0) {
      System.out.println((char)i + ":" 
           + counts[i]);
    }
  }
}

在C#中，我们可以看到一个类似但稍微不同的方法。C#有一个统一的类型系统，在这个系统中值类型和引用类型都扩展System.Object。但是，你不能直接看到这一点，因为C#为简单的值类型提供了别名和优化。int是System.Int32的一个别名，short是System.Int16的一个别名，double是System.Double的一个别名。在C#中，你能够调用“int i = 5； i.ToString()；”，它是完全合法的。这是因为每个值类型都有一个在它被转换为引用类型时创建的相应隐藏引用类型（在值类型被转换为一个引用类型时创建的）。

int x = 9;
object o = x;  //创建了引用类型
int y = (int) o;

当基于一个不同的类型系统时，最终结果与我们在J2SE 1.5中看到的非常接近。

public void drawAll(Collection<Shape> c) {
  Iterator<Shape> itr = c.iterator();
  while (itr.hasNext()) {
    itr.next().draw();
  }
}

public void drawAll(Collection<Shape> c) {
  for (Shape s : c) {
    s.draw();
  }
}

for (Iterator<Shape> $i = c.iterator(); 
     $i.hasNext(); ) {
  Shape s = $i.next();
  s.draw();
}

public interface Iterable<T> {
  SimpleIterator<T> iterator();
}
public interface SimpleIterator<T> {
  boolean hasNext();
  T next();
}

// C#
foreach (Color c in colors) {
  Console.WriteLine(c);
}

class PlayingCard {
  public static final int SUIT_CLUBS 
    = 0;
  public static final int SUIT_DIAMONDS 
    = 1;
  public static final int SUIT_HEARTS 
    = 2;
  public static final int SUIT_SPADES 
    = 3;
  // ...
}

class PlayingCard {
  class Suit {
     public static final Suit CLUBS 
       = new Suit();
     public static final Suit DIAMONDS 
       = new Suit();
     public static final Suit HEARTS 
       = new Suit();
     public static final Suit SPADES 
       = new Suit();
     protected Suit() { }
  }
}

class PlayingCard {
  public enum Suit { clubs, 
        diamonds, hearts, spades }
}

public class Enum<E extends Enum<E>>
     implements Comparable<E>, 
               Serializable {

out.println(Suit.clubs);       // "clubs"
out.println(Suit.clubs.name);  // "clubs"
out.println(Suit.clubs.ordinal);    // 0
out.println(Suit.diamonds.ordinal); // 1
Suit.clubs == Suit.clubs     // true
Suit.clubs == Suit.diamonds  // false
Suit.clubs.compareTo(Suit.diamonds) // -1

public enum Roman {
  I(1), V(5), X(10), L(50), C(100),
  D(500), M(1000);

  private final int value;

  Roman(int value) { this.value = value; }

  public int value() { return value; }

  public static void main(String[] args) {
    System.out.println(Roman.I);
  }
}

public abstract enum Whitespace {
  raw {
    String handle(String s) { return s; }
  },
  trim {
    String handle(String s) { 
      return s.trim(); }
  },
  trimFullWhite {
    String handle(String s) { 
      return s.trim().equals("") ? "":s; }
  };
  abstract String handle(String s);

  public static void main(String[] args) {
    String sample = " Test string ";
    for (Whitespace w : Whitespace.VALUES) 
      System.out.println(w + ": '" 
          + w.handle(sample) + "'");
}}

// C#
[Flags]
public enum Credit : byte {
  Visa = 1, MC = 2, Discover = 4 }

Credit accepted = Credit.Visa | Credit.MC;

c.WriteLine(accepted);         // 3
c.WriteLine(accepted.Format());//"Visa|MC"

import static java.lang.Math.*;
import static java.lang.System.out;

public class Test {
  public static void main(String[] args) {
    out.println(abs(-1) * PI);
  }
}

out.println(sum(1, 2, 3));

public static int sum(int args...) {
  int sum = 0;
  for (int x : args) { sum += x; }
  return sum;
}

public static void printf(String fmt, 
                        int args...) {
  int i = 0;
  for (char c : fmt.toCharArray()) {
    out.print(c == '%' ? args[i++] : c);
  }
}

public static void main(String[] args) {
  printf("My values are % and %
", 
         1, 2);
}
在Tiger版本中，你会发现采用一个新格式的invoke（）函数： invoke(Object obj, Object args...). 这看上去更加自然。
结论
J2SE1.5版努力使Java的编程更加简便、安全和更加富有表现力。这些特性和谐完美的被结合在一起。如果你跟我一样，总是喜欢用老的“for”循环，你肯定希
望你拥有Tiger。然而，需要记住的是，该规范并没有最终完成，很多地方还需要修改。管理这些变化的专家小组（JSR-14,JSR-175以及JSR-201）会在2003年
年末的beta版本发布之前，以及预期在2004年发布最终版发布之前，会做出很多修改。然而，Sun表达了对JavaOne的信心，认为总体上主要原则不会改变太多。
如果你想体验一下，那么你可以从下面的站点获取抢鲜版本。 从中你会找到可能从任何一个预览版软件都会遇到的错误，但是也会看到很多激动人心的新特性。
我强烈建议你尝试一下。

关键词 Java; 内存泄漏; GC(垃圾收集器) 引用; Optimizeit

问题的提出

　　笔者曾经参与开发的网管系统，系统规模庞大，涉及上百万行代码。系统主要采用Java语言开发，大体上分为客户端、服务器和数据库三个层次。在版本进入测试和试用的过程中，现场人员和测试部人员纷纷反映:系统的稳定性比较差，经常会出现服务器端运行一昼夜就死机的现象，客户端跑死的现象也比较频繁地发生。对于网管系统来讲，经常性的服务器死机是个比较严重的问题，因为频繁的死机不仅可能导致前后台数据不一致，发生错误，更会引起用户的不满，降低客户的信任度。因此，服务器端的稳定性问题必须尽快解决。

解决思路

　　通过察看服务器端日志，发现死机前服务器端频繁抛出OutOfMemoryException内存溢出错误，因此初步把死机的原因定位为内存泄漏引起内存不足，进而引起内存溢出错误。如何查找引起内存泄漏的原因呢?有两种思路:第一种，安排有经验的编程人员对代码进行走查和分析，找出内存泄漏发生的位置;第二种，使用专门的内存泄漏测试工具Optimizeit进行测试。这两种方法都是解决系统稳定性问题的有效手段，使用内存测试工具对于已经暴露出来的内存泄漏问题的定位和解决非常有效;但是软件测试的理论也告诉我们，系统中永远存在一些没有暴露出来的问题，而且，系统的稳定性问题也不仅仅只是内存泄漏的问题，代码走查是提高系统的整体代码质量乃至解决潜在问题的有效手段。基于这样的考虑，我们的内存稳定性工作决定采用代码走查结合测试工具的使用，双管齐下，争取比较彻底地解决系统的稳定性问题。

　　在代码走查的工作中，安排了对系统业务和开发语言工具比较熟悉的开发人员对应用的代码进行了交叉走查，找出代码中存在的数据库连接声明和结果集未关闭、代码冗余和低效等故障若干，取得了良好的效果，文中主要讲述结合工具的使用对已经出现的内存泄漏问题的定位方法。

内存泄漏的基本原理

　　在function()方法执行完毕后，vec数组已经是不可达对象，在C++语言中，这样的对象永远也得不到释放，称这种现象为内存泄漏。

　　而Java是通过垃圾收集器(Garbage Collection，GC)自动管理内存的回收，程序员不需要通过调用函数来释放内存，但它只能回收无用并且不再被其它对象引用的那些对象所占用的空间。在下面的代码中，循环申请Object对象，并将所申请的对象放入一个Vector中，如果仅仅释放对象本身，但是因为Vector仍然引用该对象，所以这个对象对GC来说是不可回收的。因此，如果对象加入到Vector后，还必须从Vector中删除，最简单的方法就是将Vector对象设置为null。

　　实际上无用，而还被引用的对象，GC就无能为力了(事实上GC认为它还有用)，这一点是导致内存泄漏最重要的原因。

　　Java的内存回收机制可以形象地理解为在堆空间中引入了重力场，已经加载的类的静态变量和处于活动线程的堆栈空间的变量是这个空间的牵引对象。这里牵引对象是指按照Java语言规范，即便没有其它对象保持对它的引用也不能够被回收的对象，即Java内存空间中的本原对象。当然类可能被去加载，活动线程的堆栈也是不断变化的，牵引对象的集合也是不断变化的。对于堆空间中的任何一个对象，如果存在一条或者多条从某个或者某几个牵引对象到该对象的引用链，则就是可达对象，可以形象地理解为从牵引对象伸出的引用链将其拉住，避免掉到回收池中;而其它的不可达对象由于不存在牵引对象的拉力，在重力的作用下将掉入回收池。在图1中，A、B、C、D、E、F六个对象都被牵引对象所直接或者间接地“牵引”，使得它们避免在重力的作用下掉入回收池。如果TR1-A链和TR2-D链断开，则A、B、C三个对象由于失去牵引，在重力的作用下掉入回收池(被回收)，D对象也是同样的原因掉入回收池，而F对象仍然存在一个牵引链(TR3-E-F)，所以不会被回收，如图2、3所示。
 　　
　　图1 初始状态

　　
　　图2 TR1-A链和TR2-D链断开，A、B、C、D掉入回收池

　　
　　图3 A、B、C、D四个对象被回收

　　通过前面的介绍可以看到，由于采用了垃圾回收机制，任何不可达对象都可以由垃圾收集线程回收。因此通常说的Java内存泄漏其实是指无意识的、非故意的对象引用，或者无意识的对象保持。无意识的对象引用是指代码的开发人员本来已经对对象使用完毕，却因为编码的错误而意外地保存了对该对象的引用(这个引用的存在并不是编码人员的主观意愿)，从而使得该对象一直无法被垃圾回收器回收掉，这种本来以为可以释放掉的却最终未能被释放的空间可以认为是被“泄漏了”。
这里通过一个例子来演示Java的内存泄漏。假设有一个日志类Logger，其提供一个静态的log(String msg)方法，任何其它类都可以调用Logger.Log(message)来将message的内容记录到系统的日志文件中。Logger类有一个类型为HashMap的静态变量temp，每次在执行log(message)方法的时候，都首先将message的值丢入temp中(以当前线程+当前时间为键)，在方法退出之前再从temp中将以当前线程和当前时间为键的条目删除。注意，这里当前时间是不断变化的，所以log方法在退出之前执行删除条目的操作并不能删除方法执行之初丢入的条目。这样，任何一个作为参数传给log方法的字符串最终由于被Logger的静态变量temp引用，而无法得到回收，这种违背实现者主观意图的无意识的对象保持就是我们所说的Java内存泄漏。

　　鉴别泄漏对象的方法

　　一般说来，一个正常的系统在其运行稳定后其内存的占用量是基本稳定的，不应该是无限制的增长的，同样，对任何一个类的对象的使用个数也有一个相对稳定的上限，不应该是持续增长的。根据这样的基本假设，我们可以持续地观察系统运行时使用的内存的大小和各实例的个数，如果内存的大小持续地增长，则说明系统存在内存泄漏，如果某个类的实例的个数持续地增长，则说明这个类的实例可能存在泄漏情况。

　　Optimizeit是Borland公司的产品，主要用于协助对软件系统进行代码优化和故障诊断，其功能众多，使用方便，其中的OptimizeIt Profiler主要用于内存泄漏的分析。Profiler的堆视图(如图4)就是用来观察系统运行使用的内存大小和各个类的实例分配的个数的，其界面如图四所示，各列自左至右分别为类名称、当前实例个数、自上个标记点开始增长的实例个数、占用的内存空间的大小、自上次标记点开始增长的内存的大小、被释放的实例的个数信息、自上次标记点开始增长的内存的大小被释放的实例的个数信息，表的最后一行是汇总数据，分别表示目前JVM中的对象实例总数、实例增长总数、内存使用总数、内存使用增长总数等。

　　在实践中，可以分别在系统运行四个小时、八个小时、十二个小时和二十四个小时时间点记录当时的内存状态(即抓取当时的内存快照，是工具提供的功能，这个快照也是供下一步分析使用)，找出实例个数增长的前十位的类，记录下这十个类的名称和当前实例的个数。在记录完数据后，点击Profiler中右上角的Mark按钮，将该点的状态作为下一次记录数据时的比较点。

　　　
　　图4 Profiler 堆视图

系统运行二十四小时以后可以得到四个内存快照。对这四个内存快照进行综合分析，如果每一次快照的内存使用都比上一次有增长，可以认定系统存在内存泄漏，找出在四个快照中实例个数都保持增长的类，这些类可以初步被认定为存在泄漏。

　　分析与定位

　　通过上面的数据收集和初步分析，可以得出初步结论:系统是否存在内存泄漏和哪些对象存在泄漏(被泄漏)，如果结论是存在泄漏，就可以进入分析和定位阶段了。

　　前面已经谈到Java中的内存泄漏就是无意识的对象保持，简单地讲就是因为编码的错误导致了一条本来不应该存在的引用链的存在(从而导致了被引用的对象无法释放)，因此内存泄漏分析的任务就是找出这条多余的引用链，并找到其形成的原因。前面还讲到过牵引对象，包括已经加载的类的静态变量和处于活动线程的堆栈空间的变量。由于活动线程的堆栈空间是迅速变化的，处于堆栈空间内的牵引对象集合是迅速变化的，而作为类的静态变量的牵引对象的集合在系统运行期间是相对稳定的。

　　对每个被泄漏的实例对象，必然存在一条从某个牵引对象出发到达该对象的引用链。处于堆栈空间的牵引对象在被从栈中弹出后就失去其牵引的能力，变为非牵引对象，因此，在长时间的运行后，被泄露的对象基本上都是被作为类的静态变量的牵引对象牵引。

　　Profiler的内存视图除了堆视图以外，还包括实例分配视图(图5)和实例引用图(图6)。

　　Profiler的实例引用图为找出从牵引对象到泄漏对象的引用链提供了非常直接的方法，其界面的第二个栏目中显示的就是从泄漏对象出发的逆向引用链。需要注意的是，当一个类的实例存在泄漏时，并非其所有的实例都是被泄漏的，往往只有一部分是被泄漏对象，其它则是正常使用的对象，要判断哪些是正常的引用链，哪些是不正常的引用链(引起泄漏的引用链)。通过抽取多个实例进行引用图的分析统计以后，可以找出一条或者多条从牵引对象出发的引用链，下面的任务就是找出这条引用链形成的原因。

　　实例分配图提供的功能是对每个类的实例的分配位置进行统计，查看实例分配的统计结果对于分析引用链的形成具有一定的作用，因为找到分配链与引用链的交点往往就可以找到了引用链形成的原因，下面将具体介绍。

　　
　　图5 实例分配图

　　
　　图6 实例引用图

　　设想一个实例对象a在方法f中被分配，最终被实例对象b所引用，下面来分析从b到a的引用链可能的形成原因。方法f在创建对象a后，对它的使用分为四种情况:1、将a作为返回值返回;2、将a作为参数调用其它方法;3、在方法内部将a的引用传递给其它对象;4、其它情况。其中情况4不会造成由b到a的引用链的生成，不用考虑。下面考虑其它三种情况:对于1、2两种情况，其造成的结果都是在另一个方法内部获得了对象a的引用，它的分析与方法f的分析完全一样(递归分析);考虑第3种情况:1、假设方法f直接将对象a的引用加入到对象b，则对象b到a的引用链就找到了，分析结束;2、假设方法f将对象a的引用加入到对象c，则接下来就需要跟踪对象c的使用，对象c的分析比对象a的分析步骤更多一些，但大体原理都是一样的，就是跟踪对象从创建后被使用的历程，最终找到其被牵引对象引用的原因。

　　现在将泄漏对象的引用链以及引用链形成的原因找到了，内存泄漏测试与分析的工作就到此结束，接下来的工作就是修改相应的设计或者实现中的错误了。

　　总结

　　使用上述的测试和分析方法，在实践中先后进行了三次测试，找出了好几处内存泄漏错误。系统的稳定性得到很大程度的提高，最初运行1~2天就抛出内存溢出异常，修改完成后，系统从未出现过内存溢出异常。此方法适用于任何使用Java语言开发的、对稳定性有比较高要求的软件系统。

　　(1)Easy:Java的语法比C++的相对简单，另一个方面就是Java能使软件在很小的机器上运行，基础解释其和类库的支持的大小约为40kb，增加基本的标准库和线程支持的内存需要增加125kb。

　　(2)分布式:Java带有很强大的TCP/IP协议族的例程库，Java应用程序能够通过URL来穿过网络来访问远程对象，由于servlet机制的出现，使Java编程非常的高效，现在许多的大的web server都支持servlet。

　　(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同，在与多重继承的处理及Java的原类模型。

　　(4)健壮特性:Java采取了一个安全指针模型，能减小重写内存和数据崩溃的可能型。

　　(5)安全:Java用来设计网路和分布系统，这带来了新的安全问题，Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的比较好。

　　(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行，编译器产生的指令字节码(Javabytecode)实现此特性，此字节码可以在任何机器上解释执行。

　　(7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好。

　　(8)多线程:Java处理多线程的过程很简单，Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一。

　　(9)Applet和servlet:能够在网页上执行的程序叫Applet，需要支持Java的浏览器很多，而applet支持动态的网页，这是很多其他语言所不能做到的。

　　基本概念

　　1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率。

　　2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。

　　3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。

　　4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。

　　5.对象的3个主要特性

　　behavior---说明这个对象能做什么.
　　state---当对象施加方法时对象的反映.
　　identity---与其他相似行为对象的区分标志.
　　每个对象有唯一的indentity 而这3者之间相互影响.

　　6.类之间的关系:

　　use-a :依赖关系
　　has-a :聚合关系
　　is-a :继承关系--例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)

　　7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。

　　例:Data类的构造器叫Data

　　new Data()---构造一个新对象，且初始化当前时间.
　　Data happyday=new Data()---把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用。

　　构造器特点:构造器可以有0个，一个或多个参数
　　构造器和类有相同的名字
　　一个类可以有多个构造器
　　构造器没有返回值
　　构造器总是和new运算符一起使用.

        8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。

　　9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包.java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。

　　10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。

　　11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。

　　12.多态:在java中，对象变量是多态的.而java中不支持多重继承。

　　13.动态绑定:调用对象方法的机制。

　　(1)编译器检查对象声明的类型和方法名。

　　(2)编译器检查方法调用的参数类型。

　　(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。

　　(4)当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。

　　(5)动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。

　　14.final类:为防止他人从你的类上派生新类，此类是不可扩展的。

　　15.动态调用比静态调用花费的时间要长。

　　16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。

　　例: public abstract string getDescripition

　　17.Java中的每一个类都是从Object类扩展而来的。

　　18.object类中的equal和toString方法。

　　equal用于测试一个对象是否同另一个对象相等。

　　toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示.
　　(toString 方法是一个很重要的方法)

　　19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。

　　20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小。

　　21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。

　　22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。

　　能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大.

　　1.在运行时分析类的能力。
　　2.在运行时探察类的对象。
　　3.实现通用数组操纵代码。
　　4.提供方法对象。

而此机制主要针对是工具者而不是应用及程序。

　　反射机制中的最重要的部分是允许你检查类的结构.用到的API有:

　　java.lang.reflect.Field 返回字段.
　　java.reflect.Method 返回方法.
　　java.lang.reflect.Constructor 返回参数.

　　方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。

　　23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。

　　24.接口不是一个类，而是对符合接口要求的类的一套规范。

　　若实现一个接口需要2个步骤:　

　　1.声明类需要实现的指定接口。
　　2.提供接口中的所有方法的定义。

　　声明一个类实现一个接口需要使用implements 关键字

　　class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口.

　　25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable

　　26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。

　　例:ActionListener 接口监听.
　　类似的API有:java.swing.JOptionPane

　　java.swing.Timer
　　java.awt.Tookit

　　27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。

　　28.内部类:一个内部类的定义是定义在另一个内部的类。

　　原因是:

　　1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。

　　2.对于同一个包中的其他类来说，内部类能够隐藏起来。

　　3.匿名内部类可以很方便的定义回调。

　　4.使用内部类可以非常方便的编写事件驱动程序。

　　29.代理类(proxy):

　　1.指定接口要求所有代码

　　2.object类定义的所有的方法(toString equals)

　　30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型。