如何避免对象引用的循环依赖

在面向对象编程中，一个对象可能同时引用了另一个对象，这种引用关系如果不注意可能会出现循环依赖问题，即两个或多个对象相互引用，彼此依赖，无法被垃圾回收机制回收，导致内存泄漏。此时就需要采取一些方式来避免对象引用的循环依赖。下面介绍两种常用的方式：

方法一：使用弱引用

弱引用是一种比较常见的避免循环依赖的方式，它可以让对象之间的相互引用变为非强制性的，这样当垃圾回收器发现某个对象的所有强引用都已经被释放后，就可以回收该对象。Java中已经提供了弱引用类java.lang.ref.WeakReference，可以使用它来创建弱引用对象，示例如下：

class Person {
    private String name;
    private WeakReference<Car> car;

    public Person(String name) {
        this.name = name;
    }

    public void buyCar(Car car) {
        this.car = new WeakReference<Car>(car);
    }

    public void getPaid() {
        if(car != null && car.get() != null) {
            System.out.println("I got $" + car.get().getPrice() + " for selling " + car.get().getBrand() + ".");
        } else {
            System.out.println("I have to walk now. My car has been sold.");
        }
    }
}

class Car {
    private String brand;
    private double price;
    private Person owner;

    public Car(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public void setOwner(Person owner) {
        this.owner = owner;
    }

    public String getBrand() {
        return brand;
    }

    public double getPrice() {
        return price;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person("Tom");
        Car car = new Car("Toyota", 20000);
        person.buyCar(car);
        car.setOwner(person);

        person.getPaid(); // 输出 I got $20000.0 for selling Toyota.

        // 解除Person和Car之间的引用关系
        car.setOwner(null);
        person.buyCar(null);

        // 手动调用垃圾回收器以便观察效果
        System.gc();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        person.getPaid(); // 输出 I have to walk now. My car has been sold.
    }
}

在以上示例中，Person类持有了Car对象的弱引用。当Person不再持有Car时，即使Car还有其他对象的强引用，JVM也会认为Car是可以被回收的。通过手动调用System.gc()方法可以看到上述对象回收的效果。

方法二：使用中介对象

另一种避免循环依赖的方式是引入中介对象，即创建一个额外的对象来管理两个或多个对象之间的依赖关系。这种方式较为灵活，但需要额外的管理开销，示例如下：

class Person {
    private String name;
    private CarMediator carMediator;

    public Person(String name, CarMediator carMediator) {
        this.name = name;
        this.carMediator = carMediator;
    }

    public void buyCar(Car car) {
        carMediator.setCar(this, car);
    }

    public void getPaid() {
        Car car = carMediator.getCar(this);
        if(car != null) {
            System.out.println("I got $" + car.getPrice() + " for selling " + car.getBrand() + ".");
            carMediator.removeCar(car);
        } else {
            System.out.println("I have to walk now. My car has been sold.");
        }
    }
}

class Car {
    private String brand;
    private double price;

    public Car(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public double getPrice() {
        return price;
    }
}

class CarMediator {
    private Map<Person, Car> map = new HashMap<Person, Car>();

    public void setCar(Person person, Car car) {
        map.put(person, car);
        car.setOwner(person);
    }

    public Car getCar(Person person) {
        return map.get(person);
    }

    public void removeCar(Car car) {
        map.entrySet().removeIf(entry -> Objects.equals(entry.getValue(), car));
        car.setOwner(null);
    }
}

public class Test {
    public static void main(String[] args) {
        CarMediator carMediator = new CarMediator();

        Person person1 = new Person("Tom", carMediator);
        Person person2 = new Person("Jerry", carMediator);

        Car car = new Car("Toyota", 20000);

        person1.buyCar(car);

        person1.getPaid(); // 输出 I got $20000.0 for selling Toyota.

        person2.getPaid(); // 输出 I have to walk now. My car has been sold.
    }
}

在以上示例中，Person类不再直接持有Car对象，而是通过中介对象CarMediator来管理与其的关系，从而达到避免循环依赖的目的。

总结

弱引用和中介对象是两种避免对象引用的循环依赖的常见方式。开发者可以在实际开发中根据具体情况选择适合的方式来避免该问题的发生。