// バッファなしチャネル（同期）
ch := make(chan int)

// バッファ付きチャネル（非同期、バッファサイズ5）
ch := make(chan string, 5)

ch := make(chan int)

// 送信（別のgoroutine内で）
go func() {
    ch <- 42 // チャネルに42を送信
}()

// 受信
value := <-ch // チャネルから値を受信、データが利用可能になるまでブロック
fmt.Println(value) // 42

ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
close(ch) // チャネルを閉じる、これ以上の送信は許可されない

ch := make(chan int, 3)
ch <- 10
ch <- 20
ch <- 30
close(ch)

// rangeはチャネルが閉じられるまで受信を続ける
for v := range ch {
    fmt.Println(v) // 10 20 30
}

// 送信専用チャネル
func producer(ch chan<- int) {
    ch <- 100
}

// 受信専用チャネル
func consumer(ch <-chan int) {
    v := <-ch
    fmt.Println(v)
}

package main

import "fmt"

func main() {
    // バッファなしチャネルを作成
    ch := make(chan string)

    // メッセージを送信するgoroutineを起動
    go func() {
        ch <- "こんにちは、メインスレッド！"
    }()

    // メインgoroutineがメッセージを受信（待機中にブロック）
    msg := <-ch
    fmt.Println(msg) // こんにちは、メインスレッド！
}

package main

import "fmt"

// プロデューサー：データを生成してチャネルに送信（送信専用）
func producer(id int, ch chan<- int, count int) {
    for i := 0; i < count; i++ {
        value := id*100 + i
        fmt.Printf("プロデューサー %d：%d を送信中\n", id, value)
        ch <- value
    }
}

// コンシューマー：チャネルからデータを受信して処理（受信専用）
func consumer(id int, ch <-chan int) {
    for v := range ch {
        fmt.Printf("コンシューマー %d：%d を処理中\n", id, v)
    }
    fmt.Printf("コンシューマー %d：チャネルが閉じられ、終了します\n", id)
}

func main() {
    // バッファ付きチャネルを作成
    ch := make(chan int, 5)

    // 2つのプロデューサーを起動
    go producer(1, ch, 3)
    go producer(2, ch, 3)

    // 2つのコンシューマーを起動
    go consumer(1, ch)
    go consumer(2, ch)

    // すべてのプロデューサーが完了するまで待機（実際のプロジェクトではsync.WaitGroupを使用）
    // ここではデモンストレーションのために単純にsleepを使用
    import_time := time.After(2 * time.Second)
    <-import_time

    close(ch) // チャネルを閉じる

    // コンシューマーが残りのデータを処理する時間を与える
    time.Sleep(500 * time.Millisecond)
    fmt.Println("すべての作業が完了しました")
}

package main

import (
    "fmt"
    "sync"
    "time"
)

// workerはタスクを処理し、結果をresultsチャネルに送信する
func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("ワーカー %d：タスク %d の処理を開始\n", id, job)
        time.Sleep(time.Duration(100+id*50) * time.Millisecond) // 作業をシミュレート
        result := job * job
        fmt.Printf("ワーカー %d：タスク %d 完了、結果 %d\n", id, job, result)
        results <- result
    }
}

func main() {
    numJobs := 10
    numWorkers := 3

    jobs := make(chan int, numJobs)     // タスクチャネル
    results := make(chan int, numJobs)  // 結果チャネル

    // ワーカープールを起動
    var wg sync.WaitGroup
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // タスクを送信
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs) // タスクチャネルを閉じる；ワーカーのrangeループが終了する

    // すべてのワーカーが完了したらresultsチャネルを閉じる
    go func() {
        wg.Wait()
        close(results)
    }()

    // すべての結果を収集
    total := 0
    for r := range results {
        total += r
    }

    fmt.Printf("すべての結果の合計：%d\n", total)
}

package main

import (
    "fmt"
    "time"
)

func slowOperation(ch chan<- string) {
    time.Sleep(3 * time.Second) // 遅い操作をシミュレート
    ch <- "操作完了"
}

func main() {
    ch := make(chan string, 1)
    go slowOperation(ch)

    // selectを使用してタイムアウト制御
    select {
    case result := <-ch:
        fmt.Println("結果を受信：", result)
    case <-time.After(2 * time.Second):
        fmt.Println("操作がタイムアウトしました！") // 2秒後にトリガー
    }
}

package main

import (
    "fmt"
    "time"
)

// fetchURLはURLの取得をシミュレートする
func fetchURL(url string) string {
    time.Sleep(500 * time.Millisecond) // ネットワーク遅延をシミュレート
    return "ページコンテンツ：" + url
}

func main() {
    urls := []string{
        "https://example.com/page1",
        "https://example.com/page2",
        "https://example.com/page3",
        "https://example.com/page4",
        "https://example.com/page5",
    }

    // バッファ付きチャネルをセマフォとして使用し、同時実行数を2に制限
    semaphore := make(chan struct{}, 2)
    results := make(chan string, len(urls))

    for _, url := range urls {
        go func(u string) {
            semaphore <- struct{}{} // セマフォを取得（満杯の場合はブロック）
            fmt.Printf("取得開始：%s\n", u)
            result := fetchURL(u)
            results <- result
            <-semaphore // セマフォを解放
        }(url)
    }

    // 結果を収集
    for i := 0; i < len(urls); i++ {
        fmt.Println(<-results)
    }

    fmt.Println("すべてのページの取得が完了しました")
}

ch := make(chan int, 1)
ch <- 1
close(ch)
// ch <- 2 // ❌ panic: send on closed channel
v := <-ch   // ✅ 1を返す（バッファ内の残りの値）
v2 := <-ch  // ✅ 0を返す（ゼロ値、チャネルは空で閉じられている）

var ch chan int // nilチャネル

// ch <- 1    // ❌ 永久にブロック
// v := <-ch  // ❌ 永久にブロック
// close(ch)  // ❌ panic: close of nil channel

var ch chan int // nilチャネル
select {
case v := <-ch:       // 無視される（nilチャネル）
    fmt.Println(v)
case <-time.After(1 * time.Second):
    fmt.Println("タイムアウトしました")
}

ch := make(chan int, 1)
ch <- 42
close(ch)

v, ok := <-ch
fmt.Println(v, ok) // 42 true

v2, ok := <-ch
fmt.Println(v2, ok) // 0 false（閉じられていてデータなし）