lazy_id::Id is a thread-safe 64-bit id that only initializes itself
to a specific value when you use it rather than when you create it.
Why would this be helpful? If you need a unique per-instance
Id for your
type, usually the approach is a global atomic that you increment each time
you allocate an id. The only problem here is that now if you want to store
your type in a
static of some sort, you need to use
This can be pretty annoying if your API is most useful as a
you've been carefully designing to allow static initialization, especially
this now means the API you designed forces users to use these libraries
around your types.
In my case, I was playing around with low level threading code already, and the extra locking these imposed on all accesses felt like it completely defeated the point of my fancy data structure, and would have shown up in the public api.
crate is entirely lock free, and only uses a few relaxed atomic operations
to initialize itself on first access (automatically), and the fast path of
reading an already-initialized
Id is just a single relaxed
load. This is
all to say, it's much more efficient than most of the alternatives would be
and more efficient than I had expected it to be.
A thread-safe lazily-initialized 64-bit ID.