kotlin-stdlib/kotlin.concurrent.atomics/AtomicInt

AtomicInt

An Int value that may be updated atomically.

Platform-specific implementation details:

When targeting the Native backend, AtomicInt stores a volatile Int variable and atomically updates it. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

When targeting the JVM, instances of AtomicInt are represented by java.util.concurrent.atomic.AtomicInteger. For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).

For JS and Wasm AtomicInt is implemented trivially and is not thread-safe since these platforms do not support multi-threading.

Since Kotlin

2.1

@ExperimentalAtomicApi

actual class AtomicInt(source)

An Int value that may be updated atomically.

Since the JS platform does not support multi-threading, the implementation is trivial and has no atomic synchronizations.

Since Kotlin

2.1

@ExperimentalAtomicApi

actual class AtomicInt(source)

An Int value that may be updated atomically.

Instances of AtomicInt are represented by java.util.concurrent.atomic.AtomicInteger and provide the the same atomicity guarantees.

Since Kotlin

2.1

Samples

import kotlin.concurrent.atomics.*
import kotlin.concurrent.thread

fun main() { 
   //sampleStart 
   // The atomic counter of processed items
val processedItems = AtomicInt(0)
val totalItems = 100
val items = List(totalItems) { "item$it" }
// Split the items into chunks for processing by multiple threads
val chunkSize = 20
val itemChunks = items.chunked(chunkSize)
val threads = itemChunks.map { chunk ->
    thread {
        for (item in chunk) {
            println("Processing $item in thread ${Thread.currentThread()}")
            // Increment the counter atomically
            processedItems += 1
        }
    }
}
threads.forEach { it.join() }
// The total number of processed items
println(processedItems.load()) // totalItems.toString() 
   //sampleEnd
}

@ExperimentalAtomicApi

actual class AtomicInt(source)

An Int value that may be updated atomically.

Read operation load has the same memory effects as reading a Volatile property; Write operation store has the same memory effects as writing a Volatile property; Read-modify-write operations, like exchange, compareAndSet, compareAndExchange, fetchAndAdd, addAndFetch, have the same memory effects as reading and writing a Volatile property.

For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

Since Kotlin

2.1

@ExperimentalAtomicApi

actual class AtomicInt(source)

An Int value that may be updated atomically.

Since the Wasm platform does not support multi-threading, the implementation is trivial and has no atomic synchronizations.

Since Kotlin

2.1

@ExperimentalAtomicApi

actual class AtomicInt(source)

An Int value that may be updated atomically.

Since the Wasm platform does not support multi-threading, the implementation is trivial and has no atomic synchronizations.

Since Kotlin

2.1

Constructors

AtomicInt

expect constructor(value: Int)

actual constructor(value: Int)

constructor(value: Int)

actual constructor(value: Int)

Properties

value

@Volatile

var value: Int

Since Kotlin 2.1

Functions

addAndFetch

expect fun addAndFetch(delta: Int): Int

Atomically adds the given value to the current value of this AtomicInt and returns the new value.

Since Kotlin 2.1

actual fun addAndFetch(delta: Int): Int

Atomically adds the given value to the current value of this AtomicInt and returns the new value.

Since Kotlin 2.1

actual fun addAndFetch(delta: Int): Int

Atomically adds the given value to the current value of this AtomicInt and returns the new value.

Since Kotlin 2.1

actual fun addAndFetch(delta: Int): Int

Atomically adds the given value to the current value of this AtomicInt and returns the new value.

Since Kotlin 2.1

actual fun addAndFetch(delta: Int): Int

Atomically adds the given value to the current value of this AtomicInt and returns the new value.

Since Kotlin 2.1

actual fun addAndFetch(delta: Int): Int

Atomically adds the given value to the current value of this AtomicInt and returns the new value.

Since Kotlin 2.1

addAndGet

fun ~~addAndGet~~(delta: Int): Int

Atomically adds the given value to the current value and returns the new value.

Since Kotlin 2.1

asJavaAtomic

@ExperimentalAtomicApi

fun AtomicInt.asJavaAtomic(): AtomicInteger

Casts the given AtomicInt instance to java.util.concurrent.atomic.AtomicInteger.

Since Kotlin 2.1

compareAndExchange

expect fun compareAndExchange(expectedValue: Int, newValue: Int): Int

Atomically stores the given new value into this AtomicInt if the current value equals the expected value and returns the old value in any case.

Since Kotlin 2.1

actual fun compareAndExchange(expectedValue: Int, newValue: Int): Int

Atomically stores the given new value into this AtomicInt. if the current value equals the expected value and returns the old value in any case.

Since Kotlin 2.1

actual fun compareAndExchange(expectedValue: Int, newValue: Int): Int

Atomically stores the given new value into this AtomicInt if the current value equals the expected value and returns the old value in any case.

Since Kotlin 2.1

actual fun compareAndExchange(expectedValue: Int, newValue: Int): Int

Atomically stores the given new value into this AtomicInt if the current value equals the expected value and returns the old value in any case.

Since Kotlin 2.1

actual fun compareAndExchange(expectedValue: Int, newValue: Int): Int

Atomically stores the given new value into this AtomicInt if the current value equals the expected value and returns the old value in any case.

Since Kotlin 2.1

actual fun compareAndExchange(expectedValue: Int, newValue: Int): Int

Atomically stores the given new value into this AtomicInt if the current value equals the expected value and returns the old value in any case.

Since Kotlin 2.1

compareAndSet

expect fun compareAndSet(expectedValue: Int, newValue: Int): Boolean

Atomically stores the given new value into this AtomicInt if the current value equals the expected value, returns true if the operation was successful and false only if the current value was not equal to the expected value.

Since Kotlin 2.1

actual fun compareAndSet(expectedValue: Int, newValue: Int): Boolean

Atomically stores the given new value into this AtomicInt. if the current value equals the expected value, returns true if the operation was successful and false only if the current value was not equal to the expected value.

Since Kotlin 2.1

actual fun compareAndSet(expectedValue: Int, newValue: Int): Boolean

Since Kotlin 2.1

actual fun compareAndSet(expectedValue: Int, newValue: Int): Boolean

Since Kotlin 2.1

actual fun compareAndSet(expectedValue: Int, newValue: Int): Boolean

Since Kotlin 2.1

actual fun compareAndSet(expectedValue: Int, newValue: Int): Boolean

Since Kotlin 2.1

decrementAndFetch

@ExperimentalAtomicApi

fun AtomicInt.decrementAndFetch(): Int