package main

import "fmt"

func main() {
    ch := make(chan int) // 創(chuàng)建一個(gè)整型 channel
    go func() {
        ch <- 42 // 發(fā)送數(shù)據(jù)到 channel
    }()
    fmt.Println(<-ch) // 從 channel 接收數(shù)據(jù)并打印
}

package main

import "fmt"

func main() {
    // 無緩沖 channel
    ch1 := make(chan int)
    go func() {
        ch1 <- 1
    }()
    fmt.Println(<-ch1)

    // 有緩沖 channel
    ch2 := make(chan int, 2)
    ch2 <- 1
    ch2 <- 2
    fmt.Println(<-ch2)
    fmt.Println(<-ch2)
}

package main

import "fmt"

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

    go func() {
        for i := 0; i < 5; i++ {
            ch <- i // 發(fā)送數(shù)據(jù)到 channel
        }
        close(ch) // 關(guān)閉 channel
    }()

    for val := range ch { // 從 channel 中讀取數(shù)據(jù)
        fmt.Println(val)
    }
}

package main

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

func fetchURL(url string, wg *sync.WaitGroup, ch chan<- string) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    ch <- fmt.Sprintf("Fetched %s with status %s", url, resp.Status)
}

func main() {
    urls := []string{
        "http://example.com",
        "http://example.org",
        "http://example.net",
    }

    var wg sync.WaitGroup
    ch := make(chan string)

    for _, url := range urls {
        wg.Add(1)
        go fetchURL(url, &wg, ch)
    }

    go func() {
        wg.Wait()
        close(ch) // 關(guān)閉 channel
    }()

    for msg := range ch {
        fmt.Println(msg) // 打印每個(gè)結(jié)果
    }
}

package main

import (
    "fmt"
    "time"
)

// 日志結(jié)構(gòu)體
type LogMessage struct {
    Level   string // 日志級別
    Message string // 日志內(nèi)容
}

// 日志處理器
func logProcessor(logChannel <-chan LogMessage, batchSize int, flushInterval time.Duration) {
    var logBatch []LogMessage
    timer := time.NewTimer(flushInterval)

    for {
        select {
        case log := <-logChannel:
            // 將日志添加到當(dāng)前批次
            logBatch = append(logBatch, log)

            // 當(dāng)達(dá)到批量大小時(shí)處理日志
            if len(logBatch) >= batchSize {
                processBatch(logBatch) // 處理日志批次
                logBatch = nil         // 清空批次
                timer.Reset(flushInterval) // 重置定時(shí)器
            }

        case <-timer.C:
            // 定時(shí)器觸發(fā)時(shí)處理未滿批次的日志
            if len(logBatch) > 0 {
                processBatch(logBatch)
                logBatch = nil
            }
            timer.Reset(flushInterval)
        }
    }
}

// 處理日志批次的函數(shù)（偽代碼）
func processBatch(logs []LogMessage) {
    for _, log := range logs {
        fmt.Printf("[%s] %s\n", log.Level, log.Message)
    }
}

func main() {
    logChannel := make(chan LogMessage, 100) // 創(chuàng)建帶緩沖的 channel
    batchSize := 10                          // 設(shè)置批量大小
    flushInterval := 5 * time.Second         // 設(shè)置定時(shí)刷新間隔

    go logProcessor(logChannel, batchSize, flushInterval)

    // 模擬日志生成
    for i := 0; i < 50; i++ {
        logChannel <- LogMessage{
            Level:   "INFO",
            Message: fmt.Sprintf("Log message %d", i),
        }
        time.Sleep(200 * time.Millisecond) // 模擬日志生成間隔
    }

    // 確保主 goroutine 不會過早退出
    time.Sleep(10 * time.Second)
}

package main

import (
    "fmt"
    "time"
)

// 模擬處理任務(wù)
func worker(id int, done chan bool) {
    fmt.Printf("Worker %d is working...\n", id)
    time.Sleep(1 * time.Second) // 模擬耗時(shí)操作
    fmt.Printf("Worker %d done\n", id)
    done <- true
}

func main() {
    const maxConcurrent = 3
    semaphore := make(chan struct{}, maxConcurrent) // 控制最大并發(fā)數(shù)

    done := make(chan bool)
    for i := 1; i <= 10; i++ {
        semaphore <- struct{}{} // 占用一個(gè)通道位置
        go func(id int) {
            defer func() { <-semaphore }() // 釋放通道位置
            worker(id, done)
        }(i)
    }

    // 等待所有任務(wù)完成
    for i := 0; i < 10; i++ {
        <-done
    }
}

package main

import (
    "fmt"
    "time"
)

// 模擬廣播事件
func broadcast(channel <-chan string, id int) {
    for msg := range channel {
        fmt.Printf("Listener %d received message: %s\n", id, msg)
    }
}

func main() {
    eventChannel := make(chan string)
    
    // 啟動多個(gè)監(jiān)聽器
    for i := 1; i <= 3; i++ {
        go broadcast(eventChannel, i)
    }

    // 廣播事件消息
    messages := []string{"Event 1", "Event 2", "Event 3"}
    for _, msg := range messages {
        eventChannel <- msg
        time.Sleep(500 * time.Millisecond)
    }
    close(eventChannel)
}

package main

import (
    "fmt"
    "time"
)

func worker(id int, tasks <-chan int, results chan<- int) {
    for task := range tasks {
        fmt.Printf("Worker %d processing task %d\n", id, task)
        time.Sleep(time.Second) // 模擬任務(wù)處理時(shí)間
        results <- task * 2     // 返回處理結(jié)果
    }
}

func main() {
    tasks := make(chan int, 10)
    results := make(chan int, 10)

    // 啟動工作池
    for i := 1; i <= 3; i++ {
        go worker(i, tasks, results)
    }

    // 發(fā)送任務(wù)
    for j := 1; j <= 5; j++ {
        tasks <- j
    }
    close(tasks) // 所有任務(wù)已發(fā)送完畢

    // 收集結(jié)果
    for k := 1; k <= 5; k++ {
        result := <-results
        fmt.Printf("Result: %d\n", result)
    }
}