Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Java: is there no AtomicFloat or AtomicDouble?

I have found AtomicInteger, AtomicLong, but where is AtomicFloat (or AtomicDouble)? Maybe there is some trick?

like image 899
itun Avatar asked Mar 31 '11 19:03

itun


People also ask

What is AtomicDouble?

An AtomicDouble is used in applications such as atomic accumulation, and cannot be used as a replacement for a Double . However, this class does extend Number to allow uniform access by tools and utilities that deal with numerically-based classes.

What are atomic classes in Java?

Java provides atomic classes such as AtomicInteger, AtomicLong, AtomicBoolean and AtomicReference. Objects of these classes represent the atomic variable of int, long, boolean, and object reference respectively. These classes contain the following methods.

What is Java Util Concurrent Atomic?

concurrent. atomic. A small toolkit of classes that support lock-free thread-safe programming on single variables. Instances of Atomic classes maintain values that are accessed and updated using methods otherwise available for fields using associated atomic VarHandle operations.

Is AtomicInteger blocking?

AtomicInteger uses combination of volatile & CAS (compare and swap) to achieve thread-safety for Integer Counter. It is non-blocking in nature and thus highly usable in writing high throughput concurrent data structures that can be used under low to moderate thread contention.


1 Answers

The API docs for the java.util.concurrent package states the following:

[...] Additionally, classes are provided only for those types that are commonly useful in intended applications. For example, there is no atomic class for representing byte. In those infrequent cases where you would like to do so, you can use an AtomicInteger to hold byte values, and cast appropriately. You can also hold floats using Float.floatToIntBits and Float.intBitstoFloat conversions, and doubles using Double.doubleToLongBits and Double.longBitsToDouble conversions.

I'm not claiming it's a convenient solution, but that seems to be the explanation. I suppose you would probably want to wrap an AtomicInteger and provide access methods for getFloat / setFloat etc.


I actually got around writing one. Here you go:

import java.util.concurrent.atomic.AtomicInteger; import static java.lang.Float.*;  class AtomicFloat extends Number {      private AtomicInteger bits;      public AtomicFloat() {         this(0f);     }      public AtomicFloat(float initialValue) {         bits = new AtomicInteger(floatToIntBits(initialValue));     }      public final boolean compareAndSet(float expect, float update) {         return bits.compareAndSet(floatToIntBits(expect),                                   floatToIntBits(update));     }      public final void set(float newValue) {         bits.set(floatToIntBits(newValue));     }      public final float get() {         return intBitsToFloat(bits.get());     }      public float floatValue() {         return get();     }      public final float getAndSet(float newValue) {         return intBitsToFloat(bits.getAndSet(floatToIntBits(newValue)));     }      public final boolean weakCompareAndSet(float expect, float update) {         return bits.weakCompareAndSet(floatToIntBits(expect),                                       floatToIntBits(update));     }      public double doubleValue() { return (double) floatValue(); }     public int intValue()       { return (int) get();           }     public long longValue()     { return (long) get();          }  } 
like image 151
aioobe Avatar answered Sep 24 '22 02:09

aioobe