Kotlin 写的环形 ByteBuffer，理论上是线程安全的。

本文介绍了一种环形缓冲区的实现方法，通过一个自定义的CircleByteBuffer类，支持数组的字节查看、写入和读取操作。该缓冲区在单线程写入和读取场景下表现良好，但多线程环境下需自行加锁。

class CircleByteBuffer(val size:Int) {
    private val datas=ByteArray(size)

    private var start=0
    private var end=0


    fun getLen():Int{
        if (start==end)
            return 0
        else if (start<end)
            return end-start
        else
            return start-end
    }

    fun getFree():Int{
        return size-getLen()
    }

    fun put(e:Byte){
        datas[end]=e
        val pos=end+1
        if (pos==size)
            end=0
        else if (pos==start)
            throw Exception("out buffer")
        else
            end=pos
    }
    fun get():Byte{
        if(getLen()==0)
            throw Exception("out buffer")
        val ret=datas[start]
        if (++start==size)
            start=0
        return ret
    }
    fun get(i:Int):Byte{
        if(i>=getLen())
            throw Exception("out buffer")
        var pos=start+i
        if (pos>=size)
            pos-=size
        return datas[pos]
    }

    fun puts(bts:ByteArray,ind:Int,len:Int){
        for (i in ind until len){
            put(bts[i])
        }
    }
    fun gets(len:Int):ByteArray{
        val bts=ByteArray(len)
        for (i in 0 until len){
            bts[i]=get()
        }
        return bts
    }
}

环形缓冲区，可查看数组的某个byte，写入，读取。