¿Se puede usar un mismo búfer []byte en varias…

Sí, es posible, pero se requiere garantizar la sincronización de acceso para evitar condiciones de carrera.

Los enfoques más comunes:

Mutex (sync.Mutex):

import "sync"

var buf []byte
var mu sync.Mutex

func processBuffer() {
    mu.Lock()
    defer mu.Unlock()
    // Acceso seguro a buf
    // Por ejemplo: buf = append(buf, data...)
}

func main() {
    // Inicialización de buf
    go processBuffer()
    go processBuffer()
    // ...
}

Canales (chan):

Se puede transferir la propiedad del búfer entre goroutines o usar un canal para coordinar el acceso.

import "bytes"

type BufferAccess struct {
    buf *bytes.Buffer // Puntero al búfer para uso compartido
    mu  sync.Mutex    // Mutex para sincronizar el acceso
}

func (ba *BufferAccess) Write(p []byte) (n int, err error) {
    ba.mu.Lock()
    defer ba.mu.Unlock()
    return ba.buf.Write(p)
}

func worker(ba *BufferAccess, data []byte) {
    ba.Write(data) // Escritura segura mediante método con mutex
}

func main() {
    sharedBuffer := &BufferAccess{buf: &bytes.Buffer{}}
    // Lanzar goroutines, pasando sharedBuffer
    go worker(sharedBuffer, []byte("hello"))
    go worker(sharedBuffer, []byte("world"))
    // ...
}

Pool de buffers (sync.Pool):

Menor necesidad de sincronización en el acceso al buffer en sí, si cada goroutine obtiene un buffer del pool, lo usa y luego lo devuelve.

import (
    "bytes"
    "sync"
)

var bufferPool = sync.Pool{
    New: func() interface{} {
        // Tamaño predeterminado del buffer
        return bytes.NewBuffer(make([]byte, 0, 1024))
    },
}

func processData(data []byte) {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buf) // Es importante devolver el buffer al pool

    buf.Reset() // Limpiar el buffer antes de usar
    buf.Write(data)
    // Procesar datos en el buffer
    // ...
}

func main() {
    go processData([]byte("message1"))
    go processData([]byte("message2"))
    // ...
}

Importante: El uso de un buffer sin sincronización en un entorno concurrente conducirá a condiciones de carrera, lo que puede causar comportamientos impredecibles y errores difíciles de detectar.

¿Se puede usar un mismo búfer []byte en varias goroutines?