Go: قنوات الاتصال

// Shared memory approach: lock on every read/write, hard to maintain
type TransactionPool struct {
    mu     sync.Mutex
    items  []Transaction
}

func (p *TransactionPool) Add(t Transaction) {
    p.mu.Lock()
    defer p.mu.Unlock()
    p.items = append(p.items, t)
}

func (p *TransactionPool) Get() Transaction {
    p.mu.Lock()
    defer p.mu.Unlock()
    if len(p.items) == 0 {
        return Transaction{}
    }
    item := p.items[0]
    p.items = p.items[1:]
    return item
}

// channel_approach.go
package main

import "fmt"

type Transaction struct {
    ID     string
    Amount float64
}

func main() {
    // Create an unbuffered channel
    ch := make(chan Transaction)

    // Producer goroutine
    go func() {
        tx := Transaction{ID: "TXN-001", Amount: 99.99}
        ch <- tx  // Send (blocks until receiver is ready)
        fmt.Println("Producer: send complete")
    }()

    // Consumer
    tx := <-ch  // Receive (blocks until sender is ready)
    fmt.Printf("Consumer: received %s ($%.2f)\n", tx.ID, tx.Amount)
}

Consumer: received TXN-001 ($99.99)
Producer: send complete

package main

import "fmt"

func main() {
    // Unbuffered channel (synchronous)
    ch1 := make(chan int)

    // Buffered channel (asynchronous, capacity 3)
    ch2 := make(chan string, 3)

    // nil channel (cannot be used directly)
    var ch3 chan float64

    fmt.Printf("ch1: %T, unbuffered\n", ch1)
    fmt.Printf("ch2: %T, buffer=%d\n", ch2, cap(ch2))
    fmt.Printf("ch3: %T, nil=%v\n", ch3, ch3 == nil)
}

ch := make(chan int)

// Send: ch <- القيمة
ch <- 42  // Unbuffered: blocks until someone receives

// Receive: القيمة := <-ch
القيمة := <-ch  // Blocks until someone sends

// Discard received القيمة
<-ch  // Receive only, ignore القيمة (used for synchronization signals)

package main

import (
    "fmt"
    "time"
)

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

    go func() {
        fmt.Println("goroutine: ready to send...")
        ch <- "hello"  // Blocks until main receives
        fmt.Println("goroutine: send complete")
    }()

    time.Sleep(1 * time.Second)  // Simulate delay
    fmt.Println("main: ready to receive...")
    msg := <-ch
    fmt.Printf("main: received %q\n", msg)
}

goroutine: ready to send...
main: ready to receive...
goroutine: send complete
main: received "hello"

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 3)  // Capacity 3

    go func() {
        for i := 1; i <= 5; i++ {
            ch <- i
            fmt.Printf("Sent %d (len=%d)\n", i, len(ch))
        }
        close(ch)
    }()

    time.Sleep(500 * time.Millisecond)

    for v := range ch {
        fmt.Printf("Received %d\n", v)
        time.Sleep(200 * time.Millisecond)
    }
}

Sent 1 (len=0)
Sent 2 (len=1)
Sent 3 (len=2)
Sent 4 (len=3)
Sent 5 (len=4)
Received 1
Received 2
Received 3
Received 4
Received 5

package main

import (
    "fmt"
    "time"
)

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

    ch <- 1  // ✅ Does not block (has space)
    ch <- 2  // ✅ Does not block (has space)
    // ch <- 3  // ❌ Blocks! Buffer is full, waiting for receiver

    go func() {
        time.Sleep(100 * time.Millisecond)
        fmt.Println("goroutine: starting to receive")
        <-ch  // Frees up one slot
    }()

    fmt.Println("main: sending 3")
    ch <- 3  // Now does not block (goroutine has received one)
    fmt.Println("main: send complete")
    close(ch)

    for v := range ch {
        fmt.Printf("v=%d\n", v)
    }
}

package main

import "fmt"

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    close(ch)  // Cannot send after closing

    // Can still receive remaining data after closing
    v1 := <-ch  // 1
    v2 := <-ch  // 2
    v3 := <-ch  // 0 (zero value, ok=false)
    fmt.Println(v1, v2, v3)
}

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 10
    ch <- 20
    close(ch)

    // comma-ok: ok=false means channel is closed and has no data
    v, ok := <-ch
    fmt.Printf("v=%d, ok=%v\n", v, ok)  // v=10, ok=true

    v, ok = <-ch
    fmt.Printf("v=%d, ok=%v\n", v, ok)  // v=20, ok=true

    v, ok = <-ch
    fmt.Printf("v=%d, ok=%v\n", v, ok)  // v=0, ok=false (closed and empty)
}

package main

import "fmt"

func main() {
    ch := make(chan string, 3)
    ch <- "Alice"
    ch <- "Bob"
    ch <- "Charlie"
    close(ch)

    // for range automatically exits when the channel is closed
    for name := range ch {
        fmt.Printf("Hello, %s!\n", name)
    }

    // Equivalent to:
    // for {
    //     name, ok := <-ch
    //     if !ok { break }
    //     fmt.Println(name)
    // }
}

package main

import "fmt"

// Write-only channel (can only send)
func producer(out chan<- int) {
    for i := 1; i <= 3; i++ {
        out <- i  // ✅ Can only send
    }
    close(out)
}

// Read-only channel (can only receive)
func consumer(in <-chan int) {
    for v := range in {
        fmt.Printf("Received: %d\n", v)  // ✅ Can only receive
    }
}

func main() {
    ch := make(chan int, 3)
    go producer(ch)   // Automatically converts to chan<- int
    consumer(ch)       // Automatically converts to <-chan int
}

package main

import (
    "fmt"
    "strings"
)

// Stage 1: Write-only
func stage1(names []string, out chan<- string) {
    for _, name := range names {
        out <- strings.ToUpper(name)
    }
    close(out)
}

// Stage 2: Read-write (read from in, process, write to out)
func stage2(in <-chan string, out chan<- string) {
    for name := range in {
        out <- "Hello, " + name + "!"
    }
    close(out)
}

// Stage 3: Read-only
func stage3(in <-chan string) {
    for msg := range in {
        fmt.Println(msg)
    }
}

func main() {
    ch1 := make(chan string, 3)
    ch2 := make(chan string, 3)

    names := []string{"Alice", "Bob", "Charlie"}

    go stage1(names, ch1)
    go stage2(ch1, ch2)
    stage3(ch2)
}

Hello, ALICE!
Hello, BOB!
Hello, CHARLIE!

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "from ch1"
    }()

    go func() {
        time.Sleep(200 * time.Millisecond)
        ch2 <- "from ch2"
    }()

    select {
    case msg := <-ch1:
        fmt.Println(msg)
    case msg := <-ch2:
        fmt.Println(msg)
    case <-time.After(300 * time.Millisecond):
        fmt.Println("Timeout")
    }
}

package main

import (
    "fmt"
    "time"
)

func longOperation(result chan<- string) {
    time.Sleep(3 * time.Second)
    result <- "Done"
}

func main() {
    result := make(chan string)

    go longOperation(result)

    الاختيار {
    case res := <-result:
        fmt.Println(res)
    case <-time.After(1 * time.Second):
        fmt.Println("Operation timed out!")
    }
}

Operation timed out!

// Deadlock 1: Unbuffered channel with send but no receive
func deadlock1() {
    ch := make(chan int)
    ch <- 42  // fatal error: all goroutines are asleep - deadlock!
}

// Deadlock 2: main goroutine waiting on itself
func deadlock2() {
    ch := make(chan int)
    <-ch  // fatal error: deadlock
}

// Deadlock 3: Multiple goroutines waiting on each other
func deadlock3() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        <-ch1  // Wait for ch1
        ch2 <- 1
    }()

    <-ch2  // Wait for ch2
    ch1 <- 1  // Never reaches this line
}

// pipeline.go
package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

// Work unit
type Job struct {
    ID      int
    Payload string
}

type Result struct {
    Job      Job
    Output   string
    Err      error
    Duration time.Duration
}

// Producer: generates jobs (write-only channel)
func producer(jobs chan<- Job, count int) {
    for i := 1; i <= count; i++ {
        jobs <- Job{
            ID:      i,
            Payload: fmt.Sprintf("task-%d", i),
        }
        time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
    }
    close(jobs)
}

// Consumer: processes jobs (read jobs, write results)
func consumer(id int, jobs <-chan Job, results chan<- Result, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        start := time.Now()

        // Simulate processing
        time.Sleep(time.Duration(50+rand.Intn(100)) * time.Millisecond)
        output := fmt.Sprintf("consumer-%d processed %s", id, job.Payload)

        results <- Result{
            Job:      job,
            Output:   output,
            Duration: time.Since(start),
        }
    }
}

// Collector: collects and prints results (read-only channel)
func collector(results <-chan Result, done chan<- struct{}) {
    var total time.Duration
    count := 0

    for r := range results {
        count++
        total += r.Duration
        status := "OK"
        if r.Err != nil {
            status = "ERR"
        }
        fmt.Printf("[%s] Job#%d: %s (%v)\n",
            status, r.Job.ID, r.Output, r.Duration)
    }

    if count > 0 {
        fmt.Printf("\nTotal %d tasks, avg %.2f ms\n",
            count, float64(total.Milliseconds())/float64(count))
    }
    close(done)
}

func main() {
    const (
        jobCount     = 20
        workerCount  = 3
    )

    jobs := make(chan Job, 10)
    results := make(chan Result, 10)
    done := make(chan struct{})

    // 1 producer
    go producer(jobs, jobCount)

    // N consumers
    var wg sync.WaitGroup
    for w := 1; w <= workerCount; w++ {
        wg.Add(1)
        go consumer(w, jobs, results, &wg)
    }

    // Wait for all consumers to finish, then close results
    go func() {
        wg.Wait()
        close(results)
    }()

    // Collector (main goroutine)
    collector(results, done)
    <-done
}

[OK] Job#1: consumer-2 processed task-1 (85ms)
[OK] Job#2: consumer-1 processed task-2 (92ms)
[OK] Job#3: consumer-3 processed task-3 (78ms)
...
[OK] Job#20: consumer-1 processed task-20 (112ms)

Total 20 tasks, avg 87.45 ms