javadoc | javadocs for JavaFX -

When you invoke clear() on a reference object, it will only clear this particular Reference object without any impact on the rest of your application and no special memory semantics. It’s exactly like you have seen in the code, an assignment of null to a field which has no volatile modifier.

Mind the documentation of clear():

This method is invoked only by Java code; when the garbage collector clears references it does so directly, without invoking this method.

So this is not related to the event of the GC clearing a reference. Your assumption “that all threads will see it cleared” when the GC clears a reference is correct. The documentation of WeakReference states:

Suppose that the garbage collector determines at a certain point in time that an object is weakly reachable. At that time it will atomically clear all weak references to that object and all weak references to any other weakly-reachable objects from which that object is reachable through a chain of strong and soft references.

So at this point, not only all threads will agree that a weak reference has been cleared, they will also agree that all weak references to the same object have been cleared. A similar statement can be found at SoftReference and PhantomReference.

The Java Language Specification, §12.6.2. Interaction with the Memory Model refers to points where such an atomic clear may happen as reachability decision points. It specifies interactions between these points and other program actions, in terms of “comes-before di” and “comes-after di” relationships, the most import ones being:

If r is a read that sees a write w and r comes-before di, then w must come-before di.

If x and y are synchronization actions on the same variable or monitor such that so(x, y) (§17.4.4) and y comes-before di, then x must come-before di.

So, the GC action will be inserted into the synchronization order and even a racy read could not subvert it, but it’s important to keep in mind that the exact location of the reachability decision point is not known to the application. It’s obviously somewhere between the last point where get() returned a non-null reference or refersTo(null) returned false and the first point where get() returned null or refersTo(null) returned true.

For practical applications, the fact that once the reference reports the object to be garbage collected you can be sure that it won’t reappear anywhere¹, is enough. Just keep the reference object private, to be sure that not someone invoked clear() on it.

¹ Letting things like “finalizer resurrection aside”

Update: Version 1.6.9 has been released and should fix this issue! 🎉

This is actually a known bug, which is now open for quite a while: OSSRH-66257. There are two known workarounds:

As a workaround, use --add-opens to give the library causing the problem access to the required classes:

This failure is likely due to an issue between java 17 and older lombok versions. Building with java 17.0.1, lombok 1.18.20 and maven 3.8.1 caused a vague "Compilation failure" for me as well. I upgraded to maven 3.8.3 which also failed but provided this detail on the failure:

java.lang.NullPointerException: Cannot read field "bindingsWhenTrue" because "currentBindings" is null

Searching for this failure message I found this issue on stackoverflow leading me to a bug in lombok. I upgraded to lombok 1.18.22 and that fixed the compilation failure for a successful build.

In this case, the pending intent for the geofence needs to use FLAG_MUTABLE while the notification pending intent needs to use FLAG_IMMUTABLE. Unfortunately, they have not updated the documentation or the codelabs example for targeting Android 12 yet. Here's how I modified the codelabs geofence example to work.

First, update gradle to target SDK31.

In HuntMainActivity, change the geofencePendingIntent to:

I've managed to stop this by clicking on the red square button near the end of the line with "Download sources and javadoc" progression bar in "Progress" tab. This red button appears for a fraction of a second, so you have to be quick with clicking it.

The reactive streams specification, which reactor follows, states that all errors in a stream are terminal events - and this is what the reactor error handling documentation builds on. In order to handle an error, an error must have occurred, and that error must be terminal according to the spec. In all specification-compliant cases (which is nearly all total cases) this is true.

onErrorContinue() is, however, a rather special type of operator. It is an error-handling operator, but one that breaks the reactive specification by allowing the error to be dropped, and the stream to continue. It can be potentially useful in cases where you want continuous processing, to never stop, with an error side-channel.

That being said, it has a bunch of problems - not just that it requires specific operator support (because operators fully compliant with the reactive streams specification may completely disregard onErrorContinue() while still remaining compliant), but also a whole bunch of other issues. A few of us discussed these here if you're interested in some background reading. In future it's possible that it'll get moved to an unsafe() grouping or similar, but it's a very difficult problem to solve.

That being said, the core advice is that that's in the Javadoc at the moment, that being not to use onErrorContinue() in all but very specific cases, and instead using onErrorResume() on each individual publisher as so:

There are several specialized builders in HC 5.1 that can be used to do the same:

Kotlin doesn't have checked exceptions, consequentially there is no catch or specify requirement. So there is no need to specify any checked exception in the function header.

This also means that kotlin will not force you to catch checked exceptions thrown from any java code. its upto you if you want to catch such exception or you can choose not to.

If you want to interoperate with java then you can use @Throws

This is discussed here: https://www.reddit.com/r/cn1/comments/opifd6/a_new_approach_for_the_lifecycle_main_class/

Notice the lifecycle methods still exist and you can override them if you want but for the most part you don't really need to:

When we started Codename One we copied the convention in Java of having a very verbose lifecycle class. This seemed like a good and powerful approach when we just started. The thing about core decisions like that is that you end up accepting them as dogma even when you yourself made them.

That was just stupid and with my recent commit this should be fixed. With this your main class can derive from the new Lifecycle object and you would be able to remove a lot of boilerplate. E.g. this would be the new "Hello World":