On 11/02/2023 06:31, Michael Strauß wrote:
I think that we are conflating two distinct questions in this discussion:
1. The first question is whether a listener that is registered on an
ObservableValue should prevent the ObservableValue from being eligible
for garbage collection.
This should never be the case, unless the listener does this by
accident. The ObservableValue and listener can both be GC'd if the
ObservableValue isn't referenced any more. Without a reference to the
ObservableValue, you can't change it any more, and thus can't trigger
the listener anymore. At that point, there's no need to keep either around.
I've always advocated the opposite: the ObservableValue should prevent
its listeners from being eligible for GC. Yet, in JavaFX, with weak
listeners, this can easily happen (even though the "stub" is still
there). This is what leads to hard to reproduce behavior as it relies
on an unpredictable external event: garbage collection.
All I'm trying to do is to provide more tools to do timely removal of
listeners and make it about as easy to do as weak listeners, but without
the unpredictable behavior. It is just jarring to see even more weak
listeners being introduced considering all the downsides of this approach.
2. The second question is whether the object contained in an
ObservableValue should hold a strong reference back to the
ObservableValue.
I'm only addressing the second question here. ObservableValue is a
property system: it allows developers to declare named values (much
like fields, but in addition to fields, it also allows observers to
see when the value was changed). It seems obvious to me that, while a
field refers to its value, the value of a field should not magically
refer back to the field itself (or its declaring object). Unless, of
course, the back-reference is manually added by the developer.
Similarly, the value of an ObservableValue should not magically refer
back to the ObservableValue; it is a one-way dependency by default.
This one-way dependency makes a lot of sense: it binds the lifetime of
the contained value to the lifetime of the property wrapper. The
inverse makes no sense: why should the lifetime of the property
wrapper be bound to the lifetime of its value? Plain fields don't work
like this, neither do Beans, C#'s language properties, WPF's
DependencyProperty, or any other property system that I've come
across.
And that's how most implementations in JavaFX work. Consider
ObjectProperty: the contained value will not refer to ObjectProperty,
regardless of whether listeners are registered on ObjectProperty.
I don't think I ever said the value should refer back to its property,
so I think we're on the same frequency here.
However, if you are wrapping observable into observable you are actually
doing what bindings are doing, as you can see these as wrappers as well.
Handling the relationship between bindings with weak listeners is what
results in the unpredictable semantics.
The dual nature of ListProperty is what is the root cause of the
problems. It is basically an ObjectProperty<ObservableList> that
implements ObservableList itself and offers some convenience that could
have been provided differently; but it doesn't act like an
ObservableList like ObservableArrayList would, and it doesn't act like
an ObservableValue like ObjectProperty would.
In a fluent binding chain like flatMap().map().orElse(), each part of
the chain strongly refers to its source (ie. "orElse" refers to "map" as
its source). When the chain is observed itself, then the opposite is
also true ("map" refers to "orElse" as "orElse" is a party interested in
"map"s invalidations/changes).
Replace "orElse" with "ListProperty" and "map" with "ObservableList" and
it's incredibly similar.
But ListProperty is an anomaly: it adds a ListChangeListener to its
contained list, which causes the contained list to magically refer
back to ListProperty without the intervention of the developer. This
violates the expectation that there's a one-way dependency between an
ObservableValue and its contained value.
It's not a normal value though, it's also an Observable, and with any
binding, there are references back and forth.
In what situation would this be a problem though, assuming the
ListProperty itself is actively in use? Remember that I'm proposing this
strong reference from ObservableList to ListProperty is only present
when the ListProperty itself is being observed.
The anomaly is caused by the decision to have ListProperty also
implement ObservableList: this makes it looks like ListProperty (this
is our ObservableValue) is actually the same thing as its contained
value (the ObservableList). But it's not, from the perspective of
ObservableValue these are two very distinct things. One is the
wrapper, the other is the contained value.
Purely as an implementation detail, ListProperty needs the internal
ListChangeListener to replay the changes of its contained list, in
order to perfectly masquerade as its contained list. But
implementation details shouldn't change the semantics of the
fundamental API, and this is why the internal dependency between
ListProperty and its contained list needs to be broken by a weak
reference.
Note that I'm not talking about listener semantics at all. This is
just about the semantics that govern the relationship between an
ObservableValue and its contained value. Florian's PR is a targeted
fix for this very specific bug, and I remain convinced that this is a
bug.
Furthermore, fixing this bug has no bearing on whether and how we
address question 1, which you are passionate about. Leaving the
current behavior as-is does not bring us closer to having "sticky
listeners". It seems to me that much of what you've written is an
endorsement for sticky listeners, but does not address the very narrow
problem of the PR in question.
The decision to have ListProperty implement both ObservableList and
ObservableValue is indeed as you say an "anomaly". These two interfaces
can't be implemented correctly in a single class and I think this is
where the problems originate -- it can only perfectly mimick one of
these. They both implement Observable for example, which specifies
methods for invalidation listeners. For ObservableValue this would need
to trigger when its value (a reference to the list as returned by
`getValue`) is invalidated, while for ObservableList it would trigger
when any mutation occurs.
On top of that, the ObservableValue part doesn't behave like any other
ObservableValue. Calling `get` gets you the ObservableList, but adding a
ChangeListener triggers many times with nonsense old and new values when
modifying the underlying list (ie. something like: "old value = [A],
current value = [A]" when adding "A" to an empty list).
I understand the desire to have something better than
"ObjectProperty<ObservableList<T>>" and so "ListProperty<T>" was born.
But you can also just use the ObservableList directly (without wrapper);
this is 99% effective already, with only a few downsides:
1) I can't bind to empty/size
2) I can't replace the entire list efficiently (requires clear/addAll)
3) There is no change listener (only list change listener)
1) can easily be fixed by just having a convenient way to construct
these bindings as all that is needed is to add an invalidation listener
to the observable list, and a computeValue that calls `size` or
`empty`. These can probably just be default methods in `ObservableList`.
2) could probably be done with a default method (but I haven't really
looked much into it). By default it can do a clear/addAll, allowing
smarter more efficient implementations to override this. These
implementations never implement `ObservableValue` -- it's already
observable, and just as distinct as a boolean or double; there is no
need to wrap it again.
3) there are already list change listeners; change listeners offer
nothing over these or invalidation listeners, unless they could
correctly return the original list as old value; as it is, they're worse
than useless; not having them is actually better than having broken
ones, less confusing too.
But the test shouldn't ever fail, because the ObservableList that is
wrapped by ListProperty should never keep a strong reference to the
ListProperty, even if the ListProperty is itself observed.
Why should it work that way? The alternative is that my listener is
discarded without my knowledge.
You didn't add a listener to the contained list; you added a listener
to the property wrapper. This listener is not discarded.
It may seem like it was, but that's only because ListProperty fooled
us into thinking it was the same thing as its contained list.
I added it to an ObservableList, an interface with a contract, which may
or may not be a ListProperty; this contract is what ListProperty claims
to implement.
If I have two ObservableList's, A and B, that I received from somewhere,
the interface documentation tells me what to expect. For some reason
though, if I add an invalidation listener to A it keeps working, but if
I add it to B, it breaks after a GC.
A is an ObservableArrayList
B is a ListProperty
An interface is supposed to be solid contract that you can rely upon.
ListProperty acts like they're just guidelines and does its own thing
whenever the gap between ObservableList and ObservableValue is too hard
to reconcile easily.
--John