问优化网络代码

EN

// Read client data from channel
func (c *Client) listen() {

    reader := bufio.NewReader(c.conn)

    clientBuffer := new(bytes.Buffer)

    for {
        c.conn.SetDeadline(time.Now().Add(c.timeoutDuration))

        byte, err := reader.ReadByte()

        if err != nil {
            c.conn.Close()
            c.server.onClientConnectionClosed(c, err)
            return
        }

        wrErr := clientBuffer.WriteByte(byte)
        if wrErr != nil {
            log.Println("Write Error:", wrErr)
        }

        packet := popPacketFromBuffer(clientBuffer)
        if packet != nil {
            c.receiveMutex.Lock()
            packetSize := uint64(len(packet))
            c.bytesReceived += packetSize
            c.receiveMutex.Unlock()

            packetBuffer := bytes.NewBuffer(packet)

            b, err := uncompress(packetBuffer.Bytes())
            if err != nil {
                log.Println("Unzip Error:", err)
            } else {
                c.server.onNewMessage(c, b)
            }
        }

    }
}

func popPacketFromBuffer(buffer *bytes.Buffer) []byte {

    bufferLength := buffer.Len()

    if bufferLength >= 125000 { // 1MB in bytes is roughly this
        log.Println("Buffer is too large ", bufferLength)
        buffer.Reset()
        return nil
    }

    tempBuffer := buffer.Bytes()
    length := len(tempBuffer)

    // Return on zero length buffer submission
    if length == 0 {
        return nil
    }

    endOfPacket := -1

    // Determine the endOfPacket position by looking for an instance of our delimiter
    for i := 0; i < length-1; i++ {
        if tempBuffer[i] == endDelimiter {
            if tempBuffer[i+1] == endDelimiter {
                i++
            } else {
                // We found a single delimiter, so consider this the end of a packet
                endOfPacket = i - 2
                break
            }
        }
    }

    if endOfPacket != -1 {
        // Grab the contents of the provided packet
        extractedPacket := buffer.Bytes()

        // Extract the last byte as we were super greedy with the read operation to check for stuffing
        carryByte := extractedPacket[len(extractedPacket)-1]

        // Clear the main buffer now we have extracted a packet from it
        buffer.Reset()

        // Add the carryByte over to our new buffer
        buffer.WriteByte(carryByte)

        // Ensure packet begins with a valid startDelimiter
        if extractedPacket[0] != startDelimiter {
            log.Println("Popped a packet without a valid start delimiter")
            return nil
        }

        // Remove the start and end caps
        slice := extractedPacket[1 : len(extractedPacket)-2]

        return deStuffPacket(slice)
    }

    return nil
}