辛格尔顿在Java中对象的集合，垃圾收集

Question

我使用的是单有关在运行时给予每个对象的唯一副本：

Car object1= CarFactory.createCar(id); 

其中createCar方法是：

private static ArrayList<Car> cars= new ArrayList<Car>(); 

public static synchronized Car createCar(int id){ 
    Car result= new Car(id); 
    int index= cars.indexOf(result); 
    if (index==-1){ 
     cars.add(result); 
     return result; 
    } else { 
     return cars.get(index); 
    } 
} 

问题在于，通过这种方法，每辆车总是具有“汽车”集合的参考，并且对象的内存永远不会释放。我该如何改进它？

Answer 1

使用一个WeakReference在将对象放入列表之前先包装这些对象。例如：

private static List<WeakReference<Car>> cars = new ArrayList<WeakReference<Car>>(); 

public static synchronized Car createCar(int id) { 
    WeakReference<Car> result= new WeakReference<Car>(new Car(id)); 
    int index= cars.indexOf(result); 
    if (index==-1){ 
     cars.add(result); 
     return result.get(); 
    } else { 
     return cars.get(index).get(); 
    } 
} 

注意：这不是生产代码。在使用之前，你必须建立更多的保护措施。

Answer 2

我假设你可以保留一个列表WeakReference s。弱引用不足以保持垃圾收集对象。

例：

List<WeakReference<Point>> list = new ArrayList<>(); 
    Point p = new Point(); 
    list.add(new WeakReference<>(p)); 
    System.out.println(p); 
    System.out.println(list.get(0).get()); 

    p = null; 

    System.gc(); 
    System.gc(); 
    System.gc(); 
    System.gc(); // hopefully the GC collects p by now 

    System.out.println(list.get(0).get()); // null! 

但是，除非你创建了大量的Car S和内存实际上的问题，它可能是不值得的麻烦。

Answer 3

这是一个黑客位，但你可以使用

WeakHashMap<Car,WeakReference<Car>> cars=new WeakHashMap<Car,WeakReference<Car>>(); 

public static synchronized Car createCar(int id){ 
    Car result= new Car(id); 
    WeakReference<Car> weakCar=cars.get(result); 
    if(weakCar==null){ 
     cars.put(new WeakReference(result)); 
     return result; 
    } 
    Car val= weakCar.get(); 
    if (val==null){//it may have been collected between cars.get() and weakCar.get() 
     cars.put(new WeakReference(result)); 
     return result; 
    } else { 
     return val; 
    } 
} 

请注意，您所需要的weakref的价值，因为价值被认为是一个强大的裁判