Как синхронизировать горутины?

Question

[Kairr]

Я только начинаю разбираться с Go.
Подскажите плиз в какую сторону можно подумать?
Мне нужно чтобы цифры выводились по порядку. Этот код вроде как работает, но иногда выводит цифры вразброс

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(2)

	num := make(chan string)


	go func() {
		for _, value := range []int{1, 3, 5} {
			num <- "ok"
			fmt.Println(value)
		}
		wg.Done()
	}()

	go func() {
		for _, value := range []int{2, 4, 6} {
			<- num
			fmt.Println(value)
		}
		wg.Done()
	}()

	wg.Wait()
}

Answer 1

[Евгений Мамонов]

Горутины синхронизировать/обмениваться данными можно при помощи каналов.
У вас не очень удачный пример для обучения.
Обычно есть горутина или несколько, которые получают данные и пишут их в канал и есть горутина или несколько, которые будут читать из канала.
Читающие горутины будут получать данные из канала в той последовательности, в которой они туда попали.
Ближе к реальности пример будет выглядеть вот так.
Одна горутина пишет данные в канал, а две горутины по очереди извлекают данные.

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    num := make(chan int, 1000) // 1000 - размер буффера канала

    wg.Add(1)
    go func() {
        for i := 0; i < 1000; i++ {
            num <- i
            fmt.Printf("write to channel: %d\n", i)
            // задержка нужна только на время теста
            time.Sleep(100 * time.Microsecond)
        }
        close(num)
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 1 got: %d\n", val)
        }
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 2 got: %d\n", val)
        }
        wg.Done()
    }()

    wg.Wait()
}

Comments

[Евгений Мамонов]

стало понятнее?
если что-то не понятно - пишите, буду рад помочь

[Kairr]

Евгений Мамонов, то что вы написали я понял, спасибо. Но не понял как так получается, что принимающие горутины получают данные из канала по очереди? Это такое совпадение, что именно с такой задержкой 100 * time.Second первая печатает нечетные, а вторая четные числа?
Я попробовал без задержки и числа пошли печататься рандомно.

[Евгений Мамонов]

Данные будут извлекаться из канала в той последовательности, в которой они туда были записаны.
А вот распределение по горутинам может быть уже разным.
Например...
Пишущая горутина пишет в канал URL'ы, которые нужно скачать.
У вас 2 горутины, которые эти URL'ы читают из канала.
1й URL получила первая горутина и скачивался он 1 сек
2й URL получила вторая горутина и скачивался он 1 сек
3й URL получила первая горутина и скачивался он 10 сек
4й URL получила вторая горутина и скачивался он 2 сек
5й URL получила снова вторая горутина, т.к. первая еще качает 3й URL и скачивался он 1 сек
6й URL получила снова вторая горутина, т.к. первая еще качает 3й URL и скачивался он 1 сек.
7й URL получила снова вторая горутина, т.к. первая еще качает 3й URL и скачивался он 7 сек.
8й URL получила уже первая горутина, т.к. она уже свободна, а вторая еще качает 7й URL.
Т.е. порядок работы горутин будет разный, но все URL'ы были обработаны по очереди с 1го по 8й.
Т.е. их нет нужды синхронизировать как то, т.к. они данные заберут из канала по порядку.
Теперь стало понятнее?
Если нет - пишите, попробую еще привести примеры какие то

[Евгений Мамонов]

В примере, который в ответе, если убрать задержку - тогда первая читающая горутина успеет вычитать почти все или все данные еще до того, как вторая читающая горутина запустится.

[Евгений Мамонов]

Можем немного изменить пример, сначала запустим читающие горутины, а потом запишем данные в канал.

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    num := make(chan int, 1000) // 1000 - размер буфера канала

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 1 got: %d\n", val)
            time.Sleep(100 * time.Microsecond)
        }
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 2 got: %d\n", val)
            time.Sleep(500 * time.Microsecond)
        }
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for i := 0; i < 1000; i++ {
            num <- i
            fmt.Printf("write to channel: %d\n", i)
        }
        close(num)
        wg.Done()
    }()

    wg.Wait()
}

Обратите внимание на то, что в читающие горутины добавлена разная задержка, вторая горутина работает в 5 раз дольше (имитируем обработку данных).

Вывод будет примерно таким

goroutine 1 got: 640
goroutine 1 got: 641
goroutine 1 got: 642
goroutine 2 got: 643
goroutine 1 got: 644
goroutine 1 got: 645
goroutine 1 got: 646
goroutine 1 got: 647
goroutine 2 got: 648
goroutine 1 got: 649
goroutine 1 got: 650

Первая горутина обрабатывает больше данных, но все данные идут последовательно от 640 до 650.

[Kairr]

Евгений Мамонов, Большое спасибо, вы все очень понятно объяснили)

[Евгений Мамонов]

рад помочь :)

Answer 2

[Kenit]

Каналы в го если упрощённо представить то это очереди. Горутины потоки которые воюют за ресурсы и в целом их порядок выполнения можно считать случайно-параллельным в данном примере. Для выведения чисел по порядку в данном случае я бы добавил синхронизирующий примитив на основе мьютекса, который будет следить за очерёдностью использования канала горутинами.