Goの非同期処理について解説：goroutineとchannelで実現するシンプルな並行処理

package main
import (
	"fmt"
	"sync"
)
func main() {
	// WaitGroupでgoroutineの終了を待つサンプル
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		// 非同期処理(goroutine)の実行中の処理
		fmt.Println("goroutineが実行中")
		wg.Done() // goroutineの処理完了を通知
	}()
	wg.Wait() // 全goroutineの終了を待つ
	fmt.Println("全てのgoroutineが終了")
}

goroutineが実行中
全てのgoroutineが終了

package main
import (
	"fmt"
	"sync"
)
func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	// goroutineとして関数を非同期に実行
	go func() {
		// 非同期処理中のメッセージ
		fmt.Println("非同期処理中のメッセージ")
		wg.Done() // 終了を通知
	}()
	wg.Wait() // goroutine終了まで待つ
	fmt.Println("メイン処理終了")
}

非同期処理中のメッセージ
メイン処理終了

package main
import (
	"fmt"
	"sync"
)
func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	// 外部パラメータmsgをクロージャ内で利用
	msg := "クロージャで渡したメッセージ"
	go func(message string) {
		fmt.Println(message)
		wg.Done()
	}(msg) // 引数として渡す
	wg.Wait()
	fmt.Println("非同期処理完了")
}

クロージャで渡したメッセージ
非同期処理完了

package main
import (
	"fmt"
	"sync"
)
func main() {
	var wg sync.WaitGroup
	taskCount := 3
	wg.Add(taskCount)
	// 複数のgoroutineを作成し、終了を待つ例
	for i := 1; i <= taskCount; i++ {
		go func(taskID int) {
			fmt.Printf("タスク%d実行中\n", taskID)
			wg.Done() // 個々のタスクの終了を通知
		}(i)
	}
	wg.Wait() // 全てのタスクが終了するまで待機
	fmt.Println("全てのタスクが完了")
}

タスク1実行中
タスク2実行中
タスク3実行中
全てのタスクが完了

package main
import "fmt"
func main() {
	// 型stringのチャネルを作成
	messageChan := make(chan string)
	// goroutine内でチャネルにメッセージを送信
	go func() {
		messageChan <- "チャネルを利用したデータ送信"
	}()
	// チャネルからメッセージを受信
	msg := <-messageChan
	fmt.Println(msg)
}

チャネルを利用したデータ送信

package main
import "fmt"
func main() {
	// バッファサイズ2でチャネルを作成
	bufferChan := make(chan string, 2)
	// チャネルに複数のデータを送信(バッファに余裕があるため即時送信可能)
	bufferChan <- "メッセージ1"
	bufferChan <- "メッセージ2"
	// チャネルからデータを1つずつ受信
	fmt.Println(<-bufferChan)
	fmt.Println(<-bufferChan)
}

メッセージ1
メッセージ2

package main
import (
	"fmt"
	"time"
)
func main() {
	chanA := make(chan string)
	chanB := make(chan string)
	// goroutineで遅延を入れた送信
	go func() {
		time.Sleep(100 * time.Millisecond)
		chanA <- "チャンネルAからのメッセージ"
	}()
	go func() {
		time.Sleep(50 * time.Millisecond)
		chanB <- "チャンネルBからのメッセージ"
	}()
	// select文でどちらか先に受信した方の処理を行う
	select {
	case msg := <-chanA:
		fmt.Println(msg)
	case msg := <-chanB:
		fmt.Println(msg)
	}
}

チャンネルBからのメッセージ

package main
import (
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
)
func fetchURL(url string, ch chan<- string, wg *sync.WaitGroup) {
	defer wg.Done()
	// HTTPリクエストを実行
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprintf("URL %s でエラー: %v", url, err)
		return
	}
	defer resp.Body.Close()
	// レスポンスの内容を読み込み
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		ch <- fmt.Sprintf("URL %s の読み込みエラー: %v", url, err)
		return
	}
	// チャンネルに結果を送信
	ch <- fmt.Sprintf("URL: %s, 長さ: %d", url, len(body))
}
func main() {
	urls := []string{
		"https://example.com",
		"https://golang.org",
	}
	resultChan := make(chan string, len(urls))
	var wg sync.WaitGroup
	// 各URLに対してgoroutineを作成し、非同期にHTTPリクエストを実行
	for _, url := range urls {
		wg.Add(1)
		go fetchURL(url, resultChan, &wg)
	}
	wg.Wait()
	close(resultChan)
	// 受信した結果を出力
	for result := range resultChan {
		fmt.Println(result)
	}
}

URL: https://example.com, 長さ: 1256
URL: https://golang.org, 長さ: 5430

package main
import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"
)
func fetchWithTimeout(url string) {
	// 2秒後にタイムアウトするコンテキストを作成
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		fmt.Println("リクエスト作成エラー:", err)
		return
	}
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Println("HTTPリクエストエラー:", err)
		return
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("レスポンス読み込みエラー:", err)
		return
	}
	fmt.Printf("URL: %s, 取得データ長: %d\n", url, len(body))
}
func main() {
	// タイムアウト処理の例
	fetchWithTimeout("https://example.com")
}

URL: https://example.com, 取得データ長: 1256

package main
import (
	"errors"
	"fmt"
	"sync"
)
// エラーを返すサンプル処理
func processTask(taskID int) (string, error) {
	if taskID%2 == 0 {
		return "", errors.New("サンプルエラー発生")
	}
	return fmt.Sprintf("タスク%d成功", taskID), nil
}
func main() {
	var wg sync.WaitGroup
	resultChan := make(chan string, 3)
	errorChan := make(chan error, 3)
	taskCount := 3
	wg.Add(taskCount)
	for i := 1; i <= taskCount; i++ {
		go func(id int) {
			defer wg.Done()
			// タスク処理
			if result, err := processTask(id); err != nil {
				errorChan <- err
			} else {
				resultChan <- result
			}
		}(i)
	}
	wg.Wait()
	close(resultChan)
	close(errorChan)
	// 結果の出力
	for res := range resultChan {
		fmt.Println(res)
	}
	for err := range errorChan {
		fmt.Println("エラー:", err)
	}
}

タスク1成功
タスク3成功
エラー: サンプルエラー発生