Package kotlin.native.concurrent
Types
AtomicInt
An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile .
class
AtomicInt
AtomicLong
A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile .
class
AtomicLong
AtomicNativePtr
A kotlinx.cinterop.NativePtr value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile .
class
AtomicNativePtr
AtomicReference
An object reference that is always updated atomically.
class
AtomicReference
<
T
>
Continuation0
class
Continuation0
:
(
)
->
Unit
Continuation1
class
Continuation1
<
T1
>
:
(
T1
)
->
Unit
Continuation2
class
Continuation2
<
T1
,
T2
>
:
(
T1
,
T2
)
->
Unit
DetachedObjectGraph
Detached object graph encapsulates transferrable detached subgraph which cannot be accessed externally, until it is attached with the attach extension function.
class
DetachedObjectGraph
<
T
>
FreezableAtomicReference
This class was useful only with legacy memory manager. Please use AtomicReference instead.
class
FreezableAtomicReference
<
T
>
FreezingException
Exception thrown whenever freezing is not possible.
class
FreezingException
:
RuntimeException
Future
class
Future
<
T
>
FutureState
State of the future object.
enum
class
FutureState
InvalidMutabilityException
Exception thrown whenever we attempt to mutate frozen objects.
class
InvalidMutabilityException
:
RuntimeException
MutableData
Mutable concurrently accessible data buffer. Could be accessed from several workers simultaneously.
class
MutableData
TransferMode
Note: modern Kotlin/Native memory manager allows to share objects between threads without additional ceremonies, so TransferMode has effect only in legacy memory manager.
enum
class
TransferMode
Worker
class
Worker
WorkerBoundReference
A shared reference to a Kotlin object that doesn't freeze the referred object when it gets frozen itself.
class
WorkerBoundReference
<
out
T
:
Any
>
Annotations
ObsoleteWorkersApi
Marks all
Worker
-related API as obsolete.
annotation
class
ObsoleteWorkersApi
SharedImmutable
Note: this annotation has effect only in Kotlin/Native with legacy memory manager.
annotation
class
SharedImmutable
ThreadLocal
Marks a top level property with a backing field or an object as thread local. The object remains mutable and it is possible to change its state, but every thread will have a distinct copy of this object, so changes in one thread are not reflected in another.
annotation
class
ThreadLocal
Properties
isFrozen
Checks if given object is null or frozen or permanent (i.e. instantiated at compile-time).
val
Any
?
.
isFrozen
:
Boolean
Functions
atomicLazy
Atomic lazy initializer, could be used in frozen objects, freezes initializing lambda,
so use very carefully. Also, as with other uses of an
AtomicReference
may potentially
leak memory, so it is recommended to use
atomicLazy
in cases of objects living forever,
such as object singletons, or in cases where it's guaranteed not to have cyclical garbage.
fun
<
T
>
atomicLazy
(
initializer
:
(
)
->
T
)
:
Lazy
<
T
>
attach
Attaches previously detached object subgraph created by DetachedObjectGraph . Please note, that once object graph is attached, the DetachedObjectGraph.stable pointer does not make sense anymore, and shall be discarded, so attach of one DetachedObjectGraph object can only happen once.
fun
<
T
>
DetachedObjectGraph
<
T
>
.
attach
(
)
:
T
callContinuation0
fun
COpaquePointer
.
callContinuation0
(
)
callContinuation1
fun
<
T1
>
COpaquePointer
.
callContinuation1
(
)
callContinuation2
fun
<
T1
,
T2
>
COpaquePointer
.
callContinuation2
(
)
ensureNeverFrozen
This function ensures that if we see such an object during freezing attempt - freeze fails and FreezingException is thrown.
fun
Any
.
ensureNeverFrozen
(
)
freeze
Freezes object subgraph reachable from this object. Frozen objects can be freely shared between threads/workers.
fun
<
T
>
T
.
freeze
(
)
:
T
waitForMultipleFutures
fun
<
T
>
Collection
<
Future
<
T
>
>
.
waitForMultipleFutures
(
millis
:
Int
)
:
Set
<
Future
<
T
>
>
waitWorkerTermination
fun
waitWorkerTermination
(
worker
:
Worker
)
withWorker
Executes block with new Worker as resource, by starting the new worker, calling provided block (in current context) with newly started worker as this and terminating worker after the block completes. Note that this operation is pretty heavyweight, use preconfigured worker or worker pool if need to execute it frequently.
fun
<
R
>
withWorker
(
name
:
String
?
=
null
,
errorReporting
:
Boolean
=
true
,
block
:
Worker
.
(
)
->
R
)
:
R