How to deal with Memory Leaks, that are caused by Binding

Question

Hi, I recently noticed (huge?) memory leaks in my application and suspect bindings to be the cause of all the evil.
I made a little test case, which confirms my suspicion:
import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
public class TestAppMemoryLeak extends Application {
    public static void main(String[] args) {
        launch(args);
    @Override
    public void start(Stage stage) throws Exception {
        VBox root = new VBox();
        Button button = null;
        for (int i = 0; i < 100000; i++) {
            button = new Button();
            button.textProperty().bind(text);
            button.textProperty().unbind(); // if you don't call this, you can notice the increased memory of the java process.
        root.getChildren().add(button);
        Scene scene = new Scene(root);
        stage.setScene(scene);
        stage.show();
    private StringProperty text = new SimpleStringProperty("test");
}Now the problem is, HOW can I know, when a variable is no longer needed or overwritten by a new instance.
Just an example:
I have a ListView with a Cell Factory. In the updateItem method, I add a ContextMenu. The textProperty of each MenuItem is bound to a kind of global property, like in the example above. I have to do it in the updateItem method, since the ContextMenu differs depending on the item.
So every time the updateItem method is called a new ContextMenu is created, which binds some properties, but the old context menus remain in memory.
I guess there could be many more example.
How can I deal with it?

Answer 1

I've dealt with this situation and created a Jira issue for it, but I also have a work-around that is a bit unwieldy but works. I'll share it with you.
The bug that deals with this (in part atleast): http://javafx-jira.kenai.com/browse/RT-20616
The solution is to use weak invalidation listeners, however they are a bit of a pain to use as you cannot do it with something simplistic as "bindWeakly"... and you need to keep a reference around to the wrapped listener otherwise it will just get garbage collected immediately (as it is only weakly referenced). Some very odd bugs can surface if weak listeners disappear randomly because you forgot to reference them :)
Anyway, see this code below, it shows you some code that is called from a TreeCell's updateItem method (I've wrapped it in some more layers in my program, but it is essentially the same as an updateItem method):
public class EpisodeCell extends DuoLineCell implements MediaNodeCell {
  private final WeakBinder binder = new WeakBinder();
  @Override
  public void configureCell(MediaNode mediaNode) {
    MediaItem item = mediaNode.getMediaItem();
    StringBinding episodeRange = MapBindings.selectString(mediaNode.dataMapProperty(), Episode.class, "episodeRange");
    binder.unbindAll();
    binder.bind(titleProperty(), MapBindings.selectString(mediaNode.dataMapProperty(), Media.class, "title"));
    binder.bind(ratingProperty(), MapBindings.selectDouble(mediaNode.dataMapProperty(), Media.class, "rating").divide(10));
    binder.bind(extraInfoProperty(), Bindings.when(episodeRange.isNull()).then(new SimpleStringProperty("Special")).otherwise(episodeRange));
    binder.bind(viewedProperty(), item.viewedProperty());
    subtitleProperty().set("");
}This code makes use of a class called WeakBinder -- it is a helper class that can make Weak bindings and can keep track of them. When you call unbindAll() on it, all of the bindings it created before are released immediately (although they will also disappear when the Cell itself is garbage collected, which is possible because it only makes weak references).
I've tested this extensively and it solves the problem of Cells keeping references to objects with much longer life cycles (in my case, the MediaNode passed in has a longer lifecycle than the cells and so it is important to bind weakly to it). Before this would create huge memory leaks (crashing my program within a minute if you kept refreshing the Tree)... now it survives hours atleast and the Heap usage stays in a fixed range which means it is correctly able to collect all garbage).
The code for WeakBinder is below (you can consider it public domain, so use it as you see fit, or write your own):
package hs.mediasystem.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.WeakInvalidationListener;
import javafx.beans.property.Property;
import javafx.beans.value.ObservableValue;
public class WeakBinder {
  private final List<Object> hardRefs = new ArrayList<>();
  private final Map<ObservableValue<?>, WeakInvalidationListener> listeners = new HashMap<>();
  public void unbindAll() {
    for(ObservableValue<?> observableValue : listeners.keySet()) {
      observableValue.removeListener(listeners.get(observableValue));
    hardRefs.clear();
    listeners.clear();
  public <T> void bind(final Property<T> property, final ObservableValue<? extends T> dest) {
    InvalidationListener invalidationListener = new InvalidationListener() {
      @Override
      public void invalidated(Observable observable) {
        property.setValue(dest.getValue());
    WeakInvalidationListener weakInvalidationListener = new WeakInvalidationListener(invalidationListener);
    listeners.put(dest, weakInvalidationListener);
    dest.addListener(weakInvalidationListener);
    property.setValue(dest.getValue());
    hardRefs.add(dest);
    hardRefs.add(invalidationListener);
}Let me know if this solves your problem.