Faster Recycler's claim/release (Fixes netty#13153)

Motivation:

Recycler's claim/release can be made faster by saving expensive volatile ops, when not needed.
For claim, always, while for release, if the owner thread is performing release itself.

Modification:

Replacing expensive volatile ops with ordered ones.

Result:

Faster Recycler's claim/release

common/src/main/java/io/netty/util/Recycler.java

@@ -252,7 +252,15 @@ void set(T value) {
 
         void toClaimed() {
             assert state == STATE_AVAILABLE;
-            state = STATE_CLAIMED;
+            STATE_UPDATER.lazySet(this, STATE_CLAIMED);
+        }
+
+        void toOrderedAvailable() {
+            int prev = state;
+            if (prev == STATE_AVAILABLE) {
+                throw new IllegalStateException("Object has been recycled already.");
+            }
+            STATE_UPDATER.lazySet(this, STATE_AVAILABLE);
         }
 
         void toAvailable() {
@@ -302,9 +310,14 @@ DefaultHandle<T> claim() {
         }
 
         void release(DefaultHandle<T> handle) {
-            handle.toAvailable();
-            Thread owner = this.owner;
-            if (owner != null && Thread.currentThread() == owner && batch.size() < chunkSize) {
+            final Thread owner = this.owner;
+            final boolean releaseByOwner = owner != null && Thread.currentThread() == owner;
+            if (releaseByOwner) {
+                handle.toOrderedAvailable();
+            } else {
+                handle.toAvailable();
+            }
+            if (releaseByOwner && batch.size() < chunkSize) {
                 accept(handle);
             } else if (owner != null && owner.getState() == Thread.State.TERMINATED) {
                 this.owner = null;