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

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，写入，读取。

理论上是线程安全的（使用多线程没碰到问题，但是不是很确定）

    只要一个线程只写，一个线程只读，是没问题的，如果多个线程同时写或者读需要自己加锁。