🔥 채널: 값을 주고받는 통로

ch <- v    // v를 채널 ch로 보냅니다.
v := <-ch  // ch에서 값을 받아
           // v에 할당합니다.
 
go복사

ch := make(chan int)
 
go복사

package main
 
import "fmt"
 
func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v  // 슬라이스의 각 요소를 더합니다.
	}
	c <- sum     // 합계를 c로 보냅니다.
}
 
func main() {
	s := []int{7, 2, 8, -9, 4, 0}
 
	c := make(chan int)
	go sum(s[:len(s)/2], c)  // 슬라이스 앞부분을 더하는 고루틴
	go sum(s[len(s)/2:], c)  // 슬라이스 뒷부분을 더하는 고루틴
	x, y := <-c, <-c         // c에서 결과를 받습니다.
 
	fmt.Println(x, y, x+y)   // 부분합과 전체합을 출력합니다.
}
 
go복사

package main
 
import (
    "fmt"
    "sync"
)
 
type BankAccount struct {
    balance int
    ch      chan func()
}
 
func NewBankAccount(initialBalance int) *BankAccount {
    account := &BankAccount{
        balance: initialBalance,
        ch:      make(chan func()),
    }
    go func() {
        for message := range account.ch {
            message()  // 받은 메시지(함수)를 실행합니다.
        }
    }()
    return account
}
 
func (a *BankAccount) Deposit(amount int) {
    a.ch <- func() {
        a.balance += amount  // 잔액에 입금액을 더합니다.
    }
}
 
func (a *BankAccount) Withdraw(amount int) bool {
    result := make(chan bool)
    a.ch <- func() {
        if a.balance >= amount {
            a.balance -= amount  // 잔액에서 출금액을 뺍니다.
            result <- true
        } else {
            result <- false
        }
    }
    return <-result
}
 
func (a *BankAccount) Balance() int {
    result := make(chan int)
    a.ch <- func() {
        result <- a.balance  // 현재 잔액을 채널로 보냅니다.
    }
    return <-result
}
 
func main() {
    var wg sync.WaitGroup
    account := NewBankAccount(1000)
 
    // 여러 고루틴에서 계좌에 접근합니다.
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            account.Deposit(100)
            if account.Withdraw(50) {
                fmt.Println("출금 성공!")
            } else {
                fmt.Println("잔액 부족!")
            }
        }()
    }
 
    wg.Wait()
    fmt.Printf("최종 잔액: %d", account.Balance())
}
 
go복사

package main
 
import (
    "fmt"
    "math/rand"
    "time"
)
 
// Result는 비동기 작업의 결과를 나타냅니다.
type Result struct {
    Value int
    Err   error
}
 
// Promise는 비동기 작업을 나타냅니다.
type Promise struct {
    ch chan Result
}
 
// NewPromise는 새로운 Promise를 생성합니다.
func NewPromise(fn func() (int, error)) *Promise {
    p := &Promise{
        ch: make(chan Result, 1),
    }
    go func() {
        value, err := fn()
        p.ch <- Result{Value: value, Err: err}
    }()
    return p
}
 
// Then은 Promise의 결과를 처리하는 메서드입니다.
func (p *Promise) Then(fn func(int) (int, error)) *Promise {
    return NewPromise(func() (int, error) {
        result := <-p.ch
        if result.Err != nil {
            return 0, result.Err
        }
        return fn(result.Value)
    })
}
 
// Await은 Promise의 결과를 기다리는 함수입니다.
func Await(p *Promise) (int, error) {
    result := <-p.ch
    return result.Value, result.Err
}
 
// 비동기 작업을 모사하는 함수입니다.
func asyncTask() (int, error) {
    time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
    if rand.Intn(2) == 0 {
        return 0, fmt.Errorf("async task failed")
    }
    return rand.Intn(100), nil
}
 
func main() {
    start := time.Now()
 
    p := NewPromise(asyncTask).Then(func(value int) (int, error) {
        fmt.Printf("첫 번째 비동기 작업 결과: %d\n", value)
        return asyncTask()
    }).Then(func(value int) (int, error) {
        fmt.Printf("두 번째 비동기 작업 결과: %d\n", value)
        return value, nil
    })
 
    result, err := Await(p)
    if err != nil {
        fmt.Printf("에러 발생: %v\n", err)
    } else {
        fmt.Printf("최종 결과: %d\n", result)
    }
 
    elapsed := time.Since(start)
    fmt.Printf("소요 시간: %s\n", elapsed)
}
 
go복사

첫 번째 비동기 작업 결과: 96
두 번째 비동기 작업 결과: 65
최종 결과: 65
소요 시간: 709.187291ms
text복사

첫 번째 비동기 작업 결과: 71
에러 발생: async task failed
소요 시간: 936.864007ms
text복사