View Javadoc
1   /*
2    * Copyright 2013 The Netty Project
3    *
4    * The Netty Project licenses this file to you under the Apache License,
5    * version 2.0 (the "License"); you may not use this file except in compliance
6    * with the License. You may obtain a copy of the License at:
7    *
8    *   https://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations
14   * under the License.
15   */
16  package io.netty.util;
17  
18  import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
19  
20  import io.netty.util.internal.ReferenceCountUpdater;
21  
22  /**
23   * Abstract base class for classes wants to implement {@link ReferenceCounted}.
24   */
25  public abstract class AbstractReferenceCounted implements ReferenceCounted {
26      private static final long REFCNT_FIELD_OFFSET =
27              ReferenceCountUpdater.getUnsafeOffset(AbstractReferenceCounted.class, "refCnt");
28      private static final AtomicIntegerFieldUpdater<AbstractReferenceCounted> AIF_UPDATER =
29              AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCounted.class, "refCnt");
30  
31      private static final ReferenceCountUpdater<AbstractReferenceCounted> updater =
32              new ReferenceCountUpdater<AbstractReferenceCounted>() {
33          @Override
34          protected AtomicIntegerFieldUpdater<AbstractReferenceCounted> updater() {
35              return AIF_UPDATER;
36          }
37          @Override
38          protected long unsafeOffset() {
39              return REFCNT_FIELD_OFFSET;
40          }
41      };
42  
43      // Value might not equal "real" reference count, all access should be via the updater
44      @SuppressWarnings({"unused", "FieldMayBeFinal"})
45      private volatile int refCnt = updater.initialValue();
46  
47      @Override
48      public int refCnt() {
49          return updater.refCnt(this);
50      }
51  
52      /**
53       * An unsafe operation intended for use by a subclass that sets the reference count of the buffer directly
54       */
55      protected final void setRefCnt(int refCnt) {
56          updater.setRefCnt(this, refCnt);
57      }
58  
59      @Override
60      public ReferenceCounted retain() {
61          return updater.retain(this);
62      }
63  
64      @Override
65      public ReferenceCounted retain(int increment) {
66          return updater.retain(this, increment);
67      }
68  
69      @Override
70      public ReferenceCounted touch() {
71          return touch(null);
72      }
73  
74      @Override
75      public boolean release() {
76          return handleRelease(updater.release(this));
77      }
78  
79      @Override
80      public boolean release(int decrement) {
81          return handleRelease(updater.release(this, decrement));
82      }
83  
84      private boolean handleRelease(boolean result) {
85          if (result) {
86              deallocate();
87          }
88          return result;
89      }
90  
91      /**
92       * Called once {@link #refCnt()} is equals 0.
93       */
94      protected abstract void deallocate();
95  }