diff --git a/agrona-agent/src/test/java/org/agrona/agent/BufferAlignmentAgentTest.java b/agrona-agent/src/test/java/org/agrona/agent/BufferAlignmentAgentTest.java
index eab323e5a..e365a0b90 100644
--- a/agrona-agent/src/test/java/org/agrona/agent/BufferAlignmentAgentTest.java
+++ b/agrona-agent/src/test/java/org/agrona/agent/BufferAlignmentAgentTest.java
@@ -284,16 +284,16 @@ private void testAlignedAtomicMethods(final AtomicBuffer buffer, final int offse
         buffer.compareAndSetLong(offset + SIZE_OF_LONG, Long.MAX_VALUE, Long.MAX_VALUE);
         buffer.getAndAddLong(offset + SIZE_OF_LONG, Long.MAX_VALUE);
         buffer.getAndSetLong(offset + SIZE_OF_LONG, Long.MAX_VALUE);
-        buffer.putLongOrdered(offset + SIZE_OF_LONG, Long.MAX_VALUE);
-        buffer.addLongOrdered(offset + SIZE_OF_LONG, Long.MAX_VALUE);
+        buffer.putLongRelease(offset + SIZE_OF_LONG, Long.MAX_VALUE);
+        buffer.addLongRelease(offset + SIZE_OF_LONG, Long.MAX_VALUE);
 
         buffer.getIntVolatile(offset + SIZE_OF_INT);
         buffer.putIntVolatile(offset + SIZE_OF_INT, Integer.MAX_VALUE);
         buffer.compareAndSetInt(offset + SIZE_OF_INT, Integer.MAX_VALUE, Integer.MAX_VALUE);
         buffer.getAndAddInt(offset + SIZE_OF_INT, Integer.MAX_VALUE);
         buffer.getAndSetInt(offset + SIZE_OF_INT, Integer.MAX_VALUE);
-        buffer.putIntOrdered(offset + SIZE_OF_INT, Integer.MAX_VALUE);
-        buffer.addIntOrdered(offset + SIZE_OF_INT, Integer.MAX_VALUE);
+        buffer.putIntRelease(offset + SIZE_OF_INT, Integer.MAX_VALUE);
+        buffer.addIntRelease(offset + SIZE_OF_INT, Integer.MAX_VALUE);
 
         buffer.getShortVolatile(offset + SIZE_OF_SHORT);
         buffer.putShortVolatile(offset + SIZE_OF_SHORT, Short.MAX_VALUE);
@@ -319,8 +319,8 @@ private void testUnAlignedAtomicMethods(final AtomicBuffer buffer, final int off
             addressOffset, offset + SIZE_OF_INT, (i) -> buffer.compareAndSetLong(i, Long.MAX_VALUE, Long.MAX_VALUE));
         assertUnaligned(addressOffset, offset + SIZE_OF_INT, (i) -> buffer.getAndAddLong(i, Long.MAX_VALUE));
         assertUnaligned(addressOffset, offset + SIZE_OF_INT, (i) -> buffer.getAndSetLong(i, Long.MAX_VALUE));
-        assertUnaligned(addressOffset, offset + SIZE_OF_INT, (i) -> buffer.putLongOrdered(i, Long.MAX_VALUE));
-        assertUnaligned(addressOffset, offset + SIZE_OF_INT, (i) -> buffer.addLongOrdered(i, Long.MAX_VALUE));
+        assertUnaligned(addressOffset, offset + SIZE_OF_INT, (i) -> buffer.putLongRelease(i, Long.MAX_VALUE));
+        assertUnaligned(addressOffset, offset + SIZE_OF_INT, (i) -> buffer.addLongRelease(i, Long.MAX_VALUE));
 
         assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, buffer::getIntVolatile);
         assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.putIntVolatile(i, Integer.MAX_VALUE));
@@ -328,8 +328,8 @@ private void testUnAlignedAtomicMethods(final AtomicBuffer buffer, final int off
             (i) -> buffer.compareAndSetInt(i, Integer.MAX_VALUE, Integer.MAX_VALUE));
         assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.getAndAddInt(i, Integer.MAX_VALUE));
         assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.getAndSetInt(i, Integer.MAX_VALUE));
-        assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.putIntOrdered(i, Integer.MAX_VALUE));
-        assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.addIntOrdered(i, Integer.MAX_VALUE));
+        assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.putIntRelease(i, Integer.MAX_VALUE));
+        assertUnaligned(addressOffset, offset + SIZE_OF_SHORT, (i) -> buffer.addIntRelease(i, Integer.MAX_VALUE));
 
         assertUnaligned(addressOffset, offset + SIZE_OF_BYTE, buffer::getShortVolatile);
         assertUnaligned(addressOffset, offset + SIZE_OF_BYTE, (i) -> buffer.putShortVolatile(i, Short.MAX_VALUE));
diff --git a/agrona-concurrency-tests/src/main/java/org/agrona/concurrent/UnsafeBufferTests.java b/agrona-concurrency-tests/src/main/java/org/agrona/concurrent/UnsafeBufferTests.java
index 65ad93dbf..47b9175b4 100644
--- a/agrona-concurrency-tests/src/main/java/org/agrona/concurrent/UnsafeBufferTests.java
+++ b/agrona-concurrency-tests/src/main/java/org/agrona/concurrent/UnsafeBufferTests.java
@@ -40,7 +40,7 @@ public class UnsafeBufferTests
 
     /**
      * Test that verifies the atomicity of the {@link UnsafeBuffer#putLongVolatile(int, long)},
-     * {@link UnsafeBuffer#putLongOrdered(int, long)} and {@link UnsafeBuffer#getLongVolatile(int)}.
+     * {@link UnsafeBuffer#putLongRelease(int, long)} (int, long)} and {@link UnsafeBuffer#getLongVolatile(int)}.
      */
     @JCStressTest
     @Outcome(id = "0", expect = Expect.ACCEPTABLE, desc = "read before writes")
@@ -71,7 +71,7 @@ public void putLongVolatile()
         @Actor
         public void putLongOrdered()
         {
-            buffer.putLongOrdered(WRITE_INDEX, Long.MAX_VALUE - 1);
+            buffer.putLongRelease(WRITE_INDEX, Long.MAX_VALUE - 1);
         }
 
         /**
@@ -88,7 +88,7 @@ public void actor2(final J_Result result)
 
     /**
      * Test that verifies the atomicity of the {@link UnsafeBuffer#putIntVolatile(int, int)},
-     * {@link UnsafeBuffer#putIntOrdered(int, int)} and {@link UnsafeBuffer#getIntVolatile(int)}.
+     * {@link UnsafeBuffer#putIntRelease(int, int)} (int, int)} and {@link UnsafeBuffer#getIntVolatile(int)}.
      */
     @JCStressTest
     @Outcome(id = "0", expect = Expect.ACCEPTABLE, desc = "read before writes")
@@ -119,7 +119,7 @@ public void putIntVolatile()
         @Actor
         public void putIntOrdered()
         {
-            buffer.putIntOrdered(WRITE_INDEX, 222222222);
+            buffer.putIntRelease(WRITE_INDEX, 222222222);
         }
 
         /**
diff --git a/agrona/src/main/java/org/agrona/MarkFile.java b/agrona/src/main/java/org/agrona/MarkFile.java
index bcf1a70d6..6d31b18fb 100644
--- a/agrona/src/main/java/org/agrona/MarkFile.java
+++ b/agrona/src/main/java/org/agrona/MarkFile.java
@@ -259,7 +259,7 @@ public void close()
      */
     public void signalReady(final int version)
     {
-        buffer.putIntOrdered(versionFieldOffset, version);
+        buffer.putIntRelease(versionFieldOffset, version);
     }
 
     /**
@@ -289,7 +289,7 @@ public int versionWeak()
      */
     public void timestampOrdered(final long timestamp)
     {
-        buffer.putLongOrdered(timestampFieldOffset, timestamp);
+        buffer.putLongRelease(timestampFieldOffset, timestamp);
     }
 
     /**
diff --git a/agrona/src/main/java/org/agrona/concurrent/AtomicBuffer.java b/agrona/src/main/java/org/agrona/concurrent/AtomicBuffer.java
index d2b61910a..ede9f6083 100644
--- a/agrona/src/main/java/org/agrona/concurrent/AtomicBuffer.java
+++ b/agrona/src/main/java/org/agrona/concurrent/AtomicBuffer.java
@@ -22,6 +22,13 @@
 
 /**
  * Abstraction over a range of buffer types that allows type to be accessed with various memory ordering semantics.
+ * <p>
+ * Before Java 9, there was no standard for stores with release semantics. On the AtomicLong there was the
+ * {@link java.util.concurrent.atomic.AtomicLong#lazySet(long)}. Because there was no standard, the AtomicBuffer
+ * has methods like {@link #putLongOrdered(int, long)}. With Java 9, the 'release' name has been introduced.
+ * The AtomicBuffer also has methods with release methods which are identical to the ordered methods. All the
+ * methods with 'ordered' semantics will call the equivalent method with release semantics. This introduces a small
+ * performance penalty and should encourage users to switch to the newer methods.
  */
 public interface AtomicBuffer extends MutableDirectBuffer
 {
@@ -53,8 +60,8 @@ public interface AtomicBuffer extends MutableDirectBuffer
      * Verify that the underlying buffer is correctly aligned to prevent word tearing, other ordering issues and
      * the JVM crashes. In particular this method verifies that the starting offset of the underlying buffer is properly
      * aligned. However, the actual atomic call must ensure that the index is properly aligned, i.e. it must be aligned
-     * to the size of the operand. For example a call to any of the following methods {@link #putIntOrdered(int, int)},
-     * {@link #putIntVolatile(int, int)}, {@link #addIntOrdered(int, int)}, {@link #getIntVolatile(int)},
+     * to the size of the operand. For example a call to any of the following methods {@link #putIntRelease(int, int)},
+     * {@link #putIntVolatile(int, int)}, {@link #addIntRelease(int, int)} (int, int)}, {@link #getIntVolatile(int)},
      * {@link #getAndAddInt(int, int)} or {@link #getAndSetInt(int, int)}, must have the index aligned by four bytes
      * (e.g. {@code 0, 4, 8, 12, 60 etc.}).
      * <p>
@@ -88,6 +95,14 @@ public interface AtomicBuffer extends MutableDirectBuffer
      */
     long getLongVolatile(int index);
 
+    /**
+     * Atomically get the value at a given index with acquire semantics.
+     *
+     * @param index in bytes from which to get.
+     * @return the value for at a given index.
+     */
+    long getLongAcquire(int index);
+
     /**
      * Atomically put a value to a given index with volatile semantics.
      * <p>
@@ -101,17 +116,29 @@ public interface AtomicBuffer extends MutableDirectBuffer
     /**
      * Atomically put a value to a given index with ordered store semantics.
      * <p>
-     * This call has release semantics.
+     * Instead of using this method, use  {@link #putLongRelease(int, long)} instead. They
+     * are identical and the putLongRelease is the preferred version.
      *
      * @param index in bytes for where to put.
      * @param value for at a given index.
      */
     void putLongOrdered(int index, long value);
 
+    /**
+     * Atomically put a value to a given index with release semantics.
+     *
+     * @param index in bytes for where to put.
+     * @param value for at a given index.
+     */
+    void putLongRelease(int index, long value);
+
     /**
      * Atomically adds a value to a given index with ordered store semantics. Use a negative increment to decrement.
      * <p>
      * The load has no ordering semantics. The store has release semantics.
+     * <p>
+     * Instead of using this method, use {@link #addLongRelease(int, long)} instead. They
+     * are identical but the addLongRelease is the preferred version.
      *
      * @param index     in bytes for where to put.
      * @param increment by which the value at the index will be adjusted.
@@ -119,6 +146,17 @@ public interface AtomicBuffer extends MutableDirectBuffer
      */
     long addLongOrdered(int index, long increment);
 
+    /**
+     * Atomically adds a value to a given index with ordered store semantics. Use a negative increment to decrement.
+     * <p>
+     * The load has no ordering semantics. The store has release semantics.
+     *
+     * @param index     in bytes for where to put.
+     * @param increment by which the value at the index will be adjusted.
+     * @return the previous value at the index.
+     */
+    long addLongRelease(int index, long increment);
+
     /**
      * Atomic compare and set of a long given an expected value.
      * <p>
@@ -174,20 +212,40 @@ public interface AtomicBuffer extends MutableDirectBuffer
      */
     void putIntVolatile(int index, int value);
 
+    /**
+     * Atomically get the value at a given index with acquire semantics.
+     *
+     * @param index in bytes from which to get.
+     * @return the value for at a given index.
+     */
+    int getIntAcquire(int index);
+
     /**
      * Atomically put a value to a given index with ordered semantics.
      * <p>
-     * This call has release semantics.
-     *
+     * Instead of using this method, use {@link #putIntRelease} instead. They
+     * are identical but the putIntRelease is the preferred version.
+
      * @param index in bytes for where to put.
      * @param value for at a given index.
      */
     void putIntOrdered(int index, int value);
 
+    /**
+     * Atomically put a value to a given index with release semantics.
+     *
+     * @param index in bytes for where to put.
+     * @param value for at a given index.
+     */
+    void putIntRelease(int index, int value);
+
     /**
      * Atomically add a value to a given index with ordered store semantics. Use a negative increment to decrement.
      * <p>
      * The load has no ordering semantics. The store has release semantics.
+     * <p>
+     * Instead of using this method, use {@link #addIntRelease(int, int)} instead. They
+     * are identical but the addIntRelease is the preferred version.
      *
      * @param index     in bytes for where to put.
      * @param increment by which the value at the index will be adjusted.
@@ -195,6 +253,17 @@ public interface AtomicBuffer extends MutableDirectBuffer
      */
     int addIntOrdered(int index, int increment);
 
+    /**
+     * Atomically add a value to a given index with release semantics. Use a negative increment to decrement.
+     * <p>
+     * The load has no ordering semantics. The store has release semantics.
+     *
+     * @param index     in bytes for where to put.
+     * @param increment by which the value at the index will be adjusted.
+     * @return the previous value at the index.
+     */
+    int addIntRelease(int index, int increment);
+
     /**
      * Atomic compare and set of an int given an expected value.
      * <p>
diff --git a/agrona/src/main/java/org/agrona/concurrent/UnsafeBuffer.java b/agrona/src/main/java/org/agrona/concurrent/UnsafeBuffer.java
index cf2a9f7b6..355c61d4c 100644
--- a/agrona/src/main/java/org/agrona/concurrent/UnsafeBuffer.java
+++ b/agrona/src/main/java/org/agrona/concurrent/UnsafeBuffer.java
@@ -398,10 +398,31 @@ public void putLongVolatile(final int index, final long value)
         UnsafeApi.putLongVolatile(byteArray, addressOffset + index, value);
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public long getLongAcquire(final int index)
+    {
+        if (SHOULD_BOUNDS_CHECK)
+        {
+            boundsCheck0(index, SIZE_OF_LONG);
+        }
+
+        return UnsafeApi.getLongAcquire(byteArray, addressOffset + index);
+    }
+
     /**
      * {@inheritDoc}
      */
     public void putLongOrdered(final int index, final long value)
+    {
+        putLongRelease(index, value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void putLongRelease(final int index, final long value)
     {
         if (SHOULD_BOUNDS_CHECK)
         {
@@ -415,6 +436,14 @@ public void putLongOrdered(final int index, final long value)
      * {@inheritDoc}
      */
     public long addLongOrdered(final int index, final long increment)
+    {
+        return addLongRelease(index, increment);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public long addLongRelease(final int index, final long increment)
     {
         if (SHOULD_BOUNDS_CHECK)
         {
@@ -489,10 +518,31 @@ public void putIntVolatile(final int index, final int value)
         UnsafeApi.putIntVolatile(byteArray, addressOffset + index, value);
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public int getIntAcquire(final int index)
+    {
+        if (SHOULD_BOUNDS_CHECK)
+        {
+            boundsCheck0(index, SIZE_OF_INT);
+        }
+
+        return UnsafeApi.getIntAcquire(byteArray, addressOffset + index);
+    }
+
     /**
      * {@inheritDoc}
      */
     public void putIntOrdered(final int index, final int value)
+    {
+        putIntRelease(index, value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void putIntRelease(final int index, final int value)
     {
         if (SHOULD_BOUNDS_CHECK)
         {
@@ -506,6 +556,14 @@ public void putIntOrdered(final int index, final int value)
      * {@inheritDoc}
      */
     public int addIntOrdered(final int index, final int increment)
+    {
+        return addIntRelease(index, increment);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public int addIntRelease(final int index, final int increment)
     {
         if (SHOULD_BOUNDS_CHECK)
         {
diff --git a/agrona/src/main/java/org/agrona/concurrent/broadcast/BroadcastTransmitter.java b/agrona/src/main/java/org/agrona/concurrent/broadcast/BroadcastTransmitter.java
index 06e5d5ead..c82d50a0c 100644
--- a/agrona/src/main/java/org/agrona/concurrent/broadcast/BroadcastTransmitter.java
+++ b/agrona/src/main/java/org/agrona/concurrent/broadcast/BroadcastTransmitter.java
@@ -122,13 +122,13 @@ public void transmit(final int msgTypeId, final DirectBuffer srcBuffer, final in
 
         buffer.putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length);
 
-        buffer.putLongOrdered(latestCounterIndex, currentTail);
-        buffer.putLongOrdered(tailCounterIndex, currentTail + recordLengthAligned);
+        buffer.putLongRelease(latestCounterIndex, currentTail);
+        buffer.putLongRelease(tailCounterIndex, currentTail + recordLengthAligned);
     }
 
     private void signalTailIntent(final AtomicBuffer buffer, final long newTail)
     {
-        buffer.putLongOrdered(tailIntentCountIndex, newTail);
+        buffer.putLongRelease(tailIntentCountIndex, newTail);
         VarHandle.releaseFence();
     }
 
diff --git a/agrona/src/main/java/org/agrona/concurrent/errors/DistinctErrorLog.java b/agrona/src/main/java/org/agrona/concurrent/errors/DistinctErrorLog.java
index fdd521a74..3002d790b 100644
--- a/agrona/src/main/java/org/agrona/concurrent/errors/DistinctErrorLog.java
+++ b/agrona/src/main/java/org/agrona/concurrent/errors/DistinctErrorLog.java
@@ -177,7 +177,7 @@ public boolean record(final Throwable observation)
 
         final int offset = distinctObservation.offset;
         buffer.getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        buffer.putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampMs);
+        buffer.putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampMs);
 
         return true;
     }
@@ -279,7 +279,7 @@ private DistinctObservation newObservation(final long timestampMs, final Throwab
 
         final DistinctObservation distinctObservation = new DistinctObservation(observation, offset);
         distinctObservations = prepend(distinctObservations, distinctObservation);
-        buffer.putIntOrdered(offset + LENGTH_OFFSET, length);
+        buffer.putIntRelease(offset + LENGTH_OFFSET, length);
 
         return distinctObservation;
     }
diff --git a/agrona/src/main/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBuffer.java b/agrona/src/main/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBuffer.java
index edc51f72e..7ca2a65ae 100644
--- a/agrona/src/main/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBuffer.java
+++ b/agrona/src/main/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBuffer.java
@@ -97,12 +97,12 @@ public boolean write(final int msgTypeId, final DirectBuffer srcBuffer, final in
             return false;
         }
 
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
         VarHandle.releaseFence();
 
         buffer.putBytes(encodedMsgOffset(recordIndex), srcBuffer, offset, length);
         buffer.putInt(typeOffset(recordIndex), msgTypeId);
-        buffer.putIntOrdered(lengthOffset(recordIndex), recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), recordLength);
 
         return true;
     }
@@ -124,7 +124,7 @@ public int tryClaim(final int msgTypeId, final int length)
             return recordIndex;
         }
 
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
         VarHandle.releaseFence();
         buffer.putInt(typeOffset(recordIndex), msgTypeId);
 
@@ -140,7 +140,7 @@ public void commit(final int index)
         final AtomicBuffer buffer = this.buffer;
         final int recordLength = verifyClaimedSpaceNotReleased(buffer, recordIndex);
 
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
     }
 
     /**
@@ -153,7 +153,7 @@ public void abort(final int index)
         final int recordLength = verifyClaimedSpaceNotReleased(buffer, recordIndex);
 
         buffer.putInt(typeOffset(recordIndex), PADDING_MSG_TYPE_ID);
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
     }
 
     /**
@@ -208,7 +208,7 @@ public int read(final MessageHandler handler, final int messageCountLimit)
             if (bytesRead > 0)
             {
                 buffer.setMemory(headIndex, bytesRead, (byte)0);
-                buffer.putLongOrdered(headPositionIndex, head + bytesRead);
+                buffer.putLongRelease(headPositionIndex, head + bytesRead);
             }
         }
 
@@ -277,7 +277,7 @@ public int controlledRead(final ControlledMessageHandler handler, final int mess
                 if (COMMIT == action)
                 {
                     buffer.setMemory(headIndex, bytesRead, (byte)0);
-                    buffer.putLongOrdered(headPositionIndex, head + bytesRead);
+                    buffer.putLongRelease(headPositionIndex, head + bytesRead);
                     headIndex += bytesRead;
                     head += bytesRead;
                     bytesRead = 0;
@@ -289,7 +289,7 @@ public int controlledRead(final ControlledMessageHandler handler, final int mess
             if (bytesRead > 0)
             {
                 buffer.setMemory(headIndex, bytesRead, (byte)0);
-                buffer.putLongOrdered(headPositionIndex, head + bytesRead);
+                buffer.putLongRelease(headPositionIndex, head + bytesRead);
             }
         }
 
@@ -325,7 +325,7 @@ public AtomicBuffer buffer()
      */
     public void consumerHeartbeatTime(final long time)
     {
-        buffer.putLongOrdered(consumerHeartbeatIndex, time);
+        buffer.putLongRelease(consumerHeartbeatIndex, time);
     }
 
     /**
@@ -408,7 +408,7 @@ public boolean unblock()
         if (length < 0)
         {
             buffer.putInt(typeOffset(consumerIndex), PADDING_MSG_TYPE_ID);
-            buffer.putIntOrdered(lengthOffset(consumerIndex), -length);
+            buffer.putIntRelease(lengthOffset(consumerIndex), -length);
             unblocked = true;
         }
         else if (0 == length)
@@ -426,7 +426,7 @@ else if (0 == length)
                     if (scanBackToConfirmStillZeroed(buffer, i, consumerIndex))
                     {
                         buffer.putInt(typeOffset(consumerIndex), PADDING_MSG_TYPE_ID);
-                        buffer.putIntOrdered(lengthOffset(consumerIndex), i - consumerIndex);
+                        buffer.putIntRelease(lengthOffset(consumerIndex), i - consumerIndex);
                         unblocked = true;
                     }
 
@@ -501,7 +501,7 @@ private int claimCapacity(final AtomicBuffer buffer, final int recordLength)
                     return INSUFFICIENT_CAPACITY;
                 }
 
-                buffer.putLongOrdered(headCachePositionIndex, head);
+                buffer.putLongRelease(headCachePositionIndex, head);
             }
             newTail = tail + requiredCapacity;
 
@@ -525,7 +525,7 @@ private int claimCapacity(final AtomicBuffer buffer, final int recordLength)
                         newTail = tail; // Do not claim any actual space, only pad to the buffer end
                     }
 
-                    buffer.putLongOrdered(headCachePositionIndex, head);
+                    buffer.putLongRelease(headCachePositionIndex, head);
                 }
 
                 padding = toBufferEndLength;
@@ -536,11 +536,11 @@ private int claimCapacity(final AtomicBuffer buffer, final int recordLength)
 
         if (0 != padding)
         {
-            buffer.putIntOrdered(lengthOffset(tailIndex), -padding);
+            buffer.putIntRelease(lengthOffset(tailIndex), -padding);
             VarHandle.releaseFence();
 
             buffer.putInt(typeOffset(tailIndex), PADDING_MSG_TYPE_ID);
-            buffer.putIntOrdered(lengthOffset(tailIndex), padding);
+            buffer.putIntRelease(lengthOffset(tailIndex), padding);
         }
 
         return writeIndex;
diff --git a/agrona/src/main/java/org/agrona/concurrent/ringbuffer/OneToOneRingBuffer.java b/agrona/src/main/java/org/agrona/concurrent/ringbuffer/OneToOneRingBuffer.java
index 2425e0ffc..e83d86789 100644
--- a/agrona/src/main/java/org/agrona/concurrent/ringbuffer/OneToOneRingBuffer.java
+++ b/agrona/src/main/java/org/agrona/concurrent/ringbuffer/OneToOneRingBuffer.java
@@ -100,12 +100,12 @@ public boolean write(final int msgTypeId, final DirectBuffer srcBuffer, final in
             return false;
         }
 
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
         VarHandle.releaseFence();
 
         buffer.putBytes(encodedMsgOffset(recordIndex), srcBuffer, offset, length);
         buffer.putInt(typeOffset(recordIndex), msgTypeId);
-        buffer.putIntOrdered(lengthOffset(recordIndex), recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), recordLength);
 
         return true;
     }
@@ -127,7 +127,7 @@ public int tryClaim(final int msgTypeId, final int length)
             return recordIndex;
         }
 
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
         VarHandle.releaseFence();
         buffer.putInt(typeOffset(recordIndex), msgTypeId);
 
@@ -143,7 +143,7 @@ public void commit(final int index)
         final AtomicBuffer buffer = this.buffer;
         final int recordLength = verifyClaimedSpaceNotReleased(buffer, recordIndex);
 
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
     }
 
     /**
@@ -156,7 +156,7 @@ public void abort(final int index)
         final int recordLength = verifyClaimedSpaceNotReleased(buffer, recordIndex);
 
         buffer.putInt(typeOffset(recordIndex), PADDING_MSG_TYPE_ID);
-        buffer.putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        buffer.putIntRelease(lengthOffset(recordIndex), -recordLength);
     }
 
     /**
@@ -211,7 +211,7 @@ public int read(final MessageHandler handler, final int messageCountLimit)
         {
             if (bytesRead > 0)
             {
-                buffer.putLongOrdered(headPositionIndex, head + bytesRead);
+                buffer.putLongRelease(headPositionIndex, head + bytesRead);
             }
         }
 
@@ -280,7 +280,7 @@ public int controlledRead(final ControlledMessageHandler handler, final int mess
                 }
                 if (COMMIT == action)
                 {
-                    buffer.putLongOrdered(headPositionIndex, head + bytesRead);
+                    buffer.putLongRelease(headPositionIndex, head + bytesRead);
                     headIndex += bytesRead;
                     head += bytesRead;
                     bytesRead = 0;
@@ -291,7 +291,7 @@ public int controlledRead(final ControlledMessageHandler handler, final int mess
         {
             if (bytesRead > 0)
             {
-                buffer.putLongOrdered(headPositionIndex, head + bytesRead);
+                buffer.putLongRelease(headPositionIndex, head + bytesRead);
             }
         }
 
@@ -327,7 +327,7 @@ public AtomicBuffer buffer()
      */
     public void consumerHeartbeatTime(final long time)
     {
-        buffer.putLongOrdered(consumerHeartbeatIndex, time);
+        buffer.putLongRelease(consumerHeartbeatIndex, time);
     }
 
     /**
@@ -441,7 +441,7 @@ private int claimCapacity(final AtomicBuffer buffer, final int recordLength)
 
         if (alignedRecordLength == toBufferEndLength) // message fits within the end of the buffer
         {
-            buffer.putLongOrdered(tailPositionIndex, nextTail);
+            buffer.putLongRelease(tailPositionIndex, nextTail);
             buffer.putLong(0, 0L); // pre-zero next message header
             return recordIndex;
         }
@@ -467,16 +467,16 @@ else if (requiredCapacity > toBufferEndLength)
             nextTail += padding;
         }
 
-        buffer.putLongOrdered(tailPositionIndex, nextTail);
+        buffer.putLongRelease(tailPositionIndex, nextTail);
 
         if (0 != padding)
         {
             buffer.putLong(0, 0L);
-            buffer.putIntOrdered(lengthOffset(recordIndex), -padding);
+            buffer.putIntRelease(lengthOffset(recordIndex), -padding);
             VarHandle.releaseFence();
 
             buffer.putInt(typeOffset(recordIndex), PADDING_MSG_TYPE_ID);
-            buffer.putIntOrdered(lengthOffset(recordIndex), padding);
+            buffer.putIntRelease(lengthOffset(recordIndex), padding);
         }
 
         if (INSUFFICIENT_CAPACITY != writeIndex)
diff --git a/agrona/src/main/java/org/agrona/concurrent/status/CountersManager.java b/agrona/src/main/java/org/agrona/concurrent/status/CountersManager.java
index 3e75333b5..aec0dda0e 100644
--- a/agrona/src/main/java/org/agrona/concurrent/status/CountersManager.java
+++ b/agrona/src/main/java/org/agrona/concurrent/status/CountersManager.java
@@ -209,7 +209,7 @@ public int allocate(final String label, final int typeId)
             metaDataBuffer.putLong(recordOffset + FREE_FOR_REUSE_DEADLINE_OFFSET, NOT_FREE_TO_REUSE);
             putLabel(recordOffset, label);
 
-            metaDataBuffer.putIntOrdered(recordOffset, RECORD_ALLOCATED);
+            metaDataBuffer.putIntRelease(recordOffset, RECORD_ALLOCATED);
         }
         catch (final Exception ex)
         {
@@ -244,7 +244,7 @@ public int allocate(final String label, final int typeId, final Consumer<Mutable
             metaDataBuffer.putLong(recordOffset + FREE_FOR_REUSE_DEADLINE_OFFSET, NOT_FREE_TO_REUSE);
             putLabel(recordOffset, label);
 
-            metaDataBuffer.putIntOrdered(recordOffset, RECORD_ALLOCATED);
+            metaDataBuffer.putIntRelease(recordOffset, RECORD_ALLOCATED);
         }
         catch (final Exception ex)
         {
@@ -297,7 +297,7 @@ public int allocate(
             metaDataBuffer.putInt(recordOffset + LABEL_OFFSET, length);
             metaDataBuffer.putBytes(recordOffset + LABEL_OFFSET + SIZE_OF_INT, labelBuffer, labelOffset, length);
 
-            metaDataBuffer.putIntOrdered(recordOffset, RECORD_ALLOCATED);
+            metaDataBuffer.putIntRelease(recordOffset, RECORD_ALLOCATED);
         }
         catch (final Exception ex)
         {
@@ -389,7 +389,7 @@ public void free(final int counterId)
             throw new IllegalStateException("counter not allocated: id=" + counterId);
         }
 
-        metaDataBuffer.putIntOrdered(offset, RECORD_RECLAIMED);
+        metaDataBuffer.putIntRelease(offset, RECORD_RECLAIMED);
         metaDataBuffer.setMemory(offset + KEY_OFFSET, MAX_KEY_LENGTH, (byte)0);
         metaDataBuffer.putLong(offset + FREE_FOR_REUSE_DEADLINE_OFFSET, epochClock.time() + freeToReuseTimeoutMs);
         freeList.addInt(counterId);
@@ -404,7 +404,7 @@ public void free(final int counterId)
     public void setCounterValue(final int counterId, final long value)
     {
         validateCounterId(counterId);
-        valuesBuffer.putLongOrdered(counterOffset(counterId), value);
+        valuesBuffer.putLongRelease(counterOffset(counterId), value);
     }
 
     /**
@@ -416,7 +416,7 @@ public void setCounterValue(final int counterId, final long value)
     public void setCounterRegistrationId(final int counterId, final long registrationId)
     {
         validateCounterId(counterId);
-        valuesBuffer.putLongOrdered(counterOffset(counterId) + REGISTRATION_ID_OFFSET, registrationId);
+        valuesBuffer.putLongRelease(counterOffset(counterId) + REGISTRATION_ID_OFFSET, registrationId);
     }
 
     /**
@@ -524,10 +524,10 @@ private int nextCounterId()
                     freeList.remove(i);
 
                     final int offset = counterOffset(counterId);
-                    valuesBuffer.putLongOrdered(offset + REGISTRATION_ID_OFFSET, DEFAULT_REGISTRATION_ID);
+                    valuesBuffer.putLongRelease(offset + REGISTRATION_ID_OFFSET, DEFAULT_REGISTRATION_ID);
                     valuesBuffer.putLong(offset + OWNER_ID_OFFSET, DEFAULT_OWNER_ID);
                     valuesBuffer.putLong(offset + REFERENCE_ID_OFFSET, DEFAULT_REFERENCE_ID);
-                    valuesBuffer.putLongOrdered(offset, 0L);
+                    valuesBuffer.putLongRelease(offset, 0L);
 
                     return counterId;
                 }
@@ -545,7 +545,7 @@ private void putLabel(final int recordOffset, final String label)
         {
             final int length = metaDataBuffer.putStringWithoutLengthAscii(
                 recordOffset + LABEL_OFFSET + SIZE_OF_INT, label, 0, MAX_LABEL_LENGTH);
-            metaDataBuffer.putIntOrdered(recordOffset + LABEL_OFFSET, length);
+            metaDataBuffer.putIntRelease(recordOffset + LABEL_OFFSET, length);
         }
         else
         {
@@ -553,7 +553,7 @@ private void putLabel(final int recordOffset, final String label)
             final int length = Math.min(bytes.length, MAX_LABEL_LENGTH);
 
             metaDataBuffer.putBytes(recordOffset + LABEL_OFFSET + SIZE_OF_INT, bytes, 0, length);
-            metaDataBuffer.putIntOrdered(recordOffset + LABEL_OFFSET, length);
+            metaDataBuffer.putIntRelease(recordOffset + LABEL_OFFSET, length);
         }
     }
 
@@ -567,7 +567,7 @@ private void appendLabel(final int recordOffset, final String suffix)
             final int suffixLength = metaDataBuffer.putStringWithoutLengthAscii(
                 recordOffset + LABEL_OFFSET + SIZE_OF_INT + existingLength, suffix, 0, maxSuffixLength);
 
-            metaDataBuffer.putIntOrdered(recordOffset + LABEL_OFFSET, existingLength + suffixLength);
+            metaDataBuffer.putIntRelease(recordOffset + LABEL_OFFSET, existingLength + suffixLength);
         }
         else
         {
@@ -576,7 +576,7 @@ private void appendLabel(final int recordOffset, final String suffix)
 
             metaDataBuffer.putBytes(
                 recordOffset + LABEL_OFFSET + SIZE_OF_INT + existingLength, suffixBytes, 0, suffixLength);
-            metaDataBuffer.putIntOrdered(recordOffset + LABEL_OFFSET, existingLength + suffixLength);
+            metaDataBuffer.putIntRelease(recordOffset + LABEL_OFFSET, existingLength + suffixLength);
         }
     }
 
diff --git a/agrona/src/test/java/org/agrona/concurrent/AtomicBufferTest.java b/agrona/src/test/java/org/agrona/concurrent/AtomicBufferTest.java
index 0680e1c52..b4876a50e 100644
--- a/agrona/src/test/java/org/agrona/concurrent/AtomicBufferTest.java
+++ b/agrona/src/test/java/org/agrona/concurrent/AtomicBufferTest.java
@@ -103,25 +103,25 @@ void shouldPutLongVolatileToNativeBuffer(final ByteBuffer buffer)
 
     @ParameterizedTest
     @MethodSource("atomicBuffers")
-    void shouldPutLongOrderedToNativeBuffer(final ByteBuffer buffer)
+    void shouldPutLongReleaseToNativeBuffer(final ByteBuffer buffer)
     {
         final UnsafeBuffer unsafeBuffer = new UnsafeBuffer(buffer);
 
-        unsafeBuffer.putLongOrdered(INDEX, LONG_VALUE);
+        unsafeBuffer.putLongRelease(INDEX, LONG_VALUE);
 
         assertThat(buffer.getLong(INDEX), is(LONG_VALUE));
     }
 
     @ParameterizedTest
     @MethodSource("atomicBuffers")
-    void shouldAddLongOrderedToNativeBuffer(final ByteBuffer buffer)
+    void shouldAddLongReleaseToNativeBuffer(final ByteBuffer buffer)
     {
         final UnsafeBuffer unsafeBuffer = new UnsafeBuffer(buffer);
 
         final long initialValue = Integer.MAX_VALUE + 7L;
         final long increment = 9L;
-        unsafeBuffer.putLongOrdered(INDEX, initialValue);
-        unsafeBuffer.addLongOrdered(INDEX, increment);
+        unsafeBuffer.putLongRelease(INDEX, initialValue);
+        unsafeBuffer.addLongRelease(INDEX, increment);
 
         assertThat(buffer.getLong(INDEX), is(initialValue + increment));
     }
@@ -215,25 +215,25 @@ void shouldPutIntVolatileToNativeBuffer(final ByteBuffer buffer)
 
     @ParameterizedTest
     @MethodSource("atomicBuffers")
-    void shouldPutIntOrderedToNativeBuffer(final ByteBuffer buffer)
+    void shouldPutIntReleaseToNativeBuffer(final ByteBuffer buffer)
     {
         final UnsafeBuffer unsafeBuffer = new UnsafeBuffer(buffer);
 
-        unsafeBuffer.putIntOrdered(INDEX, INT_VALUE);
+        unsafeBuffer.putIntRelease(INDEX, INT_VALUE);
 
         assertThat(buffer.getInt(INDEX), is(INT_VALUE));
     }
 
     @ParameterizedTest
     @MethodSource("atomicBuffers")
-    void shouldAddIntOrderedToNativeBuffer(final ByteBuffer buffer)
+    void shouldAddIntReleaseToNativeBuffer(final ByteBuffer buffer)
     {
         final UnsafeBuffer unsafeBuffer = new UnsafeBuffer(buffer);
 
         final int initialValue = 7;
         final int increment = 9;
-        unsafeBuffer.putIntOrdered(INDEX, initialValue);
-        unsafeBuffer.addIntOrdered(INDEX, increment);
+        unsafeBuffer.putIntRelease(INDEX, initialValue);
+        unsafeBuffer.addIntRelease(INDEX, increment);
 
         assertThat(buffer.getInt(INDEX), is(initialValue + increment));
     }
diff --git a/agrona/src/test/java/org/agrona/concurrent/broadcast/BroadcastTransmitterTest.java b/agrona/src/test/java/org/agrona/concurrent/broadcast/BroadcastTransmitterTest.java
index cb736a800..1d6e843c5 100644
--- a/agrona/src/test/java/org/agrona/concurrent/broadcast/BroadcastTransmitterTest.java
+++ b/agrona/src/test/java/org/agrona/concurrent/broadcast/BroadcastTransmitterTest.java
@@ -101,13 +101,13 @@ void shouldTransmitIntoEmptyBuffer()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getLong(TAIL_COUNTER_INDEX);
 
-        inOrder.verify(buffer).putLongOrdered(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned);
         inOrder.verify(buffer).putInt(lengthOffset(recordOffset), recordLength);
         inOrder.verify(buffer).putInt(typeOffset(recordOffset), MSG_TYPE_ID);
         inOrder.verify(buffer).putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length);
 
-        inOrder.verify(buffer).putLongOrdered(LATEST_COUNTER_INDEX, tail);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(LATEST_COUNTER_INDEX, tail);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
     }
 
     @Test
@@ -129,13 +129,13 @@ void shouldTransmitIntoUsedBuffer()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getLong(TAIL_COUNTER_INDEX);
 
-        inOrder.verify(buffer).putLongOrdered(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned);
         inOrder.verify(buffer).putInt(lengthOffset(recordOffset), recordLength);
         inOrder.verify(buffer).putInt(typeOffset(recordOffset), MSG_TYPE_ID);
         inOrder.verify(buffer).putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length);
 
-        inOrder.verify(buffer).putLongOrdered(LATEST_COUNTER_INDEX, tail);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(LATEST_COUNTER_INDEX, tail);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
     }
 
     @Test
@@ -158,13 +158,13 @@ void shouldTransmitIntoEndOfBuffer()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getLong(TAIL_COUNTER_INDEX);
 
-        inOrder.verify(buffer).putLongOrdered(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned);
         inOrder.verify(buffer).putInt(lengthOffset(recordOffset), recordLength);
         inOrder.verify(buffer).putInt(typeOffset(recordOffset), MSG_TYPE_ID);
         inOrder.verify(buffer).putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length);
 
-        inOrder.verify(buffer).putLongOrdered(LATEST_COUNTER_INDEX, tail);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(LATEST_COUNTER_INDEX, tail);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
     }
 
     @Test
@@ -187,7 +187,7 @@ void shouldApplyPaddingWhenInsufficientSpaceAtEndOfBuffer()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getLong(TAIL_COUNTER_INDEX);
 
-        inOrder.verify(buffer).putLongOrdered(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned + toEndOfBuffer);
+        inOrder.verify(buffer).putLongRelease(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned + toEndOfBuffer);
 
         inOrder.verify(buffer).putInt(lengthOffset(recordOffset), toEndOfBuffer);
         inOrder.verify(buffer).putInt(typeOffset(recordOffset), PADDING_MSG_TYPE_ID);
@@ -198,7 +198,7 @@ void shouldApplyPaddingWhenInsufficientSpaceAtEndOfBuffer()
         inOrder.verify(buffer).putInt(typeOffset(recordOffset), MSG_TYPE_ID);
         inOrder.verify(buffer).putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length);
 
-        inOrder.verify(buffer).putLongOrdered(LATEST_COUNTER_INDEX, tail);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
+        inOrder.verify(buffer).putLongRelease(LATEST_COUNTER_INDEX, tail);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + recordLengthAligned);
     }
 }
diff --git a/agrona/src/test/java/org/agrona/concurrent/errors/DistinctErrorLogTest.java b/agrona/src/test/java/org/agrona/concurrent/errors/DistinctErrorLogTest.java
index 57fefd3c6..7469f06b7 100644
--- a/agrona/src/test/java/org/agrona/concurrent/errors/DistinctErrorLogTest.java
+++ b/agrona/src/test/java/org/agrona/concurrent/errors/DistinctErrorLogTest.java
@@ -61,9 +61,9 @@ void shouldRecordFirstObservation()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestamp);
-        inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), anyInt());
+        inOrder.verify(buffer).putIntRelease(eq(offset + LENGTH_OFFSET), anyInt());
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestamp);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestamp);
     }
 
     @Test
@@ -82,11 +82,11 @@ void shouldRecordFirstObservationOnly()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
-        inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), anyInt());
+        inOrder.verify(buffer).putIntRelease(eq(offset + LENGTH_OFFSET), anyInt());
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
     }
 
     @Test
@@ -106,17 +106,17 @@ void shouldRecordDifferentMessage()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
-        inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), lengthArg.capture());
+        inOrder.verify(buffer).putIntRelease(eq(offset + LENGTH_OFFSET), lengthArg.capture());
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
 
         final int recordTwoOffset = BitUtil.align(lengthArg.getValue(), RECORD_ALIGNMENT);
 
         inOrder.verify(buffer).putBytes(eq(recordTwoOffset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(recordTwoOffset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
-        inOrder.verify(buffer).putIntOrdered(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
+        inOrder.verify(buffer).putIntRelease(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
         inOrder.verify(buffer).getAndAddInt(recordTwoOffset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
+        inOrder.verify(buffer).putLongRelease(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
     }
 
     @Test
@@ -135,12 +135,12 @@ void shouldSummariseObservations()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
-        inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), anyInt());
+        inOrder.verify(buffer).putIntRelease(eq(offset + LENGTH_OFFSET), anyInt());
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
 
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
     }
 
     @Test
@@ -162,17 +162,17 @@ void shouldRecordTwoDistinctObservations()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
-        inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), lengthArg.capture());
+        inOrder.verify(buffer).putIntRelease(eq(offset + LENGTH_OFFSET), lengthArg.capture());
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
 
         final int recordTwoOffset = BitUtil.align(lengthArg.getValue(), RECORD_ALIGNMENT);
 
         inOrder.verify(buffer).putBytes(eq(recordTwoOffset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(recordTwoOffset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
-        inOrder.verify(buffer).putIntOrdered(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
+        inOrder.verify(buffer).putIntRelease(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
         inOrder.verify(buffer).getAndAddInt(recordTwoOffset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
+        inOrder.verify(buffer).putLongRelease(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
     }
 
     @Test
@@ -196,17 +196,17 @@ void shouldRecordTwoDistinctObservationsOnCause()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putBytes(eq(offset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(offset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
-        inOrder.verify(buffer).putIntOrdered(eq(offset + LENGTH_OFFSET), lengthArg.capture());
+        inOrder.verify(buffer).putIntRelease(eq(offset + LENGTH_OFFSET), lengthArg.capture());
         inOrder.verify(buffer).getAndAddInt(offset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
+        inOrder.verify(buffer).putLongRelease(offset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampOne);
 
         final int recordTwoOffset = BitUtil.align(lengthArg.getValue(), RECORD_ALIGNMENT);
 
         inOrder.verify(buffer).putBytes(eq(recordTwoOffset + ENCODED_ERROR_OFFSET), any(byte[].class));
         inOrder.verify(buffer).putLong(recordTwoOffset + FIRST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
-        inOrder.verify(buffer).putIntOrdered(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
+        inOrder.verify(buffer).putIntRelease(eq(recordTwoOffset + LENGTH_OFFSET), anyInt());
         inOrder.verify(buffer).getAndAddInt(recordTwoOffset + OBSERVATION_COUNT_OFFSET, 1);
-        inOrder.verify(buffer).putLongOrdered(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
+        inOrder.verify(buffer).putLongRelease(recordTwoOffset + LAST_OBSERVATION_TIMESTAMP_OFFSET, timestampTwo);
     }
 
     @ParameterizedTest
diff --git a/agrona/src/test/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBufferTest.java b/agrona/src/test/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBufferTest.java
index 6d4eeac40..86d7a433a 100644
--- a/agrona/src/test/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBufferTest.java
+++ b/agrona/src/test/java/org/agrona/concurrent/ringbuffer/ManyToOneRingBufferTest.java
@@ -111,10 +111,10 @@ void shouldWriteToEmptyBuffer()
         assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), -recordLength);
         inOrder.verify(buffer).putBytes(encodedMsgOffset((int)tail), srcBuffer, srcIndex, length);
         inOrder.verify(buffer).putInt(typeOffset((int)tail), MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), recordLength);
     }
 
     @Test
@@ -135,7 +135,7 @@ void shouldRejectWriteWhenInsufficientSpace()
         verify(buffer, never()).putInt(anyInt(), anyInt());
         verify(buffer, never()).compareAndSetLong(anyInt(), anyLong(), anyLong());
         verify(buffer, never()).putBytes(anyInt(), eq(srcBuffer), anyInt(), anyInt());
-        verify(buffer, never()).putIntOrdered(anyInt(), anyInt());
+        verify(buffer, never()).putIntRelease(anyInt(), anyInt());
     }
 
     @Test
@@ -155,7 +155,7 @@ void shouldRejectWriteWhenBufferFull()
 
         verify(buffer, never()).putInt(anyInt(), anyInt());
         verify(buffer, never()).compareAndSetLong(anyInt(), anyLong(), anyLong());
-        verify(buffer, never()).putIntOrdered(anyInt(), anyInt());
+        verify(buffer, never()).putIntRelease(anyInt(), anyInt());
     }
 
     @Test
@@ -178,14 +178,14 @@ void shouldInsertPaddingRecordPlusMessageOnBufferWrap()
         assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), -HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), -HEADER_LENGTH);
         inOrder.verify(buffer).putInt(typeOffset((int)tail), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), HEADER_LENGTH);
 
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), -recordLength);
         inOrder.verify(buffer).putBytes(encodedMsgOffset(0), srcBuffer, srcIndex, length);
         inOrder.verify(buffer).putInt(typeOffset(0), MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), recordLength);
     }
 
     @Test
@@ -208,14 +208,14 @@ void shouldInsertPaddingRecordPlusMessageOnBufferWrapWithHeadEqualToTail()
         assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), -HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), -HEADER_LENGTH);
         inOrder.verify(buffer).putInt(typeOffset((int)tail), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), HEADER_LENGTH);
 
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), -recordLength);
         inOrder.verify(buffer).putBytes(encodedMsgOffset(0), srcBuffer, srcIndex, length);
         inOrder.verify(buffer).putInt(typeOffset(0), MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), recordLength);
     }
 
     @Test
@@ -250,7 +250,7 @@ void shouldNotReadSingleMessagePartWayThroughWriting()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer, times(1)).getIntVolatile(lengthOffset(headIndex));
         inOrder.verify(buffer, times(0)).setMemory(headIndex, 0, (byte)0);
-        inOrder.verify(buffer, times(0)).putLongOrdered(HEAD_COUNTER_INDEX, headIndex);
+        inOrder.verify(buffer, times(0)).putLongRelease(HEAD_COUNTER_INDEX, headIndex);
     }
 
     @Test
@@ -278,7 +278,7 @@ void shouldReadTwoMessages()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer, times(1)).setMemory(headIndex, alignedRecordLength * 2, (byte)0);
-        inOrder.verify(buffer, times(1)).putLongOrdered(HEAD_COUNTER_INDEX, tail);
+        inOrder.verify(buffer, times(1)).putLongRelease(HEAD_COUNTER_INDEX, tail);
     }
 
     @Test
@@ -304,7 +304,7 @@ void shouldLimitReadOfMessages()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer, times(1)).setMemory(headIndex, alignedRecordLength, (byte)0);
-        inOrder.verify(buffer, times(1)).putLongOrdered(HEAD_COUNTER_INDEX, head + alignedRecordLength);
+        inOrder.verify(buffer, times(1)).putLongRelease(HEAD_COUNTER_INDEX, head + alignedRecordLength);
     }
 
     @Test
@@ -343,7 +343,7 @@ void shouldCopeWithExceptionFromHandler()
 
             final InOrder inOrder = inOrder(buffer);
             inOrder.verify(buffer, times(1)).setMemory(headIndex, alignedRecordLength * 2, (byte)0);
-            inOrder.verify(buffer, times(1)).putLongOrdered(HEAD_COUNTER_INDEX, tail);
+            inOrder.verify(buffer, times(1)).putLongRelease(HEAD_COUNTER_INDEX, tail);
 
             return;
         }
@@ -373,7 +373,7 @@ void shouldUnblockMessageWithHeader()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putInt(typeOffset(messageLength), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(messageLength), messageLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(messageLength), messageLength);
     }
 
     @Test
@@ -388,7 +388,7 @@ void shouldUnblockWhenFullWithHeader()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putInt(typeOffset(messageLength), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(messageLength), messageLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(messageLength), messageLength);
     }
 
     @Test
@@ -403,7 +403,7 @@ void shouldUnblockWhenFullWithoutHeader()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putInt(typeOffset(messageLength), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(messageLength), messageLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(messageLength), messageLength);
     }
 
     @Test
@@ -418,7 +418,7 @@ void shouldUnblockGapWithZeros()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).putInt(typeOffset(messageLength), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(messageLength), messageLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(messageLength), messageLength);
     }
 
     @Test
@@ -536,7 +536,7 @@ void tryClaimReturnsIndexAtWhichEncodedMessageStarts()
         inOrder.verify(buffer).getLongVolatile(HEAD_COUNTER_CACHE_INDEX);
         inOrder.verify(buffer).getLongVolatile(TAIL_COUNTER_INDEX);
         inOrder.verify(buffer).compareAndSetLong(TAIL_COUNTER_INDEX, tailPosition, tailPosition + alignedRecordLength);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(recordIndex), -recordLength);
         inOrder.verify(buffer).putInt(typeOffset(recordIndex), MSG_TYPE_ID);
         inOrder.verifyNoMoreInteractions();
     }
@@ -566,10 +566,10 @@ void tryClaimReturnsIndexAtWhichEncodedMessageStartsAfterPadding()
         inOrder.verify(buffer).getLongVolatile(TAIL_COUNTER_INDEX);
         inOrder.verify(buffer)
             .compareAndSetLong(TAIL_COUNTER_INDEX, tailPosition, tailPosition + alignedRecordLength + padding);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(paddingIndex), -padding);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(paddingIndex), -padding);
         inOrder.verify(buffer).putInt(typeOffset(paddingIndex), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(paddingIndex), padding);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(paddingIndex), padding);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(recordIndex), -recordLength);
         inOrder.verify(buffer).putInt(typeOffset(recordIndex), MSG_TYPE_ID);
         inOrder.verifyNoMoreInteractions();
     }
@@ -618,13 +618,13 @@ void tryClaimReturnsInsufficientCapacityTail()
         inOrder.verify(buffer).getLongVolatile(HEAD_COUNTER_CACHE_INDEX);
         inOrder.verify(buffer).getLongVolatile(TAIL_COUNTER_INDEX);
         inOrder.verify(buffer).getLongVolatile(HEAD_COUNTER_INDEX);
-        inOrder.verify(buffer).putLongOrdered(HEAD_COUNTER_CACHE_INDEX, headPosition);
+        inOrder.verify(buffer).putLongRelease(HEAD_COUNTER_CACHE_INDEX, headPosition);
         inOrder.verify(buffer).getLongVolatile(HEAD_COUNTER_INDEX);
-        inOrder.verify(buffer).putLongOrdered(HEAD_COUNTER_CACHE_INDEX, headPosition);
+        inOrder.verify(buffer).putLongRelease(HEAD_COUNTER_CACHE_INDEX, headPosition);
         inOrder.verify(buffer).compareAndSetLong(TAIL_COUNTER_INDEX, tailPosition, tailPosition + padding);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(paddingIndex), -padding);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(paddingIndex), -padding);
         inOrder.verify(buffer).putInt(typeOffset(paddingIndex), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(paddingIndex), padding);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(paddingIndex), padding);
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -659,7 +659,7 @@ void commitPublishesMessageByInvertingTheLengthValue()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getInt(lengthOffset(recordIndex));
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(recordIndex), -recordLength);
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -695,7 +695,7 @@ void abortMarksUnusedSpaceAsPadding()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getInt(lengthOffset(recordIndex));
         inOrder.verify(buffer).putInt(typeOffset(recordIndex), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(recordIndex), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(recordIndex), -recordLength);
         inOrder.verifyNoMoreInteractions();
     }
 
diff --git a/agrona/src/test/java/org/agrona/concurrent/ringbuffer/OneToOneRingBufferTest.java b/agrona/src/test/java/org/agrona/concurrent/ringbuffer/OneToOneRingBufferTest.java
index e13d9f40c..8d04fe511 100644
--- a/agrona/src/test/java/org/agrona/concurrent/ringbuffer/OneToOneRingBufferTest.java
+++ b/agrona/src/test/java/org/agrona/concurrent/ringbuffer/OneToOneRingBufferTest.java
@@ -107,12 +107,12 @@ void shouldWriteToEmptyBuffer()
         assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + alignedRecordLength);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + alignedRecordLength);
         inOrder.verify(buffer).putLong((int)tail + alignedRecordLength, 0L);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), -recordLength);
         inOrder.verify(buffer).putBytes(encodedMsgOffset((int)tail), srcBuffer, srcIndex, length);
         inOrder.verify(buffer).putInt(typeOffset((int)tail), MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), recordLength);
     }
 
     @Test
@@ -132,8 +132,8 @@ void shouldRejectWriteWhenInsufficientSpace()
 
         verify(buffer, never()).putBytes(anyInt(), eq(srcBuffer), anyInt(), anyInt());
         verify(buffer, never()).putLong(anyInt(), anyInt());
-        verify(buffer, never()).putLongOrdered(anyInt(), anyInt());
-        verify(buffer, never()).putIntOrdered(anyInt(), anyInt());
+        verify(buffer, never()).putLongRelease(anyInt(), anyInt());
+        verify(buffer, never()).putIntRelease(anyInt(), anyInt());
     }
 
     @Test
@@ -151,7 +151,7 @@ void shouldRejectWriteWhenBufferFull()
         final int srcIndex = 0;
         assertFalse(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
-        verify(buffer, never()).putLongOrdered(anyInt(), anyInt());
+        verify(buffer, never()).putLongRelease(anyInt(), anyInt());
     }
 
     @Test
@@ -172,19 +172,19 @@ void shouldInsertPaddingRecordPlusMessageOnBufferWrap()
         assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + alignedRecordLength + HEADER_LENGTH);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + alignedRecordLength + HEADER_LENGTH);
 
         inOrder.verify(buffer).putLong(0, 0L);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), -HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), -HEADER_LENGTH);
         inOrder.verify(buffer).putInt(typeOffset((int)tail), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), HEADER_LENGTH);
 
         inOrder.verify(buffer).putLong(alignedRecordLength, 0L);
 
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), -recordLength);
         inOrder.verify(buffer).putBytes(encodedMsgOffset(0), srcBuffer, srcIndex, length);
         inOrder.verify(buffer).putInt(typeOffset(0), MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), recordLength);
     }
 
     @Test
@@ -205,19 +205,19 @@ void shouldInsertPaddingRecordPlusMessageOnBufferWrapWithHeadEqualToTail()
         assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + alignedRecordLength + HEADER_LENGTH);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, tail + alignedRecordLength + HEADER_LENGTH);
 
         inOrder.verify(buffer).putLong(0, 0L);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), -HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), -HEADER_LENGTH);
         inOrder.verify(buffer).putInt(typeOffset((int)tail), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset((int)tail), HEADER_LENGTH);
+        inOrder.verify(buffer).putIntRelease(lengthOffset((int)tail), HEADER_LENGTH);
 
         inOrder.verify(buffer).putLong(alignedRecordLength, 0L);
 
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), -recordLength);
         inOrder.verify(buffer).putBytes(encodedMsgOffset(0), srcBuffer, srcIndex, length);
         inOrder.verify(buffer).putInt(typeOffset(0), MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), recordLength);
     }
 
     @Test
@@ -252,7 +252,7 @@ void shouldNotReadSingleMessagePartWayThroughWriting()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer, times(1)).getIntVolatile(lengthOffset(headIndex));
         inOrder.verify(buffer, times(0)).setMemory(anyInt(), anyInt(), anyByte());
-        inOrder.verify(buffer, times(0)).putLongOrdered(HEAD_COUNTER_INDEX, headIndex);
+        inOrder.verify(buffer, times(0)).putLongRelease(HEAD_COUNTER_INDEX, headIndex);
     }
 
     @Test
@@ -279,7 +279,7 @@ void shouldReadTwoMessages()
         assertThat(times.get(), is(2));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer, times(1)).putLongOrdered(HEAD_COUNTER_INDEX, tail);
+        inOrder.verify(buffer, times(1)).putLongRelease(HEAD_COUNTER_INDEX, tail);
         inOrder.verify(buffer, times(0)).setMemory(anyInt(), anyInt(), anyByte());
     }
 
@@ -305,7 +305,7 @@ void shouldLimitReadOfMessages()
         assertThat(times.get(), is(1));
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer, times(1)).putLongOrdered(HEAD_COUNTER_INDEX, head + alignedRecordLength);
+        inOrder.verify(buffer, times(1)).putLongRelease(HEAD_COUNTER_INDEX, head + alignedRecordLength);
         inOrder.verify(buffer, times(0)).setMemory(anyInt(), anyInt(), anyByte());
     }
 
@@ -344,7 +344,7 @@ void shouldCopeWithExceptionFromHandler()
             assertThat(times.get(), is(2));
 
             final InOrder inOrder = inOrder(buffer);
-            inOrder.verify(buffer, times(1)).putLongOrdered(HEAD_COUNTER_INDEX, tail);
+            inOrder.verify(buffer, times(1)).putLongRelease(HEAD_COUNTER_INDEX, tail);
             inOrder.verify(buffer, times(0)).setMemory(anyInt(), anyInt(), anyByte());
 
             return;
@@ -435,9 +435,9 @@ void tryClaimReturnsOffsetAtWhichMessageBodyCanBeWritten()
         assertEquals(HEADER_LENGTH, index);
 
         final InOrder inOrder = inOrder(buffer);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, alignedRecordLength);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, alignedRecordLength);
         inOrder.verify(buffer).putLong(alignedRecordLength, 0L);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(0), -recordLength);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(0), -recordLength);
         inOrder.verify(buffer).putInt(typeOffset(0), msgTypeId);
     }
 
@@ -478,12 +478,12 @@ void tryClaimReturnsInsufficientCapacityIfThereIsNotEnoughSpaceInTheBufferAfterW
         inOrder.verify(buffer).putLong(HEAD_COUNTER_CACHE_INDEX, CAPACITY + 111L);
         inOrder.verify(buffer).getLongVolatile(HEAD_COUNTER_INDEX);
         inOrder.verify(buffer).putLong(HEAD_COUNTER_CACHE_INDEX, 3L);
-        inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, CAPACITY * 2L);
+        inOrder.verify(buffer).putLongRelease(TAIL_COUNTER_INDEX, CAPACITY * 2L);
         final int paddingIndex = CAPACITY - 10;
         inOrder.verify(buffer).putLong(0, 0L);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(paddingIndex), -10);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(paddingIndex), -10);
         inOrder.verify(buffer).putInt(typeOffset(paddingIndex), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(paddingIndex), 10);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(paddingIndex), 10);
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -517,7 +517,7 @@ void commitPublishesMessageByInvertingTheLengthValue()
 
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getInt(lengthOffset(recordIndex));
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(recordIndex), 19);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(recordIndex), 19);
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -552,7 +552,7 @@ void abortMarksUnusedSpaceAsPadding()
         final InOrder inOrder = inOrder(buffer);
         inOrder.verify(buffer).getInt(lengthOffset(recordIndex));
         inOrder.verify(buffer).putInt(typeOffset(recordIndex), PADDING_MSG_TYPE_ID);
-        inOrder.verify(buffer).putIntOrdered(lengthOffset(recordIndex), 11111);
+        inOrder.verify(buffer).putIntRelease(lengthOffset(recordIndex), 11111);
         inOrder.verifyNoMoreInteractions();
     }