Netty - ByteBuf (3)

1. Netty - ByteBuf (3)

1.3 ByteBuf相关实现源码

相关类继承关系

其中，我们从AbstractByteBuf和他的子类开始分析，其他的多为衍生工具类。

1.3.1. AbstractByteBuf

上一节主要的源代码都是AbstractByteBuf中的，这里不再赘述其中的方法，其中的域如下所示：

其中有一个ResourceLeakDetector，用了装饰器模式实现，用于检测内存泄露（没有成对调用ByteBuf的retain和relaease方法,导致ByteBuf没有被正常释放），这里先跳过。
SwappedBytebuf用于翻转ByteBuf，也用了装饰器模式实现。

1.3.2. AbstractReferenceCountedByteBuf ->AbstractByteBuf

接下来看AbstractByteBuf的一个子类，AbstractReferenceCountedByteBuf 。这是用来做ByteBuf引用计数的类。这个引用计数用来跟踪内存的分配和销毁，以便于内存回收和检测内存泄露。

这里用到了原子更新字段类，AtomicIntegerFieldUpdater用于原子更新AbstractReferenceCountedByteBuf 的refCnt字段。refCnt就是引用计数。
静态初始化：

static {
//首先通过netty运用Unsafe创建AtomicIntegerFieldUpdater
    AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> updater =
            PlatformDependent.newAtomicIntegerFieldUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
    //若创建不成功
    if (updater == null) {
        updater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
    }
    refCntUpdater = updater;
}

这里有个netty的PlatformDependent类，用于检测运行环境，以及是否用java的Unsafe这个类。这个类是用于执行低级别、不安全操作的方法集合。尽管这个类和所有的方法都是公开的（public），但是这个类的使用仍然受限，你无法在自己的java程序中直接使用该类，因为只有授信的代码才能获得该类的实例。该类是用来执行较低级别的操作的，比如获取某个属性在内存中的位置等等，还有一些底层的IO操作。Java 8可能会将Unsafe剔除，netty通过设置“io.netty.noUnsafe”这个系统属性为true或false来开启或关闭使用Unsafe。
PlatformDependent.java：

/**
     * Create a new optimized {@link AtomicIntegerFieldUpdater} or {@code null} if it
     * could not be created. Because of this the caller need to check for {@code null} and if {@code null} is returned
     * use {@link AtomicIntegerFieldUpdater#newUpdater(Class, String)} as fallback.
     */
    public static <T> AtomicIntegerFieldUpdater<T> newAtomicIntegerFieldUpdater(
            Class<?> tclass, String fieldName) {
        if (hasUnsafe()) {
            try {
                return PlatformDependent0.newAtomicIntegerFieldUpdater(tclass, fieldName);
            } catch (Throwable ignore) {
                // ignore
            }
        }
        return null;
    }

PlatformDependent只是一个对外的暴露的类，真正的实现是
PlatformDependent：
PlatformDependent.java

static <T> AtomicIntegerFieldUpdater<T> newAtomicIntegerFieldUpdater(
            Class<?> tclass, String fieldName) throws Exception { return new UnsafeAtomicIntegerFieldUpdater<T>(UNSAFE, tclass, fieldName); }

netty运用Unsafe自己实现的优化的UnsafeAtomicIntegerFieldUpdater：

final class UnsafeAtomicIntegerFieldUpdater<T> extends AtomicIntegerFieldUpdater<T> {
    private final long offset;
    private final Unsafe unsafe;

    UnsafeAtomicIntegerFieldUpdater(Unsafe unsafe, Class<?> tClass, String fieldName) throws NoSuchFieldException {
        Field field = tClass.getDeclaredField(fieldName);
        if (!Modifier.isVolatile(field.getModifiers())) {
            throw new IllegalArgumentException("Must be volatile");
        }
        this.unsafe = unsafe;
        offset = unsafe.objectFieldOffset(field);
    }

    @Override
    public boolean compareAndSet(T obj, int expect, int update) {
        return unsafe.compareAndSwapInt(obj, offset, expect, update);
    }

    @Override
    public boolean weakCompareAndSet(T obj, int expect, int update) {
        return unsafe.compareAndSwapInt(obj, offset, expect, update);
    }

    @Override
    public void set(T obj, int newValue) {
        unsafe.putIntVolatile(obj, offset, newValue);
    }

    @Override
    public void lazySet(T obj, int newValue) {
        unsafe.putOrderedInt(obj, offset, newValue);
    }

    @Override
    public int get(T obj) {
        return unsafe.getIntVolatile(obj, offset);
    }
}

这个原子更新类字段变量更新refCnt字段。
调用retian()，就是获取对于这个AbstractReferenceCountedByteBuf的引用。引用计数器加一。

public ByteBuf retain() {
    for (;;) {
        int refCnt = this.refCnt;
        //如果引用计数器为0，这是不符合逻辑的，refCnt 初始为1，如果调用了正常次数的获取释放，引用计数器最小为1
        if (refCnt == 0) {
            throw new IllegalReferenceCountException(0, 1);
        }
        if (refCnt == Integer.MAX_VALUE) {
            throw new IllegalReferenceCountException(Integer.MAX_VALUE, 1);
        }
        //CAS尝试更新refCnt为refCnt+1，如果更新成功则退出循环，否则继续更新
        if (refCntUpdater.compareAndSet(this, refCnt, refCnt + 1)) {
            break;
        }
    }
    return this;
}

public ByteBuf retain(int increment) {
        if (increment <= 0) {
            throw new IllegalArgumentException("increment: " + increment + " (expected: > 0)");
        }

        for (;;) {
            int refCnt = this.refCnt;
            if (refCnt == 0) {
                throw new IllegalReferenceCountException(0, increment);
            }
            if (refCnt > Integer.MAX_VALUE - increment) {
                throw new IllegalReferenceCountException(refCnt, increment);
            }
            if (refCntUpdater.compareAndSet(this, refCnt, refCnt + increment)) {
                break;
            }
        }
        return this;
    }

对应的，release()就是释放