[Golang] Phần 21 – Go Goroutine

1. Tổng quan.

Trong ngôn ngữ lập trình Go (Golang), một goroutine là có thể giúp bạn thực hiện các công việc đồng thời (concurrent). Một chương trình Go có thể chạy nhiều goroutine cùng một lúc, và các goroutine này có thể chia sẻ cùng một bộ nhớ. Goroutine giúp tận dụng hiệu suất của hệ thống mà không cần sử dụng quá nhiều tài nguyên.

2. Bản chất của Goroutine.

Bản chất của Goroutine trong ngôn ngữ lập trình Go (Golang) là một đơn vị thực thi đồng thời (concurrent execution). Goroutine không phải là thread truyền thống, mà nó là một đơn vị nhẹ hơn và được quản lý bởi Go runtime.

Dưới đây là một số đặc điểm quan trọng về bản chất của Goroutine:

• Nhẹ và Hiệu Quả:
  • Goroutine có overhead thấp hơn so với việc sử dụng thread truyền thống. Mỗi Goroutine chỉ yêu cầu một lượng nhỏ bộ nhớ (một vài KB), trong khi một thread thường yêu cầu một lượng lớn bộ nhớ (ví dụ: một vài MB).
• Quản Lý Bởi Go Runtime:
  • Goroutine không được quản lý trực tiếp bởi hệ điều hành mà thay vào đó, nó được quản lý bởi Go runtime. Điều này giúp giảm bớt overhead của việc tạo và quản lý các đơn vị thực thi.
• Mô Hình Đồng Thời (Concurrent):
  • Goroutine là một phần quan trọng của mô hình đồng thời của Go, nơi nhiều Goroutine có thể chạy đồng thời mà không cần sự đồng bộ khó khăn.
• Khả Năng Tạo Ra Nhiều Goroutine:
  • Một chương trình Go có thể tạo hàng nghìn, thậm chí hàng triệu Goroutine mà không làm suy giảm hiệu suất, nhờ vào cách quản lý hiệu quả của Go runtime.
• Cơ Chế Giao Tiếp:
  • Goroutine thường sử dụng các cơ chế như Channels để giao tiếp và đồng bộ hóa dữ liệu giữa chúng. Channels giúp tránh các vấn đề như race conditions và deadlock.
• Quyết Định Thực Thi Bởi Go Scheduler:
  • Go runtime có một bộ lập lịch (scheduler) được tích hợp, quyết định cách Goroutine được thực thi trên các thread vật lý của máy tính.

Bản chất của Goroutine là tạo ra một mô hình đồng thời hiệu quả, giảm overhead so với việc sử dụng thread truyền thống và hỗ trợ các cơ chế giao tiếp an toàn và đơn giản giữa các đơn vị thực thi. Điều này giúp Go trở thành một ngôn ngữ mạnh mẽ cho việc xây dựng các hệ thống đa nhiệm và phân tán.

3. Goroutine so với Thread.

Goroutine và Thread là hai khái niệm đồng thời, nhưng chúng có những sự khác biệt quan trọng, đặc biệt là khi nói đến ngôn ngữ lập trình Go (Golang).

• Khởi tạo và Quản lý:
  • Goroutine: Goroutine được quản lý bởi bộ quản lý đồng thời của Go runtime. Khởi tạo một goroutine rất nhẹ nhàng và yêu cầu ít tài nguyên hơn so với việc tạo một thread.
  • Thread: Việc quản lý thread thường phức tạp hơn và tốn kém hơn. Việc tạo và quản lý thread đòi hỏi nhiều tài nguyên hệ thống hơn.
• Hiệu suất và Overhead:
  • Goroutine: Goroutine được quản lý thông qua mô hình đồng thời (concurrent model) của Go, giúp giảm overhead so với việc sử dụng thread truyền thống.
  • Thread: Việc sử dụng thread có thể tạo ra overhead lớn hơn do yêu cầu nhiều tài nguyên hệ thống và đồng bộ hóa.
• Tài Nguyên:
  • Goroutine: Mỗi goroutine yêu cầu một ít tài nguyên hơn so với một thread thông thường. Điều này cho phép chạy hàng ngàn, thậm chí hàng triệu goroutine mà không gây tốn kém nhiều tài nguyên.
  • Thread: Việc chạy hàng nghìn hoặc hàng triệu thread có thể tạo ra một áp lực lớn đối với tài nguyên hệ thống.
• Đồng bộ và Truyền Thông:
  • Goroutine: Goroutine thường sử dụng các kỹ thuật như Channels để đạt được đồng bộ và truyền thông dữ liệu giữa các goroutine một cách an toàn.
  • Thread: Trong lập trình đa luồng truyền thống, sự đồng bộ hóa thường đòi hỏi việc sử dụng các cơ chế như locks, mutex, điều này có thể dẫn đến vấn đề như deadlock và race conditions.
• Ngôn Ngữ Lập Trình:
  • Goroutine: Đặc trưng cho ngôn ngữ Go, goroutine được tích hợp sâu vào ngôn ngữ và runtime của Go.
  • Thread: Threads là một khái niệm chung, có sẵn trong nhiều ngôn ngữ lập trình như C++ và Java.

Như vậy goroutine trong Go được thiết kế để đơn giản hóa việc lập trình đồng thời, giảm overhead, và tận dụng hiệu quả tài nguyên hệ thống. Điều này làm cho việc sử dụng goroutine trở nên linh hoạt và hiệu quả hơn so với việc quản lý thread truyền thống.

4. Cách khai báo một Goroutine.

Trong ngôn ngữ lập trình Go (Golang), bạn có thể khai báo một Goroutine bằng cách sử dụng go trước một hàm hoặc phương thức.

Ví dụ 1 – Dưới đây là cú pháp cơ bản.

package main

import (
	"fmt"
	"time"
)

func main() {
	// Khai báo một Goroutine
	go myGoroutine()

	// Chương trình chính vẫn tiếp tục thực hiện công việc của mình
	for i := 0; i < 3; i++ {
		fmt.Println("Main routine")
		time.Sleep(time.Second)
	}
}

func myGoroutine() {
	// Đoạn code mà Goroutine thực hiện
	for i := 0; i < 3; i++ {
		fmt.Println("Hello from Goroutine")
		time.Sleep(time.Second)
	}
}

Trong ví dụ trên, myGoroutine là một hàm, và chúng ta sử dụng go để khai báo một Goroutine chạy hàm này. Goroutine này sẽ chạy đồng thời với chương trình chính. Cần lưu ý rằng khi hàm myGoroutine hoàn thành việc thực thi, chương trình vẫn có thể tiếp tục chạy.

Lưu ý rằng Goroutine thường được sử dụng để thực hiện các tác vụ đồng thời mà không cần chờ đợi kết quả ngay lập tức. Đối với các tác vụ đồng bộ hóa và thu thập kết quả, bạn có thể sử dụng các cơ chế như Channels để truyền dữ liệu giữa các Goroutine.

Ví dụ 2 – Goroutine được tạo bằng cách sử dụng go trước một hàm hoặc phương thức.

package main

import (
	"fmt"
	"time"
)

func main() {
	// Tạo một goroutine bằng cách sử dụng "go"
	go sayHello()

	// Chương trình chính tiếp tục thực hiện công việc của mình
	for i := 0; i < 3; i++ {
		fmt.Println("Main routine")
		time.Sleep(time.Second)
	}
}

func sayHello() {
	// Goroutine này sẽ chạy đồng thời với chương trình chính
	for i := 0; i < 3; i++ {
		fmt.Println("Hello from goroutine")
		time.Sleep(time.Second)
	}
}

Trong ví dụ trên, goroutine được tạo khi hàm sayHello được gọi bằng cách sử dụng go. Chương trình chính tiếp tục thực hiện vòng lặp của mình trong khi goroutine đang chạy đồng thời, tạo ra một thực tế đồng thời trong chương trình Go.

Ví dụ 3 – Ví dụ thực tế.

Goroutine giúp xử lý đồng thời một cách hiệu quả và là một phần quan trọng của mô hình đồng thời trong ngôn ngữ lập trình Go.

Để thực hiện việc kiểm tra ICMP đồng thời cho tất cả các địa chỉ IP trong danh sách, bạn có thể sử dụng goroutine để thực hiện các công việc kiểm tra mỗi IP một cách độc lập. Dưới đây là một ví dụ về cách bạn có thể sửa đổi mã để thực hiện kiểm tra đồng thời:

package main

import (
	"os/exec"
	"regexp"
	"fmt"
	"sync"
)

func main() {
	// Danh sách các địa chỉ IP cần kiểm tra
	ipAddresses := []string{"8.8.8.1", "8.8.8.2", "8.8.8.3", "8.8.8.4", "8.8.8.5", "8.8.8.6", "8.8.8.7", "8.8.8.8", "8.8.8.9"}

	// Sử dụng WaitGroup để đợi tất cả các goroutine hoàn thành
	var wg sync.WaitGroup

	// Vòng lặp qua từng địa chỉ IP trong danh sách
	for _, ipaddr := range ipAddresses {
		// Tăng đếm cho mỗi goroutine mới
		wg.Add(1)

		// Goroutine để thực hiện kiểm tra cho mỗi IP
		go func(ip string) {
			defer wg.Done()

			// Thực hiện lệnh ping và lấy kết quả đầu ra
			var count string = "1"

			cmd := exec.Command("ping", "-c", count, ip)
			out, err := cmd.CombinedOutput()

			// Kiểm tra lỗi trước khi xử lý đầu ra
			if err != nil {
				fmt.Printf("Error while pinging %s: %s\n", ip, err)
				return
			}

			// Chuyển đổi đầu ra thành chuỗi
			output := string(out)

			// Sử dụng regex để tìm kiếm giá trị "0%" trong đoạn văn bản
			re := regexp.MustCompile(`(\d+)% packet loss`)
			matches := re.FindStringSubmatch(output)

			// Kiểm tra nếu có matches và lấy giá trị tương ứng
			if len(matches) > 1 {
				packetLoss := matches[1]
				fmt.Printf("Check IP: %s, Packet Loss: %s\n", ip, packetLoss)
			} else {
				fmt.Printf("Không tìm thấy thông tin về packet loss cho IP: %s\n", ip)
			}
		}(ipaddr)
	}

	// Đợi cho tất cả các goroutine hoàn thành trước khi kết thúc chương trình
	wg.Wait()
}

Kết quả.

$ go run main.go 
Check IP: 8.8.8.8, Packet Loss: 0
Check IP: 8.8.8.8, Packet Loss: 0
Check IP: zing.vn, Packet Loss: 0
Check IP: wiki.hoanghd.com, Packet Loss: 0
Check IP: google.com, Packet Loss: 0
Error while pinging 8.8.8.5: exit status 1
Error while pinging 8.8.8.2: exit status 1
Error while pinging 8.8.8.1: exit status 1
Error while pinging 8.8.8.3: exit status 1
Error while pinging 8.8.8.6: exit status 1
Error while pinging 8.8.8.7: exit status 1
Error while pinging 8.8.8.9: exit status 1

Trong ví dụ này, mỗi địa chỉ IP được xử lý trong một goroutine riêng biệt, và sync.WaitGroup được sử dụng để đợi cho tất cả các goroutine hoàn thành trước khi kết thúc chương trình. Điều này giúp đảm bảo rằng tất cả các kiểm tra được thực hiện đồng thời.