Go のバッファ付き channel で非同期処理を行う

package main

import "fmt"

func main() {
    ch := make(chan int, 3) // バッファサイズ 3

    ch <- 1
    ch <- 2
    ch <- 3
    // ch <- 4 // これはブロックする（バッファが満杯）

    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
    fmt.Println(<-ch) // 3
}

func main() {
    ch := make(chan int, 2)

    ch <- 1
    fmt.Println("1 を送信")
    ch <- 2
    fmt.Println("2 を送信")

    go func() {
        time.Sleep(2 * time.Second)
        fmt.Println("受信:", <-ch)
    }()

    ch <- 3 // バッファが満杯なのでブロック
    fmt.Println("3 を送信")
}

func main() {
    ch := make(chan string, 5)

    ch <- "a"
    ch <- "b"
    ch <- "c"

    fmt.Println("要素数:", len(ch)) // 3
    fmt.Println("容量:", cap(ch))   // 5
}

func main() {
    jobs := make(chan int, 10) // 最大 10 件のジョブを保持

    // プロデューサー：ジョブを投入
    go func() {
        for i := 1; i <= 5; i++ {
            jobs <- i
            fmt.Println("ジョブ投入:", i)
        }
        close(jobs)
    }()

    // コンシューマー：ジョブを処理
    for job := range jobs {
        fmt.Println("ジョブ処理:", job)
        time.Sleep(500 * time.Millisecond)
    }
}

func main() {
    sem := make(chan struct{}, 3) // 同時に 3 つまで
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()

            sem <- struct{}{} // セマフォ取得
            defer func() { <-sem }() // セマフォ解放

            fmt.Printf("タスク %d 開始\n", id)
            time.Sleep(1 * time.Second)
            fmt.Printf("タスク %d 完了\n", id)
        }(i)
    }

    wg.Wait()
}