commit | 97c9a52b3cd92c851a05c96ef1c1eff4e9563aa0 | [log] [tgz] |
---|---|---|
author | mvicsokolova <82594708+mvicsokolova@users.noreply.github.com> | Wed Sep 14 23:15:38 2022 +0200 |
committer | GitHub <noreply@github.com> | Wed Sep 14 23:15:38 2022 +0200 |
tree | 84cd1cf35b99576a3823407e765d72c29d82869d | |
parent | 797ec3b6c38c5de0ab02abad5c21d8abc005696d [diff] |
Update kotlinx.metadata to 0.5.0 (#245)
Note on Beta status: the plugin is in its active development phase and changes from release to release. We do provide a compatibility of atomicfu-transformed artifacts between releases, but we do not provide strict compatibility guarantees on plugin API and its general stability between Kotlin versions.
The idiomatic way to use atomic operations in Kotlin.
AtomicReference/Int/Long
, but run it in production efficiently as AtomicXxxFieldUpdater
on Kotlin/JVM and as plain unboxed values on Kotlin/JS.updateAndGet
and getAndUpdate
functions).Let us declare a top
variable for a lock-free stack implementation:
import kotlinx.atomicfu.* // import top-level functions from kotlinx.atomicfu private val top = atomic<Node?>(null)
Use top.value
to perform volatile reads and writes:
fun isEmpty() = top.value == null // volatile read fun clear() { top.value = null } // volatile write
Use compareAndSet
function directly:
if (top.compareAndSet(expect, update)) ...
Use higher-level looping primitives (inline extensions), for example:
top.loop { cur -> // while(true) loop that volatile-reads current value ... }
Use high-level update
, updateAndGet
, and getAndUpdate
, when possible, for idiomatic lock-free code, for example:
fun push(v: Value) = top.update { cur -> Node(v, cur) } fun pop(): Value? = top.getAndUpdate { cur -> cur?.next } ?.value
Declare atomic integers and longs using type inference:
val myInt = atomic(0) // note: integer initial value val myLong = atomic(0L) // note: long initial value
Integer and long atomics provide all the usual getAndIncrement
, incrementAndGet
, getAndAdd
, addAndGet
, and etc operations. They can be also atomically modified via +=
and -=
operators.
private val
or internal val
. You can use just (public) val
, but make sure they are not directly accessed outside of your Kotlin module (outside of the source set). Access to the atomic variable itself shall be encapsulated.top.compareAndSet(...)
is Ok, while val tmp = top; tmp...
is not.top.value = complex_expression
and top.compareAndSet(cur, complex_expression)
are not supported (more specifically, complex_expression
should not have branches in its compiled representation). Extract complex_expression
into a variable when needed.private val _foo = atomic<T>(initial) // private atomic, convention is to name it with leading underscore public var foo: T by _foo // public delegated property (val/var)
Building with Gradle is supported for all platforms.
You will need Gradle 6.8 or later. Add and apply AtomicFU plugin. It adds all the corresponding dependencies and transformations automatically. See additional configuration if that needs tweaking.
buildscript { ext.atomicfu_version = '0.18.3' dependencies { classpath "org.jetbrains.kotlinx:atomicfu-gradle-plugin:$atomicfu_version" } } apply plugin: 'kotlinx-atomicfu'
Configure add apply plugin just like for JVM.
This library is available for Kotlin/Native (atomicfu-native
). Apply the corresponding plugin just like for JVM.
Atomic references for Kotlin/Native are based on FreezableAtomicReference and every reference that is stored to the previously frozen (shared with another thread) atomic is automatically frozen, too.
Since Kotlin/Native does not generally provide binary compatibility between versions, you should use the same version of Kotlin compiler as was used to build AtomicFU. See gradle.properties in AtomicFU project for its kotlin_version
.
If you write a common code that should get compiled or different platforms, add org.jetbrains.kotlinx:atomicfu
to your common code dependencies or apply kotlinx-atomicfu
plugin that adds this dependency automatically:
dependencies { compile "org.jetbrains.kotlinx:atomicfu:$atomicfu_version" }
There is a new option to turn on IR transformation for Kotlin/JS backend. You can add kotlinx.atomicfu.enableIrTransformation=true
to your gradle.properties
file in order to enable it.
Here is how transformation is performed for different JS compiler modes with this option enabled:
kotlin.js.compiler=legacy
: JavaScript transformer from the library is applied to the final compiled *.js files.kotlin.js.compiler=ir
: compiler plugin transformations are appiled to the generated IR.kotlin.js.compiler=both
: compiler plugin transformations are appiled to all compilations of IR targets, while compilations of legacy targets are transformed by the library.To set configuration options you should create atomicfu
section in a build.gradle
file, like this:
atomicfu { dependenciesVersion = '0.18.3' }
To turn off transformation for Kotlin/JVM set option transformJvm
to false
.
Configuration option jvmVariant
defines the Java class that replaces atomics during bytecode transformation. Here are the valid options:
FU
– atomics are replaced with AtomicXxxFieldUpdater.VH
– atomics are replaced with VarHandle, this option is supported for JDK 9+.BOTH
– multi-release jar file will be created with both AtomicXxxFieldUpdater
for JDK <= 8 and VarHandle
for JDK 9+.To turn off transformation for Kotlin/JS set option transformJs
to false
.
Here are all available configuration options (with their defaults):
atomicfu { dependenciesVersion = '0.18.3' // set to null to turn-off auto dependencies transformJvm = true // set to false to turn off JVM transformation jvmVariant = "FU" // JVM transformation variant: FU,VH, or BOTH jsVariant = "JS" // JS transformation variant: JS or IR verbose = false // set to true to be more verbose }
Declare AtomicFU version:
<properties> <atomicfu.version>0.18.3</atomicfu.version> </properties>
Declare provided dependency on the AtomicFU library (the users of the resulting artifact will not have a dependency on AtomicFU library):
<dependencies> <dependency> <groupId>org.jetbrains.kotlinx</groupId> <artifactId>atomicfu</artifactId> <version>${atomicfu.version}</version> <scope>provided</scope> </dependency> </dependencies>
Configure build steps so that Kotlin compiler puts classes into a different classes-pre-atomicfu
directory, which is then transformed to a regular classes
directory to be used later by tests and delivery.
<build> <plugins> <!-- compile Kotlin files to staging directory --> <plugin> <groupId>org.jetbrains.kotlin</groupId> <artifactId>kotlin-maven-plugin</artifactId> <version>${kotlin.version}</version> <executions> <execution> <id>compile</id> <phase>compile</phase> <goals> <goal>compile</goal> </goals> <configuration> <output>${project.build.directory}/classes-pre-atomicfu</output> </configuration> </execution> </executions> </plugin> <!-- transform classes with AtomicFU plugin --> <plugin> <groupId>org.jetbrains.kotlinx</groupId> <artifactId>atomicfu-maven-plugin</artifactId> <version>${atomicfu.version}</version> <executions> <execution> <goals> <goal>transform</goal> </goals> <configuration> <input>${project.build.directory}/classes-pre-atomicfu</input> <!-- "VH" to use Java 9 VarHandle, "BOTH" to produce multi-version code --> <variant>FU</variant> </configuration> </execution> </executions> </plugin> </plugins> </build>
AtomicFU provides some additional features that you can optionally use.
You can declare arrays of all supported atomic value types. By default arrays are transformed into the corresponding java.util.concurrent.atomic.Atomic*Array
instances.
If you configure variant = "VH"
an array will be transformed to plain array using VarHandle to support atomic operations.
val a = atomicArrayOfNulls<T>(size) // similar to Array constructor val x = a[i].value // read value a[i].value = x // set value a[i].compareAndSet(expect, update) // do atomic operations
You can define you own extension functions on AtomicXxx
types but they must be inline
and they cannot be public and be used outside of the module they are defined in. For example:
@Suppress("NOTHING_TO_INLINE") private inline fun AtomicBoolean.tryAcquire(): Boolean = compareAndSet(false, true)
This project includes kotlinx.atomicfu.locks
package providing multiplatform locking primitives that require no additional runtime dependencies on Kotlin/JVM and Kotlin/JS with a library implementation for Kotlin/Native.
SynchronizedObject
is designed for inheritance. You write class MyClass : SynchronizedObject()
and then use synchronized(instance) { ... }
extension function similarly to the synchronized function from the standard library that is available for JVM. The SynchronizedObject
superclass gets erased (transformed to Any
) on JVM and JS, with synchronized
leaving no trace in the code on JS and getting replaced with built-in monitors for locking on JVM.
ReentrantLock
is designed for delegation. You write val lock = reentrantLock()
to construct its instance and use lock
/tryLock
/unlock
functions or lock.withLock { ... }
extension function similarly to the way jucl.ReentrantLock is used on JVM. On JVM it is a typealias to the later class, erased on JS.
Note that package
kotlinx.atomicfu.locks
is experimental explicitly even while atomicfu is experimental itself, meaning that no ABI guarantees are provided whatsoever. API from this package is not recommended to use in libraries that other projects depend on.
You can debug your tests tracing atomic operations with a special trace object:
private val trace = Trace() private val current = atomic(0, trace) fun update(x: Int): Int { // custom trace message trace { "calling update($x)" } // automatic tracing of modification operations return current.getAndAdd(x) }
All trace messages are stored in a cyclic array inside trace
.
You can optionally set the size of trace's message array and format function. For example, you can add a current thread name to the traced messages:
private val trace = Trace(size = 64) { index, // index of a trace message text // text passed when invoking trace { text } -> "$index: [${Thread.currentThread().name}] $text" }
trace
is only seen before transformation and completely erased after on Kotlin/JVM and Kotlin/JS.