Java 我们应该在观察者模式中使用WeakReference吗？

我正在学习并尝试用Java实现Observer模式。关于是否应该使用

WeakReference

作为主题来吸引观察者，我陷入了困境

对于下面的实现，

Subject

和

BinaryObserver

彼此都有很强的引用，这恐怕会阻止GC收集未使用的

Subject

所以我的问题是，我应该使用

列表观察者

而不是

列表观察者

Subject.java

public class Subject {

   private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
       observers.add(observer);
   }

   public void notifyAllObservers(){
       for (Observer observer : observers) {
           observer.update();
       }
   }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class BinaryObserver extends Observer{

    public BinaryObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString());
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
       Subject subject = new Subject();

       new BinaryObserver(subject);

       System.out.println("First state change: 15");
       subject.setState(15);
    }
}

BinaryObserver.java

public class Subject {

   private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
       observers.add(observer);
   }

   public void notifyAllObservers(){
       for (Observer observer : observers) {
           observer.update();
       }
   }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class BinaryObserver extends Observer{

    public BinaryObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString());
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
       Subject subject = new Subject();

       new BinaryObserver(subject);

       System.out.println("First state change: 15");
       subject.setState(15);
    }
}

ObserverPatternDemo.java

public class Subject {

   private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
       observers.add(observer);
   }

   public void notifyAllObservers(){
       for (Observer observer : observers) {
           observer.update();
       }
   }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class BinaryObserver extends Observer{

    public BinaryObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString());
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
       Subject subject = new Subject();

       new BinaryObserver(subject);

       System.out.println("First state change: 15");
       subject.setState(15);
    }
}

---

你不必使用弱引用。你现在做的很好。JavaGC已经处理循环引用。如果循环引用图是一个孤岛，Java GC将收集整个循环引用图（没有来自根的对该图的传入引用-您可以认为整个循环引用图是一个大对象，如果没有对它的引用，GC将收集这个大对象）

---

看看这个：

弱引用是邪恶的，只有当你喜欢追踪bug时才使用它们。注意：Java的GC是智能的让我修改@SleimanJneidi的语句：Java的GC是非常智能的。它的工作原理是“可达性”——如果

Subject

和

Observer

都不是“可达的”（本质上是：从

main（）

方法中的对象开始的任何对象引用链都无法访问它们），则可以收集它们。它们相互参照并不重要。这些引用只确保如果一个是可访问的，那么另一个也是可访问的。如果两者都无法联系到，它就不会让它们不必要地存活。谢谢~但是我们什么时候应该使用

WeakReference

？我认为观察者模式是<代码> WeakReference < /C>的一个很好的例子，因为在C++中，ObServer模式为弱的PTR 显示了很好的例子……@ HKAujuu u使用弱引用，如果你希望程序不可预测的依赖于GCGRIST信任GC的行为。如果您关心性能，请尝试不同的配置：gc类型（g1，并行，…），young gen空间，等等。