Параллелизм — это мощная функция Go, которая позволяет выполнять несколько задач одновременно, повышая производительность и эффективность ваших приложений. В этой статье мы рассмотрим комбинацию структуры данных WaitGroup и очереди в Go для достижения эффективного параллелизма. Мы углубимся в различные методы и предоставим примеры кода, демонстрирующие их использование.

1. Использование WaitGroup:
   WaitGroup — это примитив синхронизации в Go, который позволяет вам дождаться завершения выполнения набора горутин, прежде чем продолжить. Он обеспечивает простой способ дождаться, пока все горутины завершат свои задачи.

Вот пример, демонстрирующий базовое использование WaitGroup:

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d is executing...\n", id)
        }(i)
    }
    wg.Wait()
    fmt.Println("All goroutines have finished executing.")
}

2. Реализация очереди.
   Очередь — это полезная структура данных для управления параллельными задачами. В Go вы можете реализовать простую очередь, используя каналы. Вот пример:

package main
import "fmt"
type Queue chan interface{}
func (q Queue) Enqueue(item interface{}) {
    q <- item
}
func (q Queue) Dequeue() interface{} {
    return <-q
}
func main() {
    queue := make(Queue)
    go func() {
        for i := 1; i <= 5; i++ {
            queue.Enqueue(i)
        }
    }()
    for i := 1; i <= 5; i++ {
        item := queue.Dequeue()
        fmt.Printf("Dequeued item: %v\n", item)
    }
}

3. Объединение WaitGroup и очереди.
   Теперь давайте объединим возможности WaitGroup и очереди для достижения эффективного параллелизма. Мы будем использовать WaitGroup, чтобы дождаться завершения всех горутин, и очередь, чтобы распределить задачи между горутинами.

package main
import (
    "fmt"
    "sync"
)
type Queue chan interface{}
func (q Queue) Enqueue(item interface{}) {
    q <- item
}
func (q Queue) Dequeue() interface{} {
    return <-q
}
func main() {
    var wg sync.WaitGroup
    queue := make(Queue)
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for task := range queue {
                fmt.Printf("Goroutine %d is processing task: %v\n", id, task)
            }
        }(i)
    }
    for i := 1; i <= 10; i++ {
        queue.Enqueue(i)
    }
    close(queue)
    wg.Wait()
    fmt.Println("All tasks have been processed.")
}

Объединив структуру данных WaitGroup и очереди в Go, вы можете эффективно управлять параллельными задачами и обеспечивать синхронизацию между горутинами. Такой подход позволяет вам использовать всю мощь модели параллелизма Go, повышая производительность и масштабируемость ваших приложений.

В этой статье мы рассмотрели различные методы, в том числе использование WaitGroup, реализацию очереди и их объединение для достижения эффективного параллелизма. Поняв и применив эти методы, вы будете хорошо подготовлены к эффективному решению параллельных задач в Go.