fixed memory leak

transaction/transaction.go

@@ -236,7 +236,7 @@ type Header map[string]string
 
 // timer相关基础常量、方法等定义
 const (
-	T1      = 100 * time.Millisecond
+	T1      = 250 * time.Millisecond
 	T2      = 4 * time.Second
 	T4      = 5 * time.Second
 	TimeA   = T1

utils/buffer.go

@@ -1,39 +1,100 @@
 package utils
 
 import (
-	"bytes"
 	"encoding/binary"
 	"errors"
+	"io"
 )
 
-var ErrEOF = errors.New("eof")
-
 type IOBuffer struct {
-	bytes.Buffer
+	buf []byte // contents are the bytes buf[off : len(buf)]
+	off int    // read at &buf[off], write at &buf[len(buf)]
 }
 
-func (r *IOBuffer) Uint16() (uint16, error) {
-	if r.Len() > 1 {
-		return binary.BigEndian.Uint16(r.Next(2)), nil
+func (b *IOBuffer) Next(n int) []byte {
+	m := b.Len()
+	if n > m {
+		n = m
 	}
-	return 0, ErrEOF
+	data := b.buf[b.off : b.off+n]
+	b.off += n
+	return data
+}
+func (b *IOBuffer) Uint16() (uint16, error) {
+	if b.Len() > 1 {
+
+		return binary.BigEndian.Uint16(b.Next(2)), nil
+	}
+	return 0, io.EOF
 }
 
-func (r *IOBuffer) Skip(n int) (err error) {
-	_, err = r.ReadN(n)
+func (b *IOBuffer) Skip(n int) (err error) {
+	_, err = b.ReadN(n)
 	return
 }
 
-func (r *IOBuffer) Uint32() (uint32, error) {
-	if r.Len() > 3 {
-		return binary.BigEndian.Uint32(r.Next(4)), nil
+func (b *IOBuffer) Uint32() (uint32, error) {
+	if b.Len() > 3 {
+		return binary.BigEndian.Uint32(b.Next(4)), nil
 	}
-	return 0, ErrEOF
+	return 0, io.EOF
 }
 
-func (r *IOBuffer) ReadN(length int) ([]byte, error) {
-	if r.Len() >= length {
-		return r.Next(length), nil
+func (b *IOBuffer) ReadN(length int) ([]byte, error) {
+	if b.Len() >= length {
+		return b.Next(length), nil
 	}
-	return nil, ErrEOF
+	return nil, io.EOF
+}
+
+// empty reports whether the unread portion of the buffer is empty.
+func (b *IOBuffer) empty() bool { return b.Len() <= b.off }
+
+func (b *IOBuffer) ReadByte() (byte, error) {
+	if b.empty() {
+		// Buffer is empty, reset to recover space.
+		b.Reset()
+		return 0, io.EOF
+	}
+	c := b.buf[b.off]
+	b.off++
+	return c, nil
+}
+func (b *IOBuffer) Reset() {
+	b.buf = b.buf[:0]
+	b.off = 0
+}
+
+func (b *IOBuffer) Len() int { return len(b.buf) - b.off }
+
+// tryGrowByReslice is a inlineable version of grow for the fast-case where the
+// internal buffer only needs to be resliced.
+// It returns the index where bytes should be written and whether it succeeded.
+func (b *IOBuffer) tryGrowByReslice(n int) (int, bool) {
+	if l := len(b.buf); n <= cap(b.buf)-l {
+		b.buf = b.buf[:l+n]
+		return l, true
+	}
+	return 0, false
+}
+
+var ErrTooLarge = errors.New("bytes.Buffer: too large")
+
+func (b *IOBuffer) Write(p []byte) (n int, err error) {
+	defer func() {
+		if recover() != nil {
+			panic(ErrTooLarge)
+		}
+	}()
+	l := len(p)
+	oldLen := len(b.buf)
+	m, ok := b.tryGrowByReslice(l)
+	if !ok {
+		buf := make([]byte, oldLen+l)
+		copy(buf, b.buf[b.off:])
+		m = oldLen - b.off
+		b.off = 0
+		b.buf = buf
+	}
+	return copy(b.buf[m:], p), nil
 }