21/11/2026 00:00น.

Rust vs Go: เทียบเรื่อง Memory, Error Handling และ Concurrency สำหรับคนที่เขียน Go อยู่แล้ว
#Rust
#Golang
#Rust vs Go
#Garbage Collector
#Concurrency
#Goroutine
เวลามีน้องๆ ที่เขียน Go อยู่แล้วถามทีมเราว่า "อยากลอง Rust บ้าง ต้องเริ่มจากตรงไหน และมันต่างจาก Go มากแค่ไหน" คำตอบที่เราตอบบ่อยที่สุดคือ ภาษาทั้งสองคอมไพล์เป็นโปรแกรมที่รันได้ตรงๆ เหมือนกัน แต่ปรัชญาตอนที่ต้องตัดสินใจเรื่องสำคัญสามเรื่องต่างกันมาก คือใครเป็นคนดูแล memory, error ถูกบังคับให้จัดการแค่ไหน และ concurrency ถูกออกแบบให้ปลอดภัยด้วยวิธีไหน
วันนี้ Superdev Academy จะพาเทียบสามเรื่องนี้ทีละข้อ โดยยึดเอกสารทางการของแต่ละภาษาเป็นหลัก ไม่อ้างตัวเลข benchmark ที่ผลขึ้นกับงานและเครื่องที่ใช้ทดสอบ และท้ายบทความจะมีแนวทางเลือกตามลักษณะงานที่เป็นข้อสรุปของทีมเราเอง ซึ่งเป็นความเห็น ไม่ใช่ข้อเท็จจริงจากเอกสาร เราจะแยกให้ชัดตอนนั้นครับ
เรื่องที่ 1: ใครเป็นคนดูแล memory?
Go: ให้ Garbage Collector จัดการ
Go ให้ runtime ตามเก็บ memory ที่ไม่ใช้แล้วให้ คู่มือ Garbage Collector ของ Go (A Guide to the Go Garbage Collector) อธิบายว่า GC ของ Go ใช้เทคนิค mark-sweep เป็น GC แบบ non-moving และทำงานส่วนใหญ่พร้อมกับตัวแอปพลิเคชัน ไม่ได้หยุดโปรแกรมทั้งหมดตลอด (not fully stop-the-world) ผลคือเราแทบไม่ต้องคิดเรื่อง free memory เลย แลกกับ CPU และ memory ที่ runtime ใช้ในการเก็บกวาด
คู่มือเดียวกันบอกว่ามีปุ่มปรับอยู่สองตัว ตัวแรกคือ GOGC ซึ่งกำหนดเป้าหมายขนาด heap ตามสูตร live heap บวก GC roots แล้วคูณ GOGC หารร้อย และมีผลแบบตรงไปตรงมาคือ การเพิ่ม GOGC เป็นสองเท่าจะเพิ่ม memory overhead ของ heap เป็นสองเท่า และลดต้นทุน CPU ของ GC ลงประมาณครึ่งหนึ่ง ตัวที่สองคือ GOMEMLIMIT ที่เริ่มมีใน Go 1.19 เป็น soft limit ของ memory ทั้งหมดที่ runtime ใช้ได้ คู่มือเตือนว่าถ้าตั้งต่ำเกินไป GC จะรันถี่จนโปรแกรมชะงัก (thrashing) runtime จึงจำกัดสัดส่วน CPU ที่ GC ใช้ไว้ราว 50% และยอมให้ memory เกิน limit เพื่อไม่ให้เกิดอาการนั้น
Rust: ไม่มี GC ใช้ Ownership ตัดสินตอน compile
Rust ไม่มี garbage collector และไม่ให้เรา free เองด้วยมือ แต่ใช้กฎ Ownership ที่คอมไพเลอร์ตรวจตอน compile ว่าค่าแต่ละตัวมีเจ้าของคนเดียว และเมื่อเจ้าของหลุด scope ค่านั้นก็ถูกคืนทันที ถ้าสนใจรายละเอียดของกฎนี้ทีมเรามีบทความOwnership ของ Rustอธิบายไว้ สิ่งที่ต้องแลกคือเราต้องเข้าใจกฎการยืมค่าและ lifetime ตั้งแต่วันแรก คอมไพเลอร์จะปฏิเสธโค้ดที่ละเมิดกฎ แม้ว่าโค้ดนั้นอาจจะรันได้ถูกต้องในบางกรณีก็ตาม
ผลต่างที่เห็นในทางปฏิบัติคือ ใน Go คำถามเรื่อง memory มักมาในรูป ปรับ GOGC หรือ GOMEMLIMIT อย่างไรให้พอดี ส่วนใน Rust คำถามย้ายไปอยู่ที่ตอนเขียนโค้ด คือ ค่านี้ใครเป็นเจ้าของ และใครยืมได้นานแค่ไหน ทั้งสองแบบมีต้นทุน เพียงแต่จ่ายคนละเวลา
เรื่องที่ 2: Error ถูกบังคับให้จัดการแค่ไหน?
ทั้งสองภาษาไม่ใช้ exception เป็นกลไกหลักของ error ทั่วไป ทว่าวิธีที่ภาษาบังคับให้เรามองเห็น error ต่างกัน
Go ถือ error เป็นค่าธรรมดา บทความ Error handling and Go บนบล็อกทางการอธิบายว่า error คือ interface ที่มี method เดียวคือ Error() string ฟังก์ชันที่ผิดพลาดจะคืน error ที่ไม่เป็น nil และผู้เรียกตรวจด้วยรูปแบบ if err != nil ที่ทุกคนที่เขียน Go คุ้นเคย
data, err := os.ReadFile("config.txt")
if err != nil {
return err
}
// ใช้ data ต่อได้ฝั่ง Rust หนังสือทางการแยก error เป็นสองประเภทชัดเจน คือ recoverable error ที่ใช้ type Result<T, E> และ unrecoverable error ที่ใช้มาโคร panic! หนังสือเขียนไว้ว่า Rust ไม่มี exception และในหลายกรณี Rust บังคับให้เรายอมรับความเป็นไปได้ที่จะเกิด error และทำอะไรสักอย่างก่อนที่โค้ดจะ compile ผ่าน ตัวอย่างที่เทียบกับโค้ด Go ข้างบนได้ตรงๆ คือ
use std::fs;
use std::io;
fn read_config() -> Result<String, io::Error> {
let data = fs::read_to_string("config.txt")?;
Ok(data)
}เครื่องหมาย ? ทำหน้าที่คล้ายบล็อก if err != nil { return err } ของ Go ถ้าผลเป็น Ok ก็ได้ค่าข้างในและไปต่อ ถ้าเป็น Err ก็ return error นั้นออกจากฟังก์ชันทันที จุดต่างอยู่ที่ type system เพราะ Result เป็น Enum ที่ match ต้องจัดการครบทุกกรณี และค่า T ที่อยู่ข้างในเข้าถึงไม่ได้จนกว่าจะผ่านการตรวจ ส่วนใน Go คอมไพเลอร์ไม่ได้ขัดขวางถ้าเราทิ้งตัวแปร err ไว้โดยไม่ตรวจ (ผ่านการใช้ _ หรือเรียกฟังก์ชันโดยไม่รับค่า) ซึ่งเครื่องมือวิเคราะห์โค้ดช่วยจับได้ แต่ไม่ใช่กฎบังคับของภาษา
เรื่องที่ 3: Concurrency ออกแบบมาแตกต่างกันอย่างไร?
Go: goroutine และ channel เป็นของพื้นฐานในภาษา
Effective Go นิยาม goroutine ว่าเป็นฟังก์ชันที่ทำงานพร้อมกับ goroutine อื่นใน address space เดียวกัน มีน้ำหนักเบา ต้นทุนไม่ต่างจากการจัดสรร stack มากนัก โดย stack เริ่มต้นเล็กและขยายตามต้องการ และ goroutine ถูก multiplex ลงบน OS thread หลายตัว เมื่อตัวหนึ่งบล็อกเพราะรอ I/O ตัวอื่นก็ทำงานต่อได้ การเริ่ม goroutine ใช้แค่เติม go นำหน้าการเรียกฟังก์ชัน
ch := make(chan string)
go func() { ch <- "hi" }()
fmt.Println("Got:", <-ch)เอกสารเดียวกันมีคติประจำภาษาว่า "Do not communicate by sharing memory; instead, share memory by communicating." แต่ก็ย้ำว่าแนวทางนี้ "can be taken too far" เช่น การนับ reference อาจเหมาะกับการครอบ mutex ไว้รอบตัวแปรจำนวนเต็มมากกว่า (Effective Go เขียนมาตั้งแต่ Go รุ่นปี 2009 และไม่ได้อัปเดตสม่ำเสมอ แต่หลักการเรื่องนี้ยังใช้ได้)
Rust: ใช้ type system ตรวจ concurrency ตอน compile
บท Fearless Concurrency ของหนังสือ Rust ระบุว่าทีมงานพบว่า ownership และ type system เป็นชุดเครื่องมือที่ช่วยจัดการทั้งปัญหา memory safety และปัญหา concurrency ผลคือ concurrency error จำนวนมากกลายเป็น compile-time error แทนที่จะเป็น runtime error โค้ดที่ผิดจะไม่ยอม compile พร้อมข้อความบอกปัญหา ตัวอย่างการส่งข้อความระหว่าง thread ผ่าน channel
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
tx.send(String::from("hi")).unwrap();
});
let received = rx.recv().unwrap();
println!("Got: {received}");
}หนังสือ Rust ยังเปิดทางให้เลือกโมเดลที่เหมาะกับปัญหา ทั้ง thread, message passing ด้วย channel, shared state และ trait Send กับ Sync ที่ขยายการรับประกันไปถึง type ที่เราเขียนเอง จุดที่คนมาจาก Go มักเจอเป็นอันดับแรกคือ async ซึ่งหนังสือ Rust อธิบายว่าการเขียนโค้ด async ใน Rust ต้องใช้ crate ของบุคคลที่สามที่ implement asynchronous runtime เพื่อจัดการและประสานการทำงาน ต่างจาก Go ที่ goroutine scheduler เป็นส่วนหนึ่งของตัวภาษาและ runtime อยู่แล้ว
นี่คือเหตุผลที่คนมักบอกว่าเขียน concurrent code ด้วย Go ง่ายกว่าในช่วงแรก ส่วน Rust จ่ายความซับซ้อนล่วงหน้าเพื่อให้คอมไพเลอร์ช่วยตรวจ เรามองว่าเป็นข้อแลกเปลี่ยนที่ต้องชั่งตามงาน ไม่ใช่ว่าฝั่งใดชนะขาด
แล้วควรเลือกภาษาไหน? (ข้อสรุปของทีมเรา)
ส่วนนี้เป็นความเห็นของทีมเรา ไม่ได้มาจากเอกสารของภาษาใด และไม่มีการวัดผลรองรับ ใช้ประกอบการตัดสินใจเท่านั้นครับ
ถ้างานของคุณคือ API หรือบริการ backend ทั่วไปที่ทีมต้องส่งมอบเร็ว มีคนเข้าออกทีมบ่อย และความหน่วงที่ GC เพิ่มเข้ามายอมรับได้ Go มักเป็นตัวเลือกที่ตอบโจทย์ได้ตรงกว่า
ถ้างานของคุณต้องการควบคุมการใช้ memory อย่างละเอียด ต้องการหลีกเลี่ยง GC ในส่วนที่ไวต่อเวลา หรืออยากให้คอมไพเลอร์ตรวจ concurrency และ error ให้เข้มกว่านั้น Rust เป็นตัวเลือกที่น่าพิจารณา แลกกับเวลาเรียนรู้ที่นานกว่า
ถ้าทีมมีทั้งสองแบบ การใช้ Go ในส่วนบริการทั่วไปและ Rust ในส่วนที่เฉพาะเจาะจงเป็นรูปแบบที่ทำได้ แต่ต้องคิดถึงต้นทุนการดูแลสองภาษาด้วย
ส่วนถ้าคุณยังไม่แน่ใจว่าอยากเริ่ม Rust จริงหรือไม่ ลองอ่านเหตุผลในบทความทำไมต้อง Rust หรือจะย้อนไปดูฝั่ง Go ในซีรีส์Golang The Seriesเพื่อเทียบกับสิ่งที่คุณใช้อยู่ก็ได้เช่นกัน
สรุป: ทั้งสองภาษาจ่ายราคาคนละเวลา
Go ให้ runtime ดูแล memory และให้เรามองเห็น error เป็นค่าที่ต้องตรวจเอง พร้อม goroutine ที่ใช้งานง่ายตั้งแต่วันแรก ส่วน Rust ไม่มี GC ใช้ Ownership ตัดสินตอน compile บังคับให้เรายอมรับ error ผ่าน Result และใช้ type system ตรวจ concurrency ล่วงหน้า แลกกับการต้องเรียนรู้กฎมากกว่าในช่วงต้น
คำถามที่ควรถามก่อนเลือกจึงไม่ใช่ว่าภาษาไหนเก่งกว่า แต่เป็นว่างานของคุณเจ็บตรงไหนมากกว่ากัน ระหว่างความหน่วงและ memory ที่ GC ใช้ กับเวลาที่ทีมต้องเสียไปกับการเรียนรู้กฎของคอมไพเลอร์ ถ้ายังตอบไม่ได้ ลองเขียนบริการเล็กๆ ตัวเดียวกันด้วยทั้งสองภาษาในวันหยุดสักวัน แล้วดูว่าตอนไหนที่คุณหงุดหงิดน้อยกว่ากัน คำตอบนั้นมักบอกอะไรได้มากกว่าตารางเปรียบเทียบใดๆ ครับ
🎯 ติดตามความรู้สาย Dev ได้ที่ Superdev Academy:
🔵 Facebook: Superdev Academy Thailand
🎬 YouTube: Superdev Academy Channel
📸 Instagram: @superdevacademy
🎬 TikTok: @superdevacademy
FAQ: คำถามที่พบบ่อยเกี่ยวกับบทความนี้
รวมคำถามและคำตอบที่ช่วยให้คุณเข้าใจเนื้อหาในบทความนี้ได้ดียิ่งขึ้น