if (data.compareAndSet(current, new Data(v1, v2, v3))) {

if (data.compareAndSet(current, new Data(v1, v2, v3))) {

return;

return;

}

}

}

}

}

}

* Use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object

* Use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object

* repeat everything again if there was a clash

* repeat everything again if there was a clash

* and the ```current``` value was modified by some other thread meanwhile

* and the '''current''' value was modified by some other thread meanwhile

Let's keep the internal data in a dedicated immutable structure called '''Data'''. When performing an update:

Let's keep the internal data in a dedicated immutable structure called '''Data'''. When performing an update:

* Read its current state.

* Read the '''current''' state.

* Compute an update.

* Compute an update based on the '''current''' state

* Use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object

* Use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object

* repeat everything again if there was a clash

* repeat everything again if there was a clash

Let's keep the internal data in a dedicated immutable object called '''Data'''. Read its current state. Compute an update. Let's use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object or repeat everything again if there was a clash with some other thread:

Let's keep the internal data in a dedicated immutable structure called '''Data'''. When performing an update:

* Read its current state.

* Compute an update.

* Use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object

* repeat everything again if there was a clash

* and the ```current``` value was modified by some other thread meanwhile

}

}

private AtomicReference<Data> data = new AtomicReference<>(new Data(0, 0, 0));

private final AtomicReference<Data> data = new AtomicReference<>(new Data(0, 0, 0));

protected abstract int combine(int x, int y);

protected abstract int combine(int x, int y);

current = data.get();

current = data.get();

int r1 = combine(current.value1, current.value2);

int r2 = combine(current.value2, current.value3);

int v1 = combine(current.value1, current.value2);

int r3 = combine(current.value3, current.value1);

int v2 = combine(current.value2, current.value3);

int v3 = combine(current.value3, current.value1);

if (data.compareAndSet(current, new Data(r1, r2, r3))) {

if (data.compareAndSet(current, new Data(v1, v2, v3))) {

return;

return;

}

}

</source>

</source>

Neat usage of immutability. The data that are supposed to be consistent are '''final''' in a ''Data'' class. The mutability is handled all at once with {{JDK|java/util/concurrent/atomic|AtomicReference}} ''compareAndSet'' method. Either it fails and the computation runs again or it succeeds and atomically changes the data to newly created and consistent value. No locks involved, hence the reference to [[LockFreeAlgorithm]]s. Let's call such this pattern [[TransactionalDataStructure]].

Neat usage of immutability. The data that are supposed to be consistent are '''final''' in a ''Data'' class. The mutability is handled all at once with {{JDK|java/util/concurrent/atomic|AtomicReference}} ''compareAndSet'' method. Either it fails and the computation runs again or it succeeds and atomically changes the data to newly created and consistent value. No locks involved, hence the reference to [[LockFreeAlgorithm]]s. Let's call such a pattern [[TransactionalDataStructure]].

</source>

</source>

Neat usage of immutability. The data that are supposed to be consistent are '''final''' in a ''Data'' class. The mutability is handled all at once with {{JDK|java/util/concurrent/atomic|AtomicReference}} ''compareAndSet'' method. Either it fails and the computation runs again or it succeeds and atomically changes the data to newly created and consistent value. No locks involved, hence the reference to [[wikipedia::Lock free algorithm]]. Let's call such this pattern [[TransactionalDataStructure]].

Neat usage of immutability. The data that are supposed to be consistent are '''final''' in a ''Data'' class. The mutability is handled all at once with {{JDK|java/util/concurrent/atomic|AtomicReference}} ''compareAndSet'' method. Either it fails and the computation runs again or it succeeds and atomically changes the data to newly created and consistent value. No locks involved, hence the reference to [[LockFreeAlgorithm]]s. Let's call such this pattern [[TransactionalDataStructure]].

</source>

</source>

Neat usage of immutability. The data that are supposed to be consistent are '''final''' in a ''Data'' class. The mutability is handled all at once with {{JDK|java/util/concurrent/atomic|AtomicReference}} ''compareAndSet'' method. Either it fails and the computation runs again or it succeeds and atomically changes the data to newly created and consistent value. Let's call such this pattern [[TransactionalDataStructure]].

Neat usage of immutability. The data that are supposed to be consistent are '''final''' in a ''Data'' class. The mutability is handled all at once with {{JDK|java/util/concurrent/atomic|AtomicReference}} ''compareAndSet'' method. Either it fails and the computation runs again or it succeeds and atomically changes the data to newly created and consistent value. No locks involved, hence the reference to [[wikipedia::Lock free algorithm]]. Let's call such this pattern [[TransactionalDataStructure]].

Let's keep the internal data a special immutable object. Let's use ''compare and swap'' operation to ''transactionally update'' the state of the object or recompute everything again:

Let's keep the internal data in a dedicated immutable object called '''Data'''. Read its current state. Compute an update. Let's use ''compare and swap'' operation to ''transactionally'' (hence the similarity with [[TransactionalMemory]]) update the state of the object or repeat everything again if there was a clash with some other thread: