引用計數是一種常用的記憶體管理機制，是指將資源的被引用次數儲存起來，當被引用次數變為零時就將其釋放的過程。Netty在4。x版本開始使用引用計數機制進行部分物件的管理，其實現思路並不是特別複雜，它主要涉及跟蹤某個物件被引用的次數。在Netty具體程式碼中需要透過引用計數進行記憶體管理的物件，會基於ReferenceCounted介面實現，其中引用計數大於0時則代表該物件被引用不會釋放，當引用計數減少到0時，該物件就會被釋放。透過引用計數機制，Netty可以很好的實現記憶體管理，引用計數減少到0時要麼直接釋放記憶體，要麼放回記憶體池中重複利用。
1、基本示例
下面先透過一個簡單示例看下Netty中引用計數機制的使用
@Override public void channelRead（ChannelHandlerContext ctx， Object msg） { ByteBuf recvBuffer = （ByteBuf） msg；// 申請ByteBuf 需要主動釋放 if（recvBuffer。isDirect（））{ System。err。println（true）； } PooledByteBufAllocator allocator = new PooledByteBufAllocator（true）； ByteBuf sendBuffer = allocator。buffer（）；//申請池化直接記憶體 System。err。println（“sendBuffer的引用計數：”+sendBuffer。refCnt（））； sendBuffer。retain（）； System。err。println（“sendBuffer的引用計數：”+sendBuffer。refCnt（））； sendBuffer。release（）； System。err。println（“sendBuffer的引用計數：”+sendBuffer。refCnt（））； try { byte［］ bytesReady = new byte［recvBuffer。readableBytes（）］； recvBuffer。readBytes（bytesReady）； System。out。println（“channelRead收到資料：”+ BytesUtils。toHexString（bytesReady））； byte［］ sendBytes = new byte［］ {0x7E，0x01，0x02，0x7e}； sendBuffer。writeBytes（sendBytes）； ctx。writeAndFlush（sendBuffer）； System。err。println（“sendBuffer的引用計數：”+sendBuffer。refCnt（））； }catch （Exception e） { // TODO： handle exception System。err。println（e。getMessage（））； }finally { System。err。println（“recvBuffer的引用計數：”+recvBuffer。refCnt（））； recvBuffer。release（）； //此處需要釋放 System。err。println（“recvBuffer的引用計數：”+recvBuffer。refCnt（））； } }
輸出結果如下，透過示例可以看出retain方法會增加計數引用，release方法會減少計數引用
truesendBuffer的引用計數：1sendBuffer的引用計數：2sendBuffer的引用計數：1sendBuffer的引用計數：0recvBuffer的引用計數：1recvBuffer的引用計數：0
AbstractReferenceCountedByteBuf實現了對ByteBuf的記憶體管理，以實現記憶體的回收、釋放或者重複利用 ，AbstractReferenceCountedByteBuf的繼承實現關係如下圖所示
2、ReferenceCounted介面定義
首先是ReferenceCounted介面的定義
public interface ReferenceCounted { /** * Returns the reference count of this object。 If {@code 0}， it means this object has been deallocated。 * 返回物件的引用計數 */ int refCnt（）； /** * Increases the reference count by {@code 1}。 * 增加引用計數 */ ReferenceCounted retain（）； /** * Increases the reference count by the specified {@code increment}。 * 引用計數增加指定值 */ ReferenceCounted retain（int increment）； /** * Records the current access location of this object for debugging purposes。 * If this object is determined to be leaked， the information recorded by this operation will be provided to you * via {@link ResourceLeakDetector}。 This method is a shortcut to {@link #touch（Object） touch（null）}。 * 記錄該物件的當前訪問位置，用於除錯。 * 如果確定該物件被洩露，將提供此操作記錄的資訊給您 */ ReferenceCounted touch（）； /** * Records the current access location of this object with an additional arbitrary information for debugging * purposes。 If this object is determined to be leaked， the information recorded by this operation will be * provided to you via {@link ResourceLeakDetector}。 * 記錄該物件的當前訪問位置，附加資訊用於除錯。 * 如果確定該物件被洩露，將提供此操作記錄的資訊給您 */ ReferenceCounted touch（Object hint）； /** * Decreases the reference count by {@code 1} and deallocates this object if the reference count reaches at * {@code 0}。 * * @return {@code true} if and only if the reference count became {@code 0} and this object has been deallocated * 引用計數減少，如果計數變為了0，則釋放物件資源 * 如果物件資源被釋放，則返回true，否則返回false */ boolean release（）； /** * Decreases the reference count by the specified {@code decrement} and deallocates this object if the reference * count reaches at {@code 0}。 * * @return {@code true} if and only if the reference count became {@code 0} and this object has been deallocated * 引用計數-指定值，如果計數變為了0，則釋放物件資源或交回到物件池 * 如果物件資源被釋放，則返回true，否則返回false */ boolean release（int decrement）；}
3、AbstractReferenceCountedByteBuf原始碼分析
AbstractReferenceCountedByteBuf對ReferenceCounted進行了具體實現，retain與release兩個方法透過CAS方式對引用計數refcnt進行操作，下面對其原始碼進行簡單分析
初始化
引用計數初始值refCnt 使用關鍵字volatile修飾，保證執行緒的可見性，同時使用偶數，引用增加透過位移操作實現，提高運算效率。
採用 AtomicIntegerFieldUpdater 物件，透過CAS方式更新refCnt，以實現執行緒安全，避免加鎖，提高效率。
private static final long REFCNT_FIELD_OFFSET； //採用 AtomicIntegerFieldUpdater 物件，CAS方式更新refCnt private static final AtomicIntegerFieldUpdater
retain操作
上面示例中每呼叫一次retain方法，引用計數就會累加一次，我們看下原始碼中retain的具體實現
public ByteBuf retain（） { return retain0（1）； } @Override public ByteBuf retain（int increment） { return retain0（checkPositive（increment， “increment”））； } //計數器增值操作 private ByteBuf retain0（final int increment） { // all changes to the raw count are 2x the “real” change int adjustedIncrement = increment << 1； // overflow OK here 真正的計數都是2倍遞增 int oldRef = refCntUpdater。getAndAdd（this， adjustedIncrement）； //透過CAS方式遞增並獲取原值 if （（oldRef & 1） ！= 0） {//判斷奇偶，正常情況這裡應該都是偶數 throw new IllegalReferenceCountException（0， increment）； } // don‘t pass 0！ 如果計數小於等於0，以及整型範圍越界（0x7fffffff+1）丟擲異常 if （（oldRef <= 0 && oldRef + adjustedIncrement >= 0） || （oldRef >= 0 && oldRef + adjustedIncrement < oldRef）） { // overflow case refCntUpdater。getAndAdd（this， -adjustedIncrement）； throw new IllegalReferenceCountException（realRefCnt（oldRef）， increment）； } return this； }
release操作
透過呼叫release方法，對引用計數做減值操作，原始碼中release的具體實現要注意的是由於引用計數以2倍遞增，所以引用次數= 引用計數/2，當decrement=refcnt/2 也就是引用次數=釋放次數時，代表ByteBuf不再被引用，執行記憶體釋放或放回記憶體池的操作。
//計數器減值操作 private boolean release0（int decrement） { int rawCnt = nonVolatileRawCnt（）， realCnt = toLiveRealCnt（rawCnt， decrement）； //對計數器進行除以2操作，也就是引用次數 /** * /這裡如注意 你傳入的減值引數decrement = realCnt 時 等同於 引用次數=釋放次數，直接進行釋放操作 */ if （decrement == realCnt） { if （refCntUpdater。compareAndSet（this， rawCnt， 1）） { //CAS方式置為1 deallocate（）；//記憶體釋放或放回記憶體池 return true； } return retryRelease0（decrement）；//進入具體操作 } return releaseNonFinal0（decrement， rawCnt， realCnt）； } private boolean releaseNonFinal0（int decrement， int rawCnt， int realCnt） { //如果decrement 小於 realCnt，透過CAS方式減去decrement*2 if （decrement < realCnt // all changes to the raw count are 2x the “real” change && refCntUpdater。compareAndSet（this， rawCnt， rawCnt - （decrement << 1））） { return false； } return retryRelease0（decrement）； } private boolean retryRelease0（int decrement） { for （；；） { int rawCnt = refCntUpdater。get（this）， realCnt = toLiveRealCnt（rawCnt， decrement）； if （decrement == realCnt） { if （refCntUpdater。compareAndSet（this， rawCnt， 1）） { deallocate（）； return true； } } else if （decrement < realCnt） {//如果decrement 小於 realCnt，透過CAS方式減去decrement*2 // all changes to the raw count are 2x the “real” change if （refCntUpdater。compareAndSet（this， rawCnt， rawCnt - （decrement << 1））） { return false； } } else { throw new IllegalReferenceCountException（realCnt， -decrement）； } Thread。yield（）； // this benefits throughput under high contention } } /** * Like {@link #realRefCnt（int）} but throws if refCnt == 0 */ private static int toLiveRealCnt（int rawCnt， int decrement） { if （（rawCnt & 1） == 0） { return rawCnt >>> 1； } // odd rawCnt => already deallocated throw new IllegalReferenceCountException（0， -decrement）； }
4、總結
以上我們圍繞AbstractReferenceCountedByteBuf對Netty引用計數的具體實現進行了分析，可以看到Netty在實現引用計數的同時，結合CAS、位移計算等方式，保證了運算效率和執行緒安全，在實際專案中我們遇到類似應用場景也都可以借鑑參考，如資料傳送次數，商品剩餘數量等計數場景的實現。希望本文對大家能有所幫助，其中如有不足與不正確的地方還望指正與海涵，十分感謝。
