不灭的焱

Heap Pollution

首先来看下什么是Heap Pollution(堆污染)。

在Java编程语言中， 当一个 可变泛型参数 指向一个 无泛型参数 时，堆污染(Heap Pollution)就有可能发生。

举例一：

创建一个方法，空实现即可，如下所示

public static void varagMethod(Set<Integer> objects) {

}

此方法接受的是一个泛型为Integer类型的Set集合，假如我们将一个没有泛型的Set对象传给此方法时，则有可能造成堆污染，如下所示

public static void main(String[] args) {
    Set set = new TreeSet();

    set.add("abc");

    varagMethod(set);
}

以上代码，我们将一个无泛型的Set传递给了varagMethod方法，此时就有可能造成堆污染。当发生这种情况时，编译器可以检测到，并给我们 Warning，如下

而Heap Pollution有可能导致更严重的后果 : ClassCastException, 我们在刚才的varagMethod方法中添加几行代码如下：

public static void varagMethod(Set<Integer> objects) {
    objects.add(new Integer(10));
}

然后修改下main方法

public static void main(String[] args) {
    Set set = new TreeSet();

    varagMethod(set);

    Iterator<String> iter = set.iterator();
    while (iter.hasNext()) {
        String str = iter.next();   // ClassCastException thrown
        System.out.println(str);
    }
}

然后重新运行一下，程序直接 Crash！！！

可以看到，程序报了一个ClassCastException(类型转换错误)，这是因为Java允许我们将一个无泛型参数的Set对象传递给varagMethod方法，并且我们在varagMethod方法中，给传入的Set对象添加了一个Integer对象，之后我们遍历set集合时，将Set中第一个元素强转成String，很明显Integer不能转化为String对象

举例二：

像ArrayList<Number>,ArrayList<String>被参数化类型是非具体化类型。一个非具体化类型在运行时完全是不可以用的。

在编译的时候，编译器经历一个类型擦除过程，在这个过程中，会擦除参数类型类型被参数化信息，这样保证在泛型出现之前应用程序和java库能够很好的二进制兼容。

当一个被参数化变量指向一个非参数化对象的时候，Heap Pollution就发生了：

List         l  = new ArrayList<Number>();
List<String> ls = l;       // unchecked warning
l.add(0, new Integer(42)); // another unchecked warning
String s = ls.get(0);      // ClassCastException is thrown

在类型擦除过程中，类型ArrayList<Number>和List<String>分别成为ArrayList和List

这个变量ls被参数化List<String>，当l引用赋给它，编译器生成了未检查警告？

 

编译时，在add语句里编译器生成另一个未检查警告，因为编译器无法知道变量l参照ArrayList<Number>类型还是List<String>类型，可是在get语句里编译器没能产生警告或者错误，在调用get方法，本想取到一个String对象，结果抛出ClassCastException异常

 

当静态类型List<Number> l赋给静态类型List<String>的时候，Heap Pollution发生了，但为什么这样赋呢？主要是因为保护不支持泛型javaSE版本向后兼容

 

另外，当add方法调用时，and方法形式参数是String，实际参数是Integer,因此，Heap Pollution 也发生了，编译器仍然允许这个方法调用，是因为类型擦除时，and方法第二个形式参数变成了Object，Integer是Object子类型，因此编译器允许这样做。

可变参数方法 和 非具体形式参数

看看下面这个方法 ArrayBuilder.addToList 的例子，这是个可变的参数的方法，主要将T类型的对象放入List listArg

import java.util.*;

public class ArrayBuilder {

    public static <T> void addToList(List<T> listArg, T... elements) {
        for (T x : elements) {
            listArg.add(x);
        }
    }

    public static void faultyMethod(List<String>... l) {
        Object[] objectArray = l;  // Valid
        objectArray[0] = Arrays.asList(new Integer(42));
        String s = l[0].get(0);    // ClassCastException thrown here
    }

}

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class HeapPollutionExample {

    public static void main(String[] args) {

        List<String> stringListA = new ArrayList<String>();
        List<String> stringListB = new ArrayList<String>();

        ArrayBuilder.addToList(stringListA, "Seven", "Eight", "Nine");
        ArrayBuilder.addToList(stringListA, "Ten", "Eleven", "Twelve");
        List<List<String>> listOfStringLists = new ArrayList<List<String>>();
        ArrayBuilder.addToList(listOfStringLists, stringListA, stringListB);

        ArrayBuilder.faultyMethod(Arrays.asList("Hello!"), Arrays.asList("World!"));
    }
}

javaSE 7 的编译器对这个方法ArrayBuilder.addToList 生成下面的警告

warning: [varargs] Possible heap pollution from parameterized vararg type T

当编译器遇到可变的方法，它将可变的形式参数为数组，在Java语言里，不允许参数化数组的创建，对这ArrayBuilder.addToList方法，编译器将可变形式参数T... elements转化为形式参数T[] elements数组。因为类型擦涂的原因，编译器最终转化为形式参数Object[] elements，因此，Heap Pollution是有可能的。更多信息，请看下一节。

带有潜在安全漏洞 可变的非具体化 形式参数的方法

该方法arraybuilder.faultymethod表明为什么编译器警告您对这几种方法

这个方法把一个可变的非具体形式参数赋给了一个Object类型数组objectArgs：

Object[] objectArray = l;

这个语句潜伏了一个Heap Pollution问题

在这个语句编译器不生成未检查警告，在List<String>... l转化为List[] l 的时候已经提示未检查警告，这个l是这个List[]类型，是Object[]子类型，因此这句是对的。

因此，当你赋任意类型List对象到objectArray数组的元素，如下所示：

objectArray[0] = Arrays.asList(new Integer(42));

编译器不会警告或者报错

假设你用用下面的语句调用ArrayBuilder.faultyMethod

ArrayBuilder.faultyMethod(Arrays.asList("Hello!"), Arrays.asList("World!"));

在运行时，JVM在下面语句抛出 ClassCastException 异常

String s = l[0].get(0);    // ClassCastException thrown here

可变的非具体化 形式参数的方法消除警告

如果你定义了可变的参数化方法，并且能保证该方法体不会抛出ClassCastException异常，你可以通过下面一些选项来消除警告

•  添加下面的注解

@SafeVarargs

• 添加下面的注解

@SuppressWarnings({"unchecked", "varargs"})

• 使用编译选项

-Xlint:varargs

 

例如：下面ArrayBuilder类有两个另外的addToList2 and addToList3方法

public class ArrayBuilder {

    public static <T> void addToList(List<T> listArg, T... elements) {
        for (T x : elements) {
            listArg.add(x);
        }
    }

    @SuppressWarnings({"unchecked", "varargs"})
    public static <T> void addToList2(List<T> listArg, T... elements) {
        for (T x : elements) {
            listArg.add(x);
        }
    }

    @SafeVarargs
    public static <T> void addToList3(List<T> listArg, T... elements) {
        for (T x : elements) {
            listArg.add(x);
        }
    }

    // ...

}

 

public class HeapPollutionExample {

    // ...

    public static void main(String[] args) {

        // ...

        ArrayBuilder.addToList(listOfStringLists, stringListA, stringListB);
        ArrayBuilder.addToList2(listOfStringLists, stringListA, stringListB);
        ArrayBuilder.addToList3(listOfStringLists, stringListA, stringListB);

        // ...

    }
}

在这个例子，编译器生成下面警告：

• addToList:

            在方法定义：[unchecked] Possible heap pollution from parameterized vararg type T

            在方法调用：[unchecked] unchecked generic array creation for varargs parameter of type List<String>[]

• addToList2:

            在方法调用：[unchecked] unchecked generic array creation for varargs parameter of type

            在方法定义：没有警告

• addToList3:

           在方法定义和调用都没有警告

注意：在java SE 5和6，程序员需要保证他调用的方法不会Heap Pollution发生，如果这个方法不是这个程序员写的，这很难保证，但在java SE 7中，可保证不会发生Heap Pollution！

 

 

参考：

https://blog.csdn.net/zxm317122667/article/details/78400398

https://blog.csdn.net/sixianfeng/article/details/6838755