Golang Channel là gì? Các ứng dụng Channel trong Golang

Channel trong Golang là một thành phần rất quan trọng giúp các goroutines giao tiếp với nhau một cách an toàn và hiệu quả. Bài viết này sẽ giúp bạn hiểu rõ về Channel, cách khai báo, gởi và nhận dữ liệu, cùng với những lưu ý trong quá trình sử dụng.

Channel trong Golang là gì?

Table of Contents

Channel là các kênh giao tiếp trung gian giữa các goroutines trong Golang, giúp các goroutines gởi và nhận dữ liệu cho nhau một cách an toàn thông qua cơ chế lock-free. Channel có thể coi là một loại “đường ống” giúp truyền dữ liệu giữa các goroutines. Theo triết lý của Rob Pike: “Đừng giao tiếp bằng việc chia sẻ bộ nhớ, thay vào đó hãy chia sẻ bộ nhớ thông qua việc giao tiếp”.

Nói một cách đơn giản, Channel hỗ trợ việc truyền dữ liệu giữa các goroutines mà không bị lỗi race condition.

Cách khai báo Channel trong Golang

Để sử dụng Channel, bạn có thể dùng từ khóa chan. Để khai báo một kênh, bạn có thể dùng cú pháp sau:

var channelName chan Type

Hoặc sử dụng make để khởi tạo:

channelName := make(chan Type)

Golang là ngôn ngữ mạnh mẽ với kiểu dữ liệu rõ ràng. Khi khai báo Channel, bạn cần chỉ định kiểu dữ liệu mà Channel sẽ truyền tải.

Gửi và nhận dữ liệu qua Channel

Để gửi dữ liệu vào Channel, chúng ta sử dụng toán tử <-. Toán tử này giúp chỉ định hướng di chuyển của dữ liệu: từ Channel đi ra hoặc từ bên ngoài vào Channel.

Gửi dữ liệu vào Channel

channelName <- value

Gửi dữ liệu vào Channel giống như bạn đang truyền thông điệp đến một người nhận.

Nhận dữ liệu từ Channel

myVar := <- channelName

Ví dụ về gửi và nhận dữ liệu:

package main

import "fmt"

func main() {
    myChan := make(chan int)
    go func() {
        myChan <- 1
    }()
    fmt.Println(<-myChan) // Kết quả sẽ là 1
}

Cơ chế block của Channel

Channel trong Golang hoạt động dựa trên cơ chế block, nghĩa là các goroutines sẽ chờ đợi cho đến khi có dữ liệu để giao tiếp. Nếu một goroutine đang gửi dữ liệu vào một Channel mà không có goroutine nào đang đợi để nhận dữ liệu từ Channel đó, nó sẽ bị block và không thể tiếp tục thực hiện.

Ví dụ sau sẽ làm cho chương trình bị deadlock:

package main

func main() {
    myChan := make(chan int)
    myChan <- 1 // deadlock tại đây
}

Trong ví dụ trên, main goroutine bị block khi cố gắng gửi giá trị vào myChan, vì không có goroutine nào để nhận giá trị này.

Giới hạn việc sử dụng Channel chỉ cho gửi hoặc nhận dữ liệu

Golang cho phép bạn kiểm soát xem Channel có thể hoạt động cho việc gửi hoặc nhận dữ liệu.

Channel chỉ cho gửi dữ liệu

Nếu bạn chỉ muốn một Channel được phép gởi dữ liệu, bạn sẽ sử dụng cú pháp:

func sendOnly(c chan<- int) {
    c <- 2 // OK
}

Channel chỉ cho nhận dữ liệu

Ngược lại, nếu bạn chỉ muốn Channel đó nhận dữ liệu, sử dụng cú pháp:

func receiveOnly(c <-chan int) {
    fmt.Println(<-c) // Lỗi nếu cố gắng gửi dữ liệu vào đây
}

Đóng Channel trong Golang

Để đóng một Channel, bạn sử dụng hàm close(). Khi một Channel bị đóng, không còn dữ liệu nào có thể đi qua nó.

close(chanName)

Kiểm tra xem Channel đã bị đóng hay chưa

Để kiểm tra nếu một Channel đã bị đóng hay chưa, bạn có thể sử dụng cú pháp:

value, isAlive := <-chanName

Biến isAlive sẽ giúp bạn biết Channel còn hoạt động hay không.

Sử dụng Select và WaitGroup

Select

Select cho phép bạn giám sát nhiều Channel và thực hiện hành động dựa trên Channel nào sẵn sàng. Dưới đây là cú pháp cơ bản:

select {
case v1 := <-ch1:
    // Thực hiện việc gì đó với v1
case v2 := <-ch2:
    // Thực hiện việc gì đó với v2
}

WaitGroup

WaitGroup cho phép chờ đợi cho đến khi tất cả goroutines hoàn tất. Cú pháp sử dụng như sau:

var wg sync.WaitGroup
wg.Add(2) // Số lượng goroutines cần chờ

go func() {
    defer wg.Done() // Gọi khi goroutine hoàn tất
}()

wg.Wait() // Chờ cho tất cả goroutines hoàn tất

Ví dụ minh họa sử dụng Channel trong Golang

Dưới đây là một số ví dụ mà bạn có thể tham khảo khi sử dụng Channel:

Ví dụ 1: Lắng nghe dữ liệu từ nhiều nguồn

package main

import (
    "fmt"
    "runtime"
)

func sender(c chan<- int, name string) {
    for i := 1; i <= 100; i++ {
        c <- 1
        fmt.Printf("%s has sent 1 to channeln", name)
        runtime.Gosched()
    }
}

func main() {
    myChan := make(chan int)
    go sender(myChan, "Sender 1")
    go sender(myChan, "Sender 2")
    go sender(myChan, "Sender 3")

    start := 0
    for {
        start += <-myChan
        fmt.Println(start)
        if start >= 300 {
            break
        }
    }
}

Ví dụ 2: Tổng hợp dữ liệu từ các Channel

package main

import (
    "fmt"
    "sync"
)

func streamNumbers(numbers ...int) <-chan int {
    c := make(chan int)
    go func() {
        for _, n := range numbers {
            c <- n
        }
        close(c)
    }()
    return c
}

func sumAllStreams(streams ...<-chan int) <-chan int {
    sumChan := make(chan int)
    counter := 0
    var wg sync.WaitGroup
    wg.Add(len(streams))

    for _, stream := range streams {
        go func(s <-chan int) {
            for n := range s {
                counter += n
            }
            wg.Done()
        }(stream)
    }

    go func() {
        wg.Wait()
        sumChan <- counter
    }()

    return sumChan
}

func main() {
    s := sumAllStreams(
        streamNumbers(1, 2, 3),
        streamNumbers(4, 5, 6),
    )
    fmt.Println(<-s) // In ra tổng của các số
}

Kết luận

Channel trong Golang không chỉ là một công cụ để sử dụng trong lập trình đồng thời mà còn là một cách thức giao tiếp mạnh mẽ giữa các goroutines. Qua bài viết này, bạn đã nắm được những kiến thức cơ bản về Channel, cách thức sử dụng và những ví dụ minh họa để làm quen nhanh chóng với công nghệ này. Để tìm hiểu thêm về Golang và các chủ đề khác trong lập trình, hãy truy cập web comdy.vn.

blog