Go 1.25で追加されたsync.WaitGroupの新メソッドGo()を使えば、goroutineの起動とカウント管理が簡潔に。従来のAdd()とDone()を使う記述と比較しながら、より安全かつ読みやすい並行処理の書き方を紹介します。

Go 1.25で追加されたWaitGroup.Go()の使い方｜並行処理がよりシンプルに

Go 1.25 が 2025年8月12日に正式リリースになりました。
<ul>
<li><a href="https://go.dev/blog/go1.25" rel="noopener noreferrer" target="_blank">Go 1.25 is released - The Go Programming Language</a></li>
<li><a href="https://tip.golang.org/doc/go1.25" rel="noopener noreferrer" target="_blank">Go 1.25 Release Notes - The Go Programming Language</a></li>
</ul>
その中で、sync パッケージにおいて、新たに <a href="https://tip.golang.org/doc/go1.25#syncpkgsync" rel="noopener noreferrer" target="_blank">WaitGroup.Go メソッド</a> が追加されました。これによって、ゴルーチンを作成してカウントするという一般的な実装がより簡単になったので使ってみたいと思います。
<h2 id="contents">contents</h2>
<ol>
<li><a href="#sync-%E3%83%91%E3%83%83%E3%82%B1%E3%83%BC%E3%82%B8%E3%81%8A%E3%82%88%E3%81%B3-waitgroup">sync パッケージおよび WaitGroup</a></li>
<li><a href="#%E5%BE%93%E6%9D%A5%E3%81%AE%E6%9B%B8%E3%81%8D%E6%96%B9go-124%E3%81%BE%E3%81%A7">従来の書き方（Go 1.24まで）</a></li>
<li><a href="#go-125%E3%81%A7%E8%BF%BD%E5%8A%A0%E3%81%95%E3%82%8C%E3%81%9Fgo%E3%83%A1%E3%82%BD%E3%83%83%E3%83%89">Go 1.25で追加されたGo()メソッド</a></li>
<li><a href="#go-124%E3%81%A8125%E3%81%AE%E3%82%B3%E3%83%BC%E3%83%89%E6%AF%94%E8%BC%83%E3%81%A8%E9%81%95%E3%81%84">Go 1.24と1.25のコード比較と違い</a></li>
</ol>
<h2 id="sync-パッケージおよび-waitgroup">sync パッケージおよび WaitGroup</h2>
Go では、並行処理を簡単に扱える仕組みとして <code>goroutine</code>（ゴルーチン）が用意されています。<code>go</code> キーワードを使うだけで非同期実行が可能になる一方で、「すべての処理が終わるまで待つ」ためには明示的な制御が必要です。そこで登場するのが、<code>sync</code> パッケージに含まれる <code>WaitGroup</code> です。
<a href="https://pkg.go.dev/sync@master" rel="noopener noreferrer" target="_blank">sync パッケージ</a>は、「同期処理（Synchronization）」を目的とした標準ライブラリであり、Mutex（排他制御のためのロック）や Once（一度だけの実行を保証）、Cond（条件変化を通知・待機）といったスレッド間の調整に用いられる複数のツールが揃っています。その中でも <code>WaitGroup</code> は特に汎用性が高く、複数の goroutine を安全に起動し、それらの完了を待つために用いられます。
具体的には、次のような場面で利用されます。
<ul>
<li>複数の API に同時アクセスして結果を待ちたいとき</li>
<li>バッチ処理やファイル読み込みなどを並行で実行し、すべてが終わるのを確認してから次に進みたいとき</li>
<li>goroutine の実行がメイン処理より遅延することがあり、プログラムの早期終了を防ぎたいとき
<ul>
<li>非同期に処理を書いたつもりが、実はその処理が完了する前にプログラムが終了していた……というのは、Go あるあるのひとつ。</li>
</ul>
</li>
</ul>
これまでは、以下のような典型的な構文が使われてきました。
<pre><code class="hljs language-go">var wg sync.WaitGroup

wg.Add(1)
go func() {
 defer wg.Done()
 // 非同期処理
}()

wg.Wait()
</code></pre>
このように、<code>Add()</code> → <code>go</code> → <code>Done()</code> → <code>Wait()</code> という 4 つの要素を組み合わせることで、並行処理を安全に完了まで管理することができます。一方で、<code>Add()</code> と <code>Done()</code> の書き忘れや位置の誤りによって意図しないブロックやデッドロックが発生することも少なくありません。
今回の Go 1.25 では、これらの一連の流れをより安全かつ簡潔に扱うための新機能として、<code>WaitGroup</code> に <code>Go()</code> メソッドが追加されました。次のセクションでは、この <code>Go()</code> メソッドを用いた新しい記述方法と、従来の書き方との比較を通じてその利便性を確認していきます。
<h2 id="従来の書き方go-124まで">従来の書き方（Go 1.24まで）</h2>
Go 1.24 までの <code>WaitGroup</code> を用いた実装では、非同期処理を開始するたびに <code>Add(1)</code> を呼び出し、処理が終了したタイミングで <code>Done()</code> を明示的に呼ぶ必要がありました。<code>Add()</code> と <code>Done()</code> の対を適切に記述しないと、goroutine の終了を待てなかったり（<code>Add()</code>記述漏れ）、逆に <code>Wait()</code> が永久にブロックされたり（<code>Done()</code>記述漏れ）と、意図しない挙動を引き起こす原因にもなります。
以下は、複数の URL に対して並列で HTTP リクエストを送信し、そのステータスコードを出力するサンプルコードです。goroutine を安全に制御するための最小構成として、<code>WaitGroup</code> を実装しています。
<pre><code class="hljs language-go">package main

import (
	"fmt"
	"net/http"
	"sync"
)

func main() {
	var wg sync.WaitGroup

	urls := []string{
		"https://www.google.com",
		"https://www.example.com",
		"https://www.github.com",
	}

	for _, url := range urls {
		u := url
		wg.Add(1)
		go func() {
			defer wg.Done()
			resp, err := http.Get(u)
			if err != nil {
				fmt.Printf("Failed to fetch %s: %v\n", u, err)
				return
			}
			defer resp.Body.Close()
			fmt.Printf("Fetched %s: %d\n", u, resp.StatusCode)
		}()
	}

	wg.Wait()
	fmt.Println("All fetches completed.")
}
</code></pre>
このように、<code>Add()</code> → <code>go</code> → <code>defer Done()</code> → <code>Wait()</code> という 4 ステップを毎回手動で記述する必要があり、簡潔さや記述ミスの観点ではやや冗長でした。次に紹介する Go 1.25 の <code>Go()</code> メソッドでは、こうした煩雑さが解消されています。
<h2 id="go-125で追加されたgoメソッド">Go 1.25で追加されたGo()メソッド</h2>
Go 1.25 では、<code>sync.WaitGroup</code> に新たに <code>Go()</code> メソッドが追加されました。これにより、従来必要だった <code>Add()</code>・<code>go</code>・<code>defer Done()</code> の3ステップを一括でカプセル化できるようになり、goroutine を使った並列処理の記述が格段に簡潔になりました。
新たに追加された <code>Go()</code> メソッドは、次のように使います。
<pre><code class="hljs language-go">wg.Go(func() {
// goroutine 内で行いたい処理
})
</code></pre>
この <code>Go()</code> メソッドは、内部で以下の処理を自動的に行ってくれます。
<ol>
<li><code>wg.Add(1)</code> を呼び出す</li>
<li>新しい goroutine を起動する</li>
<li>処理の終了時に <code>wg.Done()</code> を実行する</li>
</ol>
そのため、開発者は goroutine の中に記述した処理の内容だけに集中すればよくなり、<code>Add()</code> や <code>Done()</code> の書き忘れや順序ミスによるバグのリスクも軽減されます。
以下は、Go 1.25 の <code>Go()</code> メソッドを使って書き換えたコードです。処理内容は先ほどの Go 1.24 のコードと同じで、複数の URL に対して並列で HTTP リクエストを行っていますが、記述が非常にシンプルになっていることがわかります。
<pre><code class="hljs language-go">package main

import (
	"fmt"
	"net/http"
	"sync"
)

func main() {
	var wg sync.WaitGroup

	urls := []string{
		"https://www.google.com",
		"https://www.example.com",
		"https://www.github.com",
	}

	for _, url := range urls {
		u := url
		wg.Go(func() {
			resp, err := http.Get(u)
			if err != nil {
				fmt.Printf("Failed to fetch %s: %v\n", u, err)
				return
			}
			defer resp.Body.Close()
			fmt.Printf("Fetched %s: %d\n", u, resp.StatusCode)
		})
	}

	wg.Wait()
	fmt.Println("All fetches completed.")
}
</code></pre>
このように、goroutine の管理に必要な記述を一行にまとめられることで、可読性・保守性の両面で大きなメリットが得られます。次のセクションでは、Go 1.24 の従来構文と Go 1.25 の <code>Go()</code> メソッドを並べて比較し、その違いを整理していきます。
<h2 id="go-124と125のコード比較と違い">Go 1.24と1.25のコード比較と違い</h2>
ここでは、Go 1.24 までの従来の書き方と、Go 1.25 で追加された <code>WaitGroup.Go()</code> メソッドを使った書き方を比較し、実際にどのような違いがあるのかを整理してみます。
両者は処理内容こそ同じですが、コードの構造や記述量、バグの起きにくさといった観点で違いがあり、特に <code>Go()</code> メソッドによる記述の簡潔さが際立ちます。
以下は、比較ポイントを表にまとめたものです。



































<table><thead><tr><th>比較項目</th><th>Go 1.24</th><th>Go 1.25</th></tr></thead><tbody><tr><td>goroutine 実行方法</td><td><code>go func()</code> を使って自前で記述</td><td><code>wg.Go(func())</code> を使用</td></tr><tr><td>Add の記述</td><td><code>wg.Add(1)</code> を毎回呼び出す必要がある</td><td>自動で <code>Add(1)</code> を内部で呼び出す</td></tr><tr><td>Done の記述</td><td><code>defer wg.Done()</code> を忘れずに書く必要がある</td><td>自動で <code>Done()</code> を呼び出す</td></tr><tr><td>コードの安全性</td><td>Add/Done の書き漏れリスクあり</td><td>書き漏れの心配がない</td></tr><tr><td>記述の簡潔さ</td><td>3ステップでやや冗長</td><td>1ステップで完結</td></tr></tbody></table>
このように、Go 1.25 で追加された <code>Go()</code> メソッドを使うことで、goroutine を使った並行処理の基本パターンを1行に集約できるようになります。結果としてコードの見通しがよくなり、書き間違いによるバグのリスクも減らすことができます。
特に、複数の処理をループで並列実行するようなシーンでは記述が繰り返されやすいため、<code>Go()</code> の恩恵は大きく感じられそうです。
<h2 id="まとめ">まとめ</h2>
<code>sync.WaitGroup</code> は Go における並行処理の基本ツールとして広く使われてきましたが、従来の <code>Add()</code> と <code>Done()</code> をセットで扱う書き方は、シンプルである一方でミスを誘発しやすい側面もありました。
Go 1.25 で追加された <code>WaitGroup.Go()</code> メソッドは、このような典型パターンをより安全に、簡潔に記述できるようにしてくれる強力なアップデートです。処理単位をそのまま渡すだけで、goroutine の起動とカウント管理を一手に担ってくれるため、より直感的に並行処理を書くことができるようになりました。
Go 1.25 以降の環境であれば、積極的にこの <code>Go()</code> メソッドを使っていき、可読性を高めながら <code>Add()</code> や <code>Done()</code> の記述漏れといったヒューマンエラーも防いでいきたいですね。

Author