Go言語でゴルーチンを使う際のイディオム

Question

Go言語でゴルーチンを使う際の
イディオムというか以下のような処理がバッドノウハウかどうかをお聞きします。

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wait *sync.WaitGroup
var commonBool bool

func main() {
	wait = &sync.WaitGroup{}
	// Need to wait 1 delta count.
	wait.Add(1)
	go HeavyFunction(wait, &commonBool)
	wait.Wait()
	if commonBool == true {
		fmt.Println("Succeeded completing Goroutine. ")
	} else {
		fmt.Println("Failed completing Goroutine. ")
	}
}

// Quite function which has heavy process.
func HeavyFunction(w *sync.WaitGroup, b *bool) {

	// It is a process to wait 5 seconds.
	time.Sleep(time.Second * 5)
	fmt.Println("Completed waiting 5 seconds.")

	// Notice completing subroutine to main thread.
	var r *rand.Rand = rand.New(rand.NewSource(150))
	r.Seed(time.Now().Unix())
	var i int = r.Intn(9)
	if (i % 2) == 0 {
		// Success when getting zero.
		*b = true
		w.Done()
	} else {
		// Fail when getting not zero.
		*b = false
		w.Done()
	}
}

HeavyFunction という5秒ほどかかる処理があったとして、
同関数内で、仮に偶数の場合true、奇数の場合falseとします。
その場合、*sync.WaitGroup.Done();でゴルーチンを終了させ、main関数内でゴルーチンの成功あるは失敗を引数に渡したグローバル変数のポインタで判断したのですが、これはプロダクションとして利用してよいのものでしょうか?

また、これをWaitGroupではなくChannelを利用した場合は

// channelを利用した場合
package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wait *sync.WaitGroup
var commonBool bool

// チャンネルの場合
var ch chan int
var result chan bool

func main() {
	result = make(chan bool)
	go HeavyFunctionUsingChannel(result)

	//
	var res bool
	res = <-result
	if res == true {
		fmt.Println("Succeeded completing Goroutine. ")
	} else {
		fmt.Println("Failed completing Goroutine. ")
	}
}


func HeavyFunctionUsingChannel(result chan bool) {

	// Heavy Process.
	time.Sleep(time.Second * 5)
	fmt.Println("Comleted waiting 5 seconds using channel.")

	var r *rand.Rand = rand.New(rand.NewSource(2434))
	r.Seed(time.Now().Unix())
	if (r.Intn(9) % 2) == 0 {
		result <- true
	} else {
		result <- false
	}
}

上記のように var result chan bool というchannelで成功あるいは失敗とゴルーチンの終了そのものを兼用しています。

よりよいグッドノウハウがあればご教授をお願いいたします。

Answer 1

WaitGroup変数をグローバルにおくのは控えましょう。
WaitGroupは値型でもポインタ型でも使えるのですが、
引数で渡す際はポインタ型である必要があります。
が、引数で渡す状況は以下のように書くことで回避できます。
以下の形にすればmain関数のスコープにwait変数を閉じ込めることができ、
waitの使い所が一目瞭然です。

func main() {
    var wait sync.WaitGroup
    // Need to wait 1 delta count.
    wait.Add(1)
    go func() {
        defer wait.Done()
        HeavyFunction(&commonBool)
    } ()
    wait.Wait()
    if commonBool == true {
        fmt.Println("Succeeded completing Goroutine. ")
    } else {
        fmt.Println("Failed completing Goroutine. ")
    }
}

あと以下のように２度「w.Done()」を書くとWaitGroupを正しく操作しているかどうかを
ロジックを追う必要が出てきますので、HeavyFunctionの先頭で「defer w.Done()」と書く方が誤解がないでしょう。（そもそも前述のように書けば引数でWaitGroupを引き廻す必要もありません）

func HeavyFunction(w *sync.WaitGroup, b *bool) {
    if ... {
        ...
        w.Done()
    } else {
        ...
        w.Done()
    }
}

チャネルバージョンはチャネルをmain内で宣言すればグローバル宣言は不要なはず。

あと全体に言えることですが、単独の処理をgoroutineで起動して直後に完了を待ち続けているというのは
実際のところgoroutineを使うことのメリットはありません（goキーワードをなくすことが出来、そのほうが効率が良い）が、練習ということであれば問題はありません。

Comments

[nobonobo]

もしプロダクションとしてこのコードのPRが上がってきたらgoroutineを使うのをやめさせるでしょう。