Goのselect文とctx.Done()によるキャンセル処理を解説

package main
import (
	"fmt"
	"time"
)
func main() {
	chanA := make(chan string)
	chanB := make(chan string)
	// 1秒後にchanAへデータ送信
	go func() {
		time.Sleep(1 * time.Second)
		chanA <- "チャネルAのデータ"
	}()
	// 2秒後にchanBへデータ送信
	go func() {
		time.Sleep(2 * time.Second)
		chanB <- "チャネルBのデータ"
	}()
	select {
	case msg := <-chanA:
		fmt.Println(msg)
	case msg := <-chanB:
		fmt.Println(msg)
	}
}

チャネルAのデータ

package main
import (
	"fmt"
	"time"
)
func worker(id int, ch chan<- string) {
	// idに応じて処理時間が異なる
	time.Sleep(time.Duration(id) * time.Second)
	ch <- fmt.Sprintf("Worker %d 完了", id)
}
func main() {
	ch := make(chan string)
	// 3つのGoルーチンを起動
	for i := 1; i <= 3; i++ {
		go worker(i, ch)
	}
	// チャネルから3件の結果を受信
	for i := 0; i < 3; i++ {
		select {
		case result := <-ch:
			fmt.Println(result)
		}
	}
}

Worker 1 完了
Worker 2 完了
Worker 3 完了

package main
import (
	"context"
	"fmt"
	"time"
)
func process(ctx context.Context) {
	// キャンセルシグナルの有無を常にチェック
	for {
		select {
		case <-ctx.Done():
			// キャンセルシグナルを受信した場合の処理
			fmt.Println("処理キャンセル")
			return
		default:
			// 通常処理
			fmt.Println("処理中...")
			time.Sleep(500 * time.Millisecond)
		}
	}
}
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go process(ctx)
	// 2秒後にキャンセルを実行
	time.Sleep(2 * time.Second)
	cancel()
	// キャンセル後の終了を待機
	time.Sleep(1 * time.Second)
}

処理中...
処理中...
処理中...
処理中...
処理キャンセル

package main
import (
	"context"
	"fmt"
	"time"
)
func processWithTimeout(ctx context.Context) {
	select {
	case <-time.After(3 * time.Second):
		// 処理が完了した場合
		fmt.Println("処理完了")
	case <-ctx.Done():
		// タイムアウトまたはキャンセル処理
		fmt.Println("タイムアウトまたはキャンセル")
	}
}
func main() {
	// 2秒後にタイムアウトするコンテキストを生成
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	processWithTimeout(ctx)
}

タイムアウトまたはキャンセル

package main
import (
	"context"
	"fmt"
	"time"
)
// fetchData関数は、データ取得をシミュレーションする
func fetchData(ctx context.Context, dataCh chan<- string) {
	time.Sleep(2 * time.Second)
	dataCh <- "取得したデータ"
}
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	dataCh := make(chan string)
	go fetchData(ctx, dataCh)
	select {
	case data := <-dataCh:
		fmt.Println("受信データ:", data)
	case <-ctx.Done():
		fmt.Println("キャンセルシグナル受信")
	}
}

受信データ: 取得したデータ

package main
import (
	"context"
	"fmt"
	"time"
)
func longRunningTask(ctx context.Context) error {
	select {
	case <-time.After(5 * time.Second):
		fmt.Println("タスク完了")
	case <-ctx.Done():
		// キャンセル時の後処理実施
		fmt.Println("キャンセルによるタスク中断")
		return ctx.Err()
	}
	return nil
}
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		// 3秒後にキャンセルを実施
		time.Sleep(3 * time.Second)
		cancel()
	}()
	if err := longRunningTask(ctx); err != nil {
		fmt.Println("エラー:", err)
	}
}

キャンセルによるタスク中断
エラー: context canceled

package main
import (
	"context"
	"fmt"
	"time"
)
func processData(ctx context.Context, resultCh chan<- string) {
	time.Sleep(2 * time.Second)
	resultCh <- "処理完了"
}
func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	resultCh := make(chan string)
	go processData(ctx, resultCh)
	select {
	case res := <-resultCh:
		fmt.Println("結果:", res)
	case <-ctx.Done():
		fmt.Println("キャンセルまたはタイムアウトにより処理中断")
	}
}

結果: 処理完了

package main
import (
	"context"
	"fmt"
	"time"
)
func task(ctx context.Context, resultCh chan<- string) {
	time.Sleep(4 * time.Second)
	resultCh <- "タスク完了"
}
func main() {
	// 3秒のタイムアウト組み込み
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	resultCh := make(chan string)
	go task(ctx, resultCh)
	select {
	case res := <-resultCh:
		fmt.Println(res)
	case <-ctx.Done():
		fmt.Println("タイムアウトまたはキャンセルにより終了")
	}
}

タイムアウトまたはキャンセルにより終了

package main
import (
	"context"
	"fmt"
	"time"
)
// fetchData関数は、データ取得をシミュレーションする
func fetchData(ctx context.Context, dataCh chan<- string) {
	// 2秒程度でデータ取得完了と仮定
	time.Sleep(2 * time.Second)
	dataCh <- "データ取得完了"
}
func main() {
	// キャンセル可能なコンテキスト生成
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	dataCh := make(chan string)
	go fetchData(ctx, dataCh)
	select {
	case data := <-dataCh:
		fmt.Println("受信データ:", data)
	case <-ctx.Done():
		fmt.Println("キャンセルされたため処理中断")
	}
}

受信データ: データ取得完了

package main
import (
	"context"
	"fmt"
	"time"
)
// simulateTask関数は、長時間処理をシミュレーションする
func simulateTask(ctx context.Context, resultCh chan<- string) {
	// 3秒間の処理をシミュレート
	time.Sleep(3 * time.Second)
	select {
	case resultCh <- "シミュレーション完了":
		// 結果送信成功
	case <-ctx.Done():
		// キャンセルされた場合の処理
	}
}
func main() {
	// 3秒のタイムアウトを設定
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	resultCh := make(chan string)
	go simulateTask(ctx, resultCh)
	select {
	case res := <-resultCh:
		fmt.Println("結果:", res)
	case <-ctx.Done():
		fmt.Println("テストタイムアウト、またはキャンセル")
	}
}

結果: シミュレーション完了