JS2GO EP.29 การจัดการ Signal และ Process ใน Go กับ JavaScript

การจัดการ Signal และ Process เป็นหัวใจสำคัญสำหรับการควบคุม lifecycle ของแอปพลิเคชัน ไม่ว่าจะเป็นการหยุด server อย่างปลอดภัย, การ restart process, หรือการจัดการ background jobs ในบทความนี้เราจะเปรียบเทียบการจัดการ Signal และ Process ใน Go และ JavaScript (Node.js) พร้อมตัวอย่างโค้ดและแนวทางปฏิบัติที่เหมาะสม

1. การจัดการ Process และ Signal ใน Node.js (JavaScript)

Node.js มี module process และ child_process สำหรับจัดการ process และ signal

จับ Signal เช่น SIGINT หรือ SIGTERM

process.on('SIGINT', () => {
  console.log('Received SIGINT. Exiting gracefully...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.log('Received SIGTERM. Cleaning up...');
  process.exit(0);
});

สร้าง Child Process

const { spawn } = require('child_process');

const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});

ls.on('close', (code) => {
  console.log(`Child process exited with code ${code}`);
});

ข้อดี Node.js

✔️ จับ signal และควบคุม process ได้ง่าย
✔️ รองรับ asynchronous process และ event-driven pattern

ข้อจำกัด

⚠️ ต้องใช้ event listener และ callback
⚠️ ต้องระวัง zombie process เมื่อ spawn child process

2. การจัดการ Process และ Signal ใน Go

Go มี package os และ os/signal สำหรับจัดการ process และ signal

จับ Signal เช่น SIGINT หรือ SIGTERM

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    sigs := make(chan os.Signal, 1)
    done := make(chan bool, 1)

    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        sig := <-sigs
        fmt.Println()
        fmt.Println("Received signal:", sig)
        fmt.Println("Cleaning up and exiting...")
        done <- true
    }()

    fmt.Println("Waiting for signal...")
    <-done
    fmt.Println("Exiting program")
}

สร้าง Child Process

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls", "-lh", "/usr")
    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Println("Error:", err)
    }
    fmt.Println(string(output))
}

ข้อดี Go

✔️ Type-safe และ error handling ชัดเจน
✔️ รองรับ signal และ process control สำหรับ backend server
✔️ สามารถจัดการ lifecycle ของ process ได้ปลอดภัย

ข้อจำกัด

⚠️ Syntax verbose กว่า Node.js
⚠️ ต้องสร้าง channel และ goroutine สำหรับ signal

3. แนวทางปฏิบัติที่เหมาะสม

✔️ จับ Signal อย่างถูกต้อง เพื่อ shutdown gracefully

Node.js: process.on('SIGTERM')
Go: signal.Notify + channel + goroutine

✔️ จัดการ Child Process อย่างระมัดระวัง

ใช้ stdout/stderr เพื่อตรวจสอบ output
รอ process เสร็จ (wait / on('close'))

✔️ Logging และ Cleanup

บันทึก event และ clean resources เช่น close DB, stop server
ป้องกัน zombie process หรือ memory leak

4. สรุปเปรียบเทียบ Signal & Process JavaScript vs Go

Feature	JavaScript (Node.js)	Go
Capture Signals	process.on('SIGINT')	signal.Notify + channel
Child Process	child_process.spawn / exec	os/exec.Command
Async Handling	Event-driven / callback	Goroutine + channel
Logging	console / winston	fmt / logrus / zap
Error Handling	Callback / try/catch	Return error + type-safe
Graceful Shutdown	Supported	Supported

คำแนะนำ

✔️ Web server / event-driven apps → Node.js เหมาะสำหรับ rapid development
✔️ Backend service / concurrent / type-safe → Go เหมาะสำหรับ production-critical system

ตอนต่อไป

ใน EP.30 ของซีรีส์ JS2GO เราจะพาคุณไปเรียนรู้ การทำงานกับ HTTP Requests และ Responses: JavaScript (Fetch/Express) vs Go (net/http) เพื่อเปรียบเทียบการสร้าง API และการจัดการ HTTP อย่างมืออาชีพ

อ่านบทความ Series อื่นๆ

🔵 Facebook: https://www.facebook.com/superdev.academy.th

🔴 YouTube : Superdev Academy

📸 Instagram: Superdev Academy

🎬 TikTok: https://www.tiktok.com/@superdevacademy?lang=th-TH

🌐 Website: https://www.superdevacademy.com/