Introducción Quiero analizar el tipo de , los casos de uso y cuándo usarlo. sync.Cond ¿Qué es ? sync.Cond En el lenguaje de programación Go, es un tipo definido en el paquete que representa una variable de condición. Las variables de condición son primitivas de sincronización que se utilizan para coordinar gorutinas al permitirles esperar a que una condición específica se cumpla antes de continuar. sync.Cond sync El tipo proporciona una manera de crear y administrar variables de condición. Tiene tres métodos principales: sync.Cond : este método hace que la rutina que llama espere hasta que otra rutina indique la variable de condición. Cuando la rutina llama a , libera el bloqueo asociado y suspende la ejecución hasta que otra rutina llama a o en la misma variable . Wait() Wait() Signal() Broadcast() sync.Cond : este método activa una rutina que espera la variable de condición. Si hay varias gorutinas esperando, solo se despierta una de ellas. La elección de qué rutina se activa es arbitraria y no está garantizada. Signal() : este método activa todas las gorutinas que esperan la variable de condición. Cuando se llama , todas las rutinas en espera se activan y pueden continuar. Broadcast() Broadcast() Tenga en cuenta que requiere un asociado para sincronizar el acceso a la variable de condición. sync.Cond sync.Mutex Al utilizar , puede coordinar la ejecución de gorutinas en función de condiciones específicas, lo que permite una programación concurrente más controlada y sincronizada en Go. sync.Cond Casos de uso comunes se usa comúnmente en escenarios donde las gorutinas necesitan coordinarse y comunicarse entre sí en función de condiciones específicas. Consideremos casos de uso comunes para . sync.Cond sync.Cond Sincronización de gorutinas se puede utilizar para sincronizar la ejecución de múltiples gorutinas. Por ejemplo, es posible que tenga varias rutinas que deban esperar a que se cumpla una condición específica antes de continuar. Las gorutinas en espera pueden llamar a y la gorutina de señalización puede llamar a o para activar las gorutinas en espera cuando se cumple la condición. sync.Cond cond.Wait() cond.Signal() cond.Broadcast() package main import ( "fmt" "sync" "time" ) func main() { var wg sync.WaitGroup var mu sync.Mutex cond := sync.NewCond(&mu) wg.Add(2) go func() { fmt.Println("Goroutine 1 is started") defer wg.Done() cond.L.Lock() defer cond.L.Unlock() fmt.Println("Goroutine 1 is waiting for condition") cond.Wait() fmt.Println("Goroutine 1 met the condition") fmt.Println("Goroutine 1 is done") }() go func() { fmt.Println("Goroutine 2 is started") defer wg.Done() time.Sleep(5 * time.Second) // Simulating some work cond.L.Lock() defer cond.L.Unlock() fmt.Println("Goroutine 2 is signaling condition") cond.Signal() fmt.Println("Goroutine 2 completed signaling") fmt.Println("Goroutine 2 is done") }() wg.Wait() } En este ejemplo, tenemos dos gorutinas. La primera rutina espera una condición usando , mientras que la segunda rutina señala la condición usando . cond.Wait() cond.Signal() Cuando se ejecuta el programa, la primera rutina adquiere el bloqueo y luego llama a . Como la condición aún no se cumple, la primera rutina libera el bloqueo y suspende su ejecución. cond.Wait() Mientras tanto, la segunda rutina duerme durante cinco segundos, simulando algo de trabajo. Adquiere el bloqueo y luego llama a . Despierta la rutina de espera, que luego adquiere el bloqueo y se ejecuta. cond.Signal() El uso de garantiza que la primera gorutina espere hasta que la segunda gorutina indique la condición, lo que permite la sincronización y coordinación entre las dos gorutinas. sync.Cond Problema productor-consumidor puede resultar útil para resolver el , un problema de sincronización clásico que involucra dos tipos de procesos, productores y consumidores, que comparten un búfer o cola común de tamaño fijo. Las rutinas de productor pueden usar o para notificar a las rutinas de consumidor cuando hay nuevos datos disponibles para el consumo. sync.Cond problema productor-consumidor cond.Signal() cond.Broadcast() package main import ( "fmt" "sync" "time" ) const MaxMessageChannelSize = 5 func main() { var wg sync.WaitGroup var mu sync.Mutex cond := sync.NewCond(&mu) messageChannel := NewMessageChannel(MaxMessageChannelSize) producer := NewProducer(cond, messageChannel) consumer := NewConsumer(cond, messageChannel) wg.Add(2) go func() { defer wg.Done() for i := range 10 { producer.Produce(fmt.Sprintf("Message %d", i)) } }() go func() { defer wg.Done() for range 10 { consumer.Consume() } }() wg.Wait() } type MessageChannel struct { maxBufferSize int buffer []string } func NewMessageChannel(size int) *MessageChannel { return &MessageChannel{ maxBufferSize: size, buffer: make([]string, 0, size), } } func (mc *MessageChannel) IsEmpty() bool { return len(mc.buffer) == 0 } func (mc *MessageChannel) IsFull() bool { return len(mc.buffer) == mc.maxBufferSize } func (mc *MessageChannel) Add(message string) { mc.buffer = append(mc.buffer, message) } func (mc *MessageChannel) Get() string { message := mc.buffer[0] mc.buffer = mc.buffer[1:] return message } type Producer struct { cond *sync.Cond messageChannel *MessageChannel } func NewProducer(cond *sync.Cond, messageChannel *MessageChannel) *Producer { return &Producer{ cond: cond, messageChannel: messageChannel, } } func (p *Producer) Produce(message string) { time.Sleep(500 * time.Millisecond) // Simulating some work p.cond.L.Lock() defer p.cond.L.Unlock() for p.messageChannel.IsFull() { fmt.Println("Producer is waiting because the message channel is full") p.cond.Wait() } p.messageChannel.Add(message) fmt.Println("Producer produced the message:", message) p.cond.Signal() } type Consumer struct { id int cond *sync.Cond messageChannel *MessageChannel } func NewConsumer(cond *sync.Cond, messageChannel *MessageChannel) *Consumer { return &Consumer{ cond: cond, messageChannel: messageChannel, } } func (c *Consumer) Consume() { time.Sleep(1 * time.Second) // Simulating some work c.cond.L.Lock() defer c.cond.L.Unlock() for c.messageChannel.IsEmpty() { fmt.Println("Consumer is waiting because the message channel is empty") c.cond.Wait() } message := c.messageChannel.Get() fmt.Println("Consumer consumed the message:", message) c.cond.Signal() } En este ejemplo, tenemos una rutina de productor que produce mensajes y los agrega al canal de mensajes y una rutina de consumidor que consume mensajes. El canal de mensajes tiene un tamaño máximo definido por . MaxMessageChannelSize La rutina del productor agrega mensajes al canal de mensajes y usa para notificar a la rutina del consumidor cuando hay nuevos datos disponibles. Si el canal de mensajes está lleno, la rutina del productor espera usando hasta que el consumidor consuma algunos datos y libere espacio en el canal de mensajes. cond.Signal() cond.Wait() De manera similar, la rutina del consumidor consume mensajes del canal de mensajes y usa para notificar a la rutina del productor cuando hay espacio disponible en el canal de mensajes. Si está vacío, la rutina del consumidor espera usando hasta que el productor produzca algunos datos y los agregue al canal de mensajes. cond.Signal() cond.Wait() Aquí, permite la coordinación y sincronización entre las rutinas de productor y consumidor. Garantiza que el consumidor espere cuando el canal de mensajes esté vacío y el productor espere cuando esté lleno, resolviendo así el problema productor-consumidor. sync.Cond Sincronización de recursos Supongamos que varias gorutinas necesitan acceso exclusivo a un recurso compartido. se puede utilizar para coordinar el acceso. Por ejemplo, es posible que un grupo de rutinas de trabajo deba esperar hasta que una cierta cantidad de recursos esté disponible antes de poder comenzar a procesar. Las gorutinas pueden esperar en la variable de condición usando y notificar sobre la liberación de recursos usando o . sync.Cond cond.Wait() cond.Signal() cond.Broadcast() package main import ( "fmt" "sync" "time" ) const MaxResources = 3 func main() { var wg sync.WaitGroup var mu sync.Mutex cond := sync.NewCond(&mu) resourceProvider := NewResourceProvider(cond, MaxResources) wg.Add(10) for i := range 10 { go func(workerID int) { defer wg.Done() worker := NewWorker(workerID, cond, resourceProvider) worker.Run() }(i) } wg.Wait() } type ResourceProvider struct { maxResources int availableResources int cond *sync.Cond } func NewResourceProvider(cond *sync.Cond, maxResources int) *ResourceProvider { return &ResourceProvider{ cond: cond, availableResources: maxResources, } } func (rp *ResourceProvider) AvailableResources() int { return rp.availableResources } func (rp *ResourceProvider) AcquireResoirce() { rp.availableResources-- } func (rp *ResourceProvider) ReleaseResource() { rp.availableResources++ } type Worker struct { id int cond *sync.Cond rp *ResourceProvider } func NewWorker(workerID int, cond *sync.Cond, rp *ResourceProvider) *Worker { return &Worker{ id: workerID, cond: cond, rp: rp, } } func (w *Worker) Run() { w.cond.L.Lock() for w.rp.AvailableResources() == 0 { fmt.Printf("Worker %d is waiting for resources\n", w.id) w.cond.Wait() } w.rp.AcquireResoirce() fmt.Printf("Worker %d acquired resource. Remaining resources: %d\n", w.id, w.rp.AvailableResources()) w.cond.L.Unlock() time.Sleep(1 * time.Second) // Simulating work w.cond.L.Lock() defer w.cond.L.Unlock() w.rp.ReleaseResource() fmt.Printf("Worker %d released resource. Remaining resources: %d\n", w.id, w.rp.AvailableResources()) w.cond.Signal() } En este ejemplo, tenemos múltiples rutinas de trabajadores que necesitan acceso exclusivo a recursos limitados. Las rutinas de los trabajadores adquieren y liberan recursos utilizando para coordinarse con otros trabajadores. Si no hay recursos disponibles, las rutinas de trabajo esperan hasta que la otra rutina libere el recurso. cond.Signal() using cond.Wait() En este ejemplo, permite la sincronización y coordinación entre las rutinas de trabajo, asegurando que las rutinas de trabajo esperen cuando no hay recursos disponibles, sincronizando así de manera efectiva el acceso a los recursos. sync.Cond Notificación de eventos se puede utilizar para notificar gorutinas sobre eventos específicos o cambios en el sistema. Por ejemplo, puedes tener gorutinas esperando un evento específico. Cuando ocurre el evento, la rutina de señalización puede usar o para activar las rutinas en espera y permitirles manejar el evento. sync.Cond cond.Signal() cond.Broadcast() package main import ( "fmt" "sync" "time" ) const maxWorkersCount = 10 func main() { var counter int32 var wg sync.WaitGroup var mu sync.Mutex cond := sync.NewCond(&mu) wg.Add(maxWorkersCount) for i := range maxWorkersCount { go func(workerID int) { defer wg.Done() fmt.Printf("Worker %d performing work\n", workerID) time.Sleep(1 * time.Second) // Simulate work cond.L.Lock() defer cond.L.Unlock() counter++ if counter == maxWorkersCount { fmt.Println("All workers have reached the barrier") cond.Broadcast() } else { fmt.Printf("Worker %d is waiting at the barrier\n", workerID) cond.Wait() } fmt.Printf("Worker %d passed the barrier\n", workerID) }(i) } wg.Wait() } Aquí, tenemos múltiples rutinas de trabajadores que realizan trabajo y se sincronizan en un punto de barrera. Las rutinas de trabajadores incrementan un contador y luego esperan en la barrera o señalan la barrera usando y según el recuento de trabajadores que llegan a la barrera. cond.Wait() cond.Broadcast() Cada rutina de trabajo realiza algún trabajo y luego adquiere el bloqueo para incrementar la variable del contador. Si el trabajador actual es el último en alcanzar la barrera, transmite la condición de la barrera usando para despertar a todos los trabajadores que esperan. De lo contrario, espera en la barrera usando para ser notificado por el último trabajador. cond.Broadcast() cond.Wait() La sincronización de la barrera garantiza que todas las rutinas de los trabajadores alcancen la barrera antes de que cualquiera de ellas la supere. Puede resultar útil en escenarios que requieren sincronizar la ejecución de múltiples rutinas en un punto específico de su flujo de trabajo. Tenga en cuenta que la barrera se implementa utilizando un contador simple en este ejemplo. Sin embargo, en escenarios más complejos, es posible que deba considerar mecanismos o condiciones de sincronización adicionales para garantizar una sincronización correcta y evitar condiciones de carrera. Conclusión En conclusión, es un tipo útil en el lenguaje de programación Go que permite la sincronización y coordinación entre gorutinas en función de condiciones específicas. Proporciona una forma de crear y gestionar variables de condición. Tiene métodos para esperar, señalizar y condiciones de transmisión. Al utilizar `sync.Cond`, puede escribir programas simultáneos más controlados y sincronizados en Go. sync.Cond Es importante tener en cuenta que es solo una de las primitivas de sincronización proporcionadas por la biblioteca estándar de Go y su uso depende de los requisitos específicos de su programa concurrente. En algunos casos, otras primitivas de sincronización como canales o pueden ser más adecuadas. sync.Cond sync.WaitGroup
