Concurrency หรือการดำเนินการพร้อมกัน (คอนเคอร์เรนซี) เป็นหนึ่งในคุณสมบัติที่เด่นชัดที่สุดของการเขียนโปรแกรมด้วยภาษา Go (หรือ Golang) ซึ่งถูกออกแบบมาเพื่อรองรับการทำงานหลายๆ อย่างพร้อมกันอย่างมีประสิทธิภาพ เมื่อพูดถึงการจัดการกับเวลาและเหตุการณ์ในแอปพลิเคชันที่ทำงานพร้อมกันใน Go เรามีเครื่องมือที่ชื่อว่า `time.Timer` และ `time.Ticker` ที่ช่วยในการจัดการเวลาในรูปแบบที่หลากหลายและทรงพลัง
ภาษา Go สนับสนุนการเขียนโปรแกรมแบบ Concurrent เป็นอย่างดี ด้วยการใช้ goroutines ซึ่งเป็นความสามารถที่ให้ผู้พัฒนาสามารถสร้างโปรเซสย่อย (หรือ Timely Concurrency) ที่สามารถทำงานไปพร้อมๆ กันนั้นเอง การใช้ goroutines มักจะมาคู่กับ channels ที่ใช้ในการสื่อสารระหว่าง goroutines ซึ่งช่วยให้การจัดการ concurrency เป็นเรื่องง่ายกว่าเดิม
`time.Timer` เป็นโครงสร้างข้อมูลที่ช่วยให้เราสามารถสร้างเหตุการณ์ที่จะทำงานในอนาคตได้ ใช้งานได้ง่ายผ่านการสร้าง Timer หลังจากที่เวลาที่กำหนดได้ผ่านไปแล้ว Timer จะปล่อยสัญญาณ (signal) ซึ่งสามารถใช้งานร่วมกับ channel ได้เป็นอย่างดี
ตัวอย่างการใช้งาน time.Timer
package main
import (
"fmt"
"time"
)
func main() {
timer := time.NewTimer(3 * time.Second)
fmt.Println("Starting timer...")
<-timer.C
fmt.Println("Timer expired!")
}
ในตัวอย่างนี้ เราสร้าง timer ที่จะรอเป็นเวลา 3 วินาทีก่อนที่จะสิ้นสุด (expire) และพิมพ์ข้อความ `Timer expired!` ออกมาทาง console
`time.Ticker` เป็นอีกโครงสร้างที่มีประโยชน์เมื่อคุณต้องการให้เหตุการณ์เกิดขึ้นซ้ำ ๆ ทุกๆ ระยะเวลาที่กำหนด Ticker จะส่งสัญญาณทุกครั้งที่เวลาที่กำหนดผ่านมา สามารถนำไปใช้งานที่ต้องการให้เกิดการทำงานบางอย่างเป็นระยะๆ เช่น การอัพเดตข้อมูล
ตัวอย่างการใช้งาน time.Ticker
package main
import (
"fmt"
"time"
)
func main() {
ticker := time.NewTicker(1 * time.Second)
quit := make(chan struct{})
go func() {
for {
select {
case <-ticker.C:
fmt.Println("Tick at", time.Now())
case <-quit:
ticker.Stop()
return
}
}
}()
time.Sleep(5 * time.Second)
close(quit)
fmt.Println("Ticker stopped")
}
ในตัวอย่างนี้ Ticker จะพิมพ์ข้อความว่า `Tick at` และแสดงเวลาปัจจุบันในทุกๆ วินาที และจะหยุดทำงานหลังจากที่ผ่านไป 5 วินาที ผ่านการใช้ channel `quit` เพื่อส่งสัญญาณหยุดการทำงาน
ในแอปพลิเคชันที่ต้องการการทำงานพร้อมกัน เช่น การตรวจสอบระบบ การอัพเดตสถานะสด และการจัดการงานแบบตารางเวลา `time.Timer` และ `time.Ticker` เป็นเครื่องมือที่มีประโยชน์อย่างยิ่ง แต่การใช้ goroutines ควรทำอย่างระมัดระวังเพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ (memory leak) และ deadlocks ซึ่งอาจเกิดขึ้นได้เมื่อเราไม่ได้ปิด channel หรือ goroutines อย่างถูกต้อง
ข้อควรระวัง:
- การใช้งาน Ticker และ Timer ควรแน่ใจว่ามีการปิดใช้งานเมื่อไม่ต้องการใช้งานอีกต่อไป มิฉะนั้นอาจเกิดการบริโภคหน่วยความจำโดยไม่จำเป็น
- ตรวจสอบการจัดการ channel และ goroutine อย่างดีเพื่อประสิทธิผลที่จะทำให้โปรแกรมทำงานได้อย่างราบรื่น
Go เป็นภาษาที่มีความพิเศษอยู่ที่การสนับสนุนการเขียนโปรแกรมแบบ concurrent อย่างแท้จริง ซึ่งเหมาะกับยุคสมัยที่ขับเคลื่อนด้วยเทคโนโลยีที่ต้องการความเร็วและการทำงานแบบพร้อมกันเสมอ เรียนรู้การเขียนโปรแกรมด้วย Go และสามารถวางใจได้ว่าเครื่องมือที่มีให้จะช่วยให้คุณเขียนโค้ดที่มีประสิทธิภาพสูงสุด หากคุณสนใจในเรื่องของ concurrency และ Go เป็นตัวเลือกที่น่าสนใจ ก็ขอแนะนำให้ลองศึกษาเพิ่มเติมบางทีอาจจะลองเข้าร่วมหลักสูตรที่ตรงกับความสนใจดูนะครับ!
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/
Tag ที่น่าสนใจ: java c# vb.net python c c++ machine_learning web database oop cloud aws ios android
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM
Copyright (c) 2013 expert-programming-tutor.com. All rights reserved. | 085-350-7540 | 084-88-00-255 | ntprintf@gmail.com