immutable-object | : lock : Immutable object library for PHP | Identity Management library

Partial answer: how "unsafe republication" works on OpenJDK today.
(This is not the ultimate general answer I would like to get, but at least it shows what to expect on the most popular Java implementation)

In short, it depends on how the object was published initially:

1. if initial publication is done through a volatile variable, then "unsafe republication" is most probably safe, i.e. you will most probably never see the object as partially constructed
2. if initial publication is done through a synchronized block, then "unsafe republication" is most probably unsafe, i.e. you will most probably be able to see object as partially constructed

Most probably is because I base my answer on the assembly generated by JIT for my test program, and, since I am not an expert in JIT, it would not surprise me if JIT generated totally different machine code on someone else's computer.

For tests I used OpenJDK 64-Bit Server VM (build 11.0.9+11-alpine-r1, mixed mode) on ARMv8.
ARMv8 was chosen because it has a very relaxed memory model, which requires memory barrier instructions in both publisher and reader threads (unlike x86).

1. Initial publication through a volatile variable: most probably safe

Test java program is like in the question (I only added one more thread to see what assembly code is generated for a volatile write):

Looking up an object in a cache is cheaper than creating a new object. However, if you cached every int, you would be wasting memory on objects that only get used once. Further, the larger the cache, the more expensive any lookup might become.

The choice of the interval [-5, 256] is somewhat arbitrary, but based on observations that the cache size is small enough, and those values used frequently enough, to justify caching them on startup, rather than only caching them on demand.

In your example, though, the compiler can see, while compiling the code, that 267 is used twice, and so can choose to add it to the cache, independently of the numbers that are cached on startup, before any code is compiled.

I can reproduce the shared use of 267 if I put the code in a file and execute it. If I enter each line individually in the interactive interpreter, separate objects are created: when a = 267 is executed, it isn't yet known that another use of 267 will follow, and its value isn't cached. Putting both assignments on the same line, though, does let caching happen:

I actually realized the problem after studying your github link, specifically this one: https://github.com/google/nomulus/blob/8f2a8835d7f09ad28806b2345de8d42ebe781fe6/core/src/main/java/google/registry/model/contact/ContactInfoData.java

Notice the naming structure used in the sample AutoValue Java class, it still uses the getVal and setVal

Here is a simple example based on my code that now works:

Just declare it as const, like this:

One possible solution:

Mapstruct doesn't recognize your getters in UserDto and UserStatusDto.

When you change the existing methods (like public abstract String username()) in these abstract classes to classic getters like

use rw_locks see http://tutorials.jenkov.com/java-concurrency/read-write-locks.html ; this allows to have no locking when reading only, and having (hard) locking only when there is a writer

Copy and update record expressions — the one, which allows you to write { rec with prop = val } — is a convenient shortcut for creation of new record with a few changes from existing record instance.

I may be wrong, for sure, but this syntax is allowed for record types only, while you've declared a Match class with custom constructor, which is not a record.

So you may want to use a record instead.

Let's take a look, why our approach didn't work.

First thing: you cannot access cdef-members from python. That means python doesn't see the cdef int _value, so even if __getattr__ would be called, __getattribute__(self, '_value') would throw.

Second: cdef readonly int value is more than meets the eye.

By declaring a member readonly value you define a property value which has only a getter (and no setter), that you can see in the cythonized C-code.

In the type descriptor (after all Cython creates a C-extension) of the class Bar created by Cython your can find the setters/getters of your class: