Channel và giao tiếp

Thuộc phần Lập trình hướng đối tượng trong hành trình GO của Coddy. Bài học 60 trên 107.

Channels là cơ chế chính của Go để các goroutine giao tiếp với nhau. Thay vì chia sẻ bộ nhớ trực tiếp, các goroutine gửi và nhận giá trị thông qua channel, theo triết lý của Go: "Đừng giao tiếp bằng cách chia sẻ bộ nhớ; hãy chia sẻ bộ nhớ bằng cách giao tiếp."

Tạo một kênh bằng hàm make với từ khóa chan:

messages := make(chan string)

Dùng toán tử mũi tên <- để gửi và nhận giá trị. Mũi tên chỉ hướng luồng dữ liệu:

func main() {
    messages := make(chan string)
    
    go func() {
        messages <- "hello"  // gửi vào kênh
    }()
    
    msg := <-messages  // nhận từ kênh
    fmt.Println(msg)   // Đầu ra: hello
}

Theo mặc định, việc gửi và nhận sẽ chặn cho đến khi phía bên kia sẵn sàng. Khi goroutine gửi "hello", nó chờ cho đến khi main sẵn sàng nhận. Cách chặn này cung cấp cơ chế đồng bộ hóa tích hợp sẵn: không cần time.Sleep.

Bạn có thể đóng một kênh để báo hiệu rằng sẽ không có thêm giá trị nào được gửi. Bên nhận có thể phát hiện điều này:

close(messages)

msg, ok := <-messages
if !ok {
    fmt.Println("Channel closed")
}

Kênh có kiểu dữ liệu cụ thể: chan string chỉ có thể truyền chuỗi. Tính an toàn kiểu dữ liệu này giúp các goroutine giao tiếp bằng đúng kiểu dữ liệu, phát hiện lỗi khi biên dịch thay vì khi chạy chương trình.

Thử thách

Dễ

Hãy xây dựng một hệ thống chuyển tiếp thông điệp để minh họa cách các goroutine giao tiếp qua channel. Bạn sẽ tạo một quy trình xử lý, trong đó thông điệp luân chuyển giữa các giai đoạn xử lý khác nhau, mỗi giai đoạn chạy đồng thời.

Bạn sẽ sắp xếp code trong hai tệp:

relay.go: Định nghĩa quy trình xử lý thông điệp.
Tạo một struct Message có các trường ID (int) và Content (string).

Triển khai ba hàm đại diện cho các giai đoạn khác nhau của quy trình xử lý:
- Producer(messages []Message, out chan Message) - Nhận một lát cắt thông điệp và gửi từng thông điệp vào channel đầu ra. Sau khi gửi tất cả thông điệp, hãy đóng channel để báo hiệu đã hoàn tất.
- Transformer(in chan Message, out chan Message) - Nhận thông điệp từ channel đầu vào, chuyển nội dung của từng thông điệp thành chữ hoa, rồi gửi thông điệp đã chuyển đổi vào channel đầu ra. Khi channel đầu vào đóng lại, được phát hiện bằng cú pháp nhận hai giá trị, hãy đóng channel đầu ra.
- Consumer(in chan Message) []string - Nhận tất cả thông điệp từ channel đầu vào và tập hợp chúng thành một lát cắt gồm các chuỗi đã định dạng. Mỗi chuỗi phải theo định dạng: Message [ID]: [Content]. Trả về lát cắt khi channel đóng.
main.go: Thiết lập quy trình xử lý và điều phối luồng thông điệp đồng thời.
Đọc số lượng thông điệp, sau đó đọc ID và nội dung của từng thông điệp. Tạo các thông điệp và thiết lập hai channel để kết nối ba giai đoạn trong quy trình. Chạy Producer và Transformer dưới dạng goroutine, sau đó chạy Consumer trong goroutine chính để thu thập kết quả. In mỗi kết quả trên một dòng riêng.

Đầu vào sẽ có định dạng như sau:

Dòng 1: Số lượng thông điệp (số nguyên)
Các dòng tiếp theo: Với mỗi thông điệp, hai dòng: ID thông điệp (số nguyên), rồi đến nội dung (chuỗi)

Ví dụ, với đầu vào:

2
1
hello world
2
go channels

Đầu ra cần có là:

Message 1: HELLO WORLD
Message 2: GO CHANNELS

Quy trình hoạt động như sau: Producer gửi thông điệp → Transformer chuyển thành chữ hoa → Consumer thu thập và định dạng kết quả. Mỗi mũi tên biểu thị một channel kết nối các giai đoạn chạy đồng thời. Dùng package strings để chuyển chữ hoa.

Tự làm thử

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Đọc số lượng thông điệp
	nLine, _ := reader.ReadString('\n')
	n, _ := strconv.Atoi(strings.TrimSpace(nLine))

	// Đọc các thông điệp
	messages := make([]Message, n)
	for i := 0; i < n; i++ {
		idLine, _ := reader.ReadString('\n')
		id, _ := strconv.Atoi(strings.TrimSpace(idLine))
		contentLine, _ := reader.ReadString('\n')
		content := strings.TrimSpace(contentLine)
		messages[i] = Message{ID: id, Content: content}
	}

	// TODO: Tạo hai kênh để kết nối các giai đoạn của pipeline

	// TODO: Khởi chạy Producer dưới dạng goroutine

	// TODO: Khởi chạy Transformer dưới dạng goroutine

	// TODO: Chạy Consumer trong goroutine chính và thu thập kết quả

	// TODO: In mỗi kết quả trên một dòng riêng
}