Python asyncio Automation Script — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog
Python asyncio Automation Script คืออะไร — แนวคิดพื้นฐานที่ต้องเข้าใจก่อนเริ่มเขียน
สวัสดีครับ อ.บอม คนเดิมจาก SiamCafe Blog วันนี้ผมจะพาทุกคนมาลุยเรื่อง Python asyncio Automation Script แบบเจาะลึกจริงจัง จากประสบการณ์ 13
ปีที่ผมใช้ภาษา Python เขียนสคริปต์อัตโนมัติทั้งงานเทรด งานดึงข้อมูล และงานระบบหลังบ้าน ผมขอสรุปให้ฟังก่อนว่า asyncio คืออะไร
asyncio คือไลบรารีมาตรฐานของ Python ที่ใช้เขียนโค้ดแบบ asynchronous หรือการทำงานพร้อมกันหลายงานโดยไม่ต้องรอแต่ละงานเสร็จทีละอัน เหมาะกับงานที่ต้องรอคอยบ่อย ๆ เช่น การเรียก API การอ่านไฟล์ หรือการสอบถามฐานข้อมูล เพราะระหว่างที่รองานหนึ่ง เราสามารถสลับไปทำงานอื่นได้ทันที ทำให้สคริปต์เร็วขึ้นหลายเท่าโดยไม่ต้องเพิ่มเครื่อง
ต่างจากการทำงานแบบมัลติเธรดตรงที่ asyncio ใช้เธรดเดียวแต่สลับงานอย่างฉลาด ผ่านคำสั่ง await และ event loop ซึ่งเป็นหัวใจของระบบทั้งหมด เมื่อโค้ดเจอคำสั่ง await มันจะปล่อยตัวเองไปทำงานอื่นก่อน แล้วกลับมาเมื่องานที่รอเสร็จแล้ว
ถ้าใครเขียนสคริปต์อัตโนมัติแบบเดิม ๆ ที่รันทีละขั้นตอน แล้วรู้สึกว่ามันเหน็ดเหนื่อยกับการรอนาน ๆ asyncio คือคำตอบที่จะเปลี่ยนวิธีทำงานของคุณไปตลอด ยกตัวอย่างงานที่ผมใช้จริง เช่น การดึงราคาจากคู่เงิน 50 คู่พร้อมกัน ถ้าทำแบบรันตามลำดับจะใช้เวลาเกือบนาที แต่พอใช้ asyncio ใช้เวลาไม่ถึง 3 วินาที ความต่างขนาดนี้คือเหตุผลที่ทุกคนควรเรียนรู้
ก่อนจะลงมือ ต้องเข้าใจคำศัพท์หลัก 4 คำนี้ก่อน
- Coroutine — ฟังก์ชันที่เขียนด้วย async def และรองรับการหยุด/กลับมาทำงานได้
- Event Loop — ผู้จัดการคิวงาน คอยสลับ coroutine ตามสถานะการรอ
- Task — coroutine ที่ถูกส่งไปรันใน event loop แล้ว
- Future — ตัวแทนผลลัพธ์ที่ยังไม่เสร็จ
เมื่อเข้าใจสี่คำนี้ การต่อยอดไปยังสคริปต์ระดับโปรดักชันจะง่ายขึ้นมาก ในหัวข้อถัดไปเราจะเริ่มเขียนโค้ดจริงกันเลย
มาเริ่มจากการเขียนสคริปต์ง่าย ๆ ที่ดาวน์โหลดข้อมูลจากหลายแหล่งพร้อมกัน ซึ่งเป็นงานอัตโนมัติที่คนใช้ asyncio บ่อยที่สุด
โค้ดชุดนี้ผมตัดมาให้เห็นโครงสร้างหลัก นำไปปรับใช้ได้ทันที
มาเริ่มจากการเขียนสคริปต์ง่าย ๆ ที่ดาวน์โหลดข้อมูลจากหลายแหล่งพร้อมกัน ซึ่งเป็นงานอัตโนมัติที่คนใช้ asyncio บ่อยที่สุด โค้ดชุดนี้ผมตัดมาให้เห็นโครงสร้างหลัก นำไปปรับใช้ได้ทันที
import asyncio import aiohttp
async def ดึงข้อมูล(session, url): try: async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp: data = await resp.json() return {"url": url, "status": "สำเร็จ", "data": data} except Exception as e: return {"url": url, "status": "ล้มเหลว", "error": str(e)}
async def main(): urls = [ "https://api.example.com/rates/eurusd", "https://api.example.com/rates/gbpusd", "https://api.example.com/news/latest", ] async with aiohttp.ClientSession() as session: tasks = [ดึงข้อมูล(session, u) for u in urls] results = await asyncio.gather(*tasks) for r in results: print(r["status"], r["url"])
asyncio.run(main())
สิ่งสำคัญที่ต้องอธิบาย ตัวแรกคือ asyncio.gather ซึ่งเป็นคำสั่งที่สั่งให้งานทุกชิ้นรันพร้อมกัน ไม่ใช่รันทีละอัน สองคือการใช้ session เดียวร่วมกันทั้งหมด เพราะการสร้างการเชื่อมต่อใหม่ทุกครั้งสิ้นเปลืองมาก สามคือการครอบด้วย try/except ในแต่ละงาน เพื่อไม่ให้งานหนึ่งล้มแล้วดึงงานที่เหลือลงไปด้วย
ข้อผิดพลาดที่ผมเห็นนักเขียนใหม่ทำบ่อยที่สุดมีสามข้อ หนึ่ง ลืม await ทำให้ได้ coroutine object แต่โค้ดไม่รันเลย สอง ใช้คำสั่ง sleep ปกติแทน asyncio.sleep ทำให้ทั้ง event loop ค้าง สาม ใช้ไลบรารีที่ไม่รองรับ async เช่น requests ซึ่งจะบล็อกการทำงานทั้งหมด ต้องเปลี่ยนเป็น aiohttp หรือ httpx แทน
ในงานจริง ๆ ผมมักเพิ่มระบบรีทรายเมื่อล้มเหลว ด้วยการครอบด้วยลูปลองใหม่ 3 ครั้งพร้อมหน่วงเวลาเพิ่มขึ้นทีละเท่า และใช้ asyncio.Semaphore จำกัดจำนวนงานพร้อมกันไม่ให้เยอะเกินไป เพราะถ้ายิง request ไปหลายพันพร้อมกัน เซิร์ฟเวอร์ปลายทางจะบล็อกเราทิ้งทันที
สคริปต์ที่รันบนเครื่องตัวเองกับสคริปต์ที่รันเป็นระบบจริงต่างกันคนละเรื่อง ในโลกจริง งานอาจล้ม อินเทอร์เน็ตหลุด เซิร์ฟเวอร์ปลายทางตอบช้า
ระบบต้องถูกปิดเพื่ออัปเดต ถ้าเขียนแบบห่วน ๆ ข้อมูลจะเสียหาย ผมเรียนรู้ข้อนี้ด้วยค่าใช้จ่ายจริงตอนสคริปต์จัดการคำสั่งเทรดพังกลางคืนโดยไม่มีใครรู้
โครงสร้างโค้ดระดับโปรดักชัน — จัดการข้อผิดพลาด บันทึกเหตุการณ์ และปิดตัวอย่างปลอดภัย
สคริปต์ที่รันบนเครื่องตัวเองกับสคริปต์ที่รันเป็นระบบจริงต่างกันคนละเรื่อง ในโลกจริง งานอาจล้ม อินเทอร์เน็ตหลุด เซิร์ฟเวอร์ปลายทางตอบช้า ระบบต้องถูกปิดเพื่ออัปเดต ถ้าเขียนแบบห่วน ๆ ข้อมูลจะเสียหาย ผมเรียนรู้ข้อนี้ด้วยค่าใช้จ่ายจริงตอนสคริปต์จัดการคำสั่งเทรดพังกลางคืนโดยไม่มีใครรู้
หัวใจของโค้ดระดับโปรดักชันมีสี่องค์ประกอบ
อย่างแรก การจัดการข้อผิดพลาดแบบแยกงาน ใช้ asyncio.gather กับพารามิเตอร์ return_exceptions=True เพื่อให้งานที่ล้มไม่ทำให้งานอื่นหยุด แล้วค่อยตรวจผลทีละชิ้นในภายหลัง อย่างสอง ระบบบันทึกเหตุการณ์ที่เขียนแบบไม่บล็อก ใช้ไลบรารี aiologger หรือบันทึกลงไฟล์แบบแยกเธรด เพื่อให้เห็นว่ากิจกรรมไหนเกิดขึ้นเมื่อไหร่ อย่างสาม การปิดตัวอย่างปลอดภัย ผ่านสัญญาณระบบดังนี้
import asyncio import signal import logging
logger = logging.getLogger("automation")
async def worker(queue: asyncio.Queue, stop_event: asyncio.Event): while not stopevent.isset(): try: job = await asyncio.wait_for(queue.get(), timeout=1.0) except asyncio.TimeoutError: continue try: await ประมวลผลงาน(job) except Exception: logger.exception("งานล้มเหลว: %s", job) finally: queue.task_done()
async def main(): stop_event = asyncio.Event() loop = asyncio.getrunningloop()
def จัดการสัญญาณ(): logger.info("ได้รับสัญญาณปิดระบบ เริ่มการปิดอย่างปลอดภัย") stop_event.set()
for sig in (signal.SIGTERM, signal.SIGINT): loop.addsignalhandler(sig, จัดการสัญญาณ)
queue = asyncio.Queue(maxsize=1000) workers = [asyncio.createtask(worker(queue, stopevent)) for _ in range(5)]
await queue.join() for w in workers: w.cancel()
asyncio.run(main())
โครงสร้างนี้ใช้คิวงานแบบ asyncio.Queue แทนการยิงงานพร้อมกันหมด ซึ่งควบคุมภาระได้ดีกว่ามาก มีจำนวนผู้ทำงานแน่นอน 5 ตัว ดึงงานจากคิวทีละชิ้น เมื่อได้สัญญาณปิดระบบ มันจะทำงานที่ค้างให้เสร็จก่อนแล้วค่อยหยุด เรียกว่าการปิดอย่างปลอดภัย
เขียนสคริปต์ให้รันได้ง่าย แต่เขียนให้มันเร็วและเสถียรนั้นคนละเรื่องกันจริง ๆ
ในหัวข้อนี้ผมจะแชร์เทคนิคที่ใช้จริงตอนปรับสคริปต์รวบรวมข้อมูลราคาให้เร็วขึ้นจาก 40 วินาที เหลือ 2 วินาทีครับ
พอโครงสร้างแน่นแล้ว ปัญหาถัดไปคือความเร็ว ในหัวข้อถัดไปเราจะดูเทคนิคปรับปรุงประสิทธิภาพแบบจริงจัง
เทคนิคปรับปรุงประสิทธิภาพ — ทำให้สคริปต์เร็วขึ้นและเสถียรขึ้น
เขียนสคริปต์ให้รันได้ง่าย แต่เขียนให้มันเร็วและเสถียรนั้นคนละเรื่องกันจริง ๆ ในหัวข้อนี้ผมจะแชร์เทคนิคที่ใช้จริงตอนปรับสคริปต์รวบรวมข้อมูลราคาให้เร็วขึ้นจาก 40 วินาที เหลือ 2 วินาทีครับ
เทคนิคแรกและสำคัญที่สุดคือการจำกัดการทำงานพร้อมกันด้วย Semaphore หลายคนคิดว่ายิงพร้อมกัน 1000 งานคือเร็วที่สุด แต่ความจริงคือเซิร์ฟเวอร์ปลายทางจะเริ่มปฏิเสธหรือช้าลง และเครื่องเราเองก็กินหน่วยความจำโดยไม่จำเป็น จำกัดที่ประมาณ 10 ถึง 30 งานพร้อมกันมักเป็นจุดที่ดีที่สุด
sem = asyncio.Semaphore(20)
async def ดึงแบบจำกัด(session, url): async with sem: return await ดึงข้อมูล(session, url)
เทคนิคที่สองคือการใช้แคช ข้อมูลที่เปลี่ยนไม่บ่อยไม่ควรดึงซ้ำ ผมใช้ aiosqlite เก็บผลลัพธ์ไว้พร้อมเวลาหมดอายุ ดึงใหม่เฉพาะเมื่อเกินกำหนด ประหยัดเวลาและปริมาณการใช้งานได้มหาศาล
เทคนิคที่สามคือการเร่งความเร็วส่วนที่ asyncio ช่วยไม่ได้ งานประมวลผลหนัก เช่น การคำนวณตัวชี้วัดทางสถิติ จะบล็อก event loop ทั้งหมด เพราะ asyncio เหมาะกับงานรอ ไม่ใช่งานคำนวณ วิธีแก้คือส่งงานพวกนี้ไปทำในเธรดหรือกระบวนการแยกด้วย asyncio.tothread หรือ loop.runin_executor
result = await asyncio.to_thread(คำนวณอินดิเคเตอร์, ข้อมูลราคา)
เทคนิคที่สี่คือการรวมการเรียกข้อมูล ถ้า API ปลายทางรองรับการขอหลายรายการในคำขอเดียว ให้รวมงานย่อยส่งไปทีเดียว ลดจำนวนคำขอลงได้หลายสิบเท่า และเทคนิคสุดท้ายคือการมอนิเตอร์ เพิ่มตัวจับเวลางานแต่ละขั้น บันทึกลงไฟล์ เพื่อให้รู้ว่าขวดคอในจุดไหน อย่าปรับปรุงโดยไม่วัด
ตารางด้านล่างสรุปเทคนิคกับผลที่คาดหวังไว้ใช้อ้างอิงได้ครับ
| เทคนิค | ใช้เมื่อไหร่ | ผลที่คาดหวัง |
|---|---|---|
| Semaphore จำกัดงานพร้อมกัน | ยิงคำขอจำนวนมาก | เสถียรขึ้น ลดการถูกบล็อก |
| แคชผลลัพธ์ | ข้อมูลไม่เปลี่ยนบ่อย | ลดเวลาและปริมาณคำขอ 50-90% |
สคริปต์ที่ดีที่สุดในโลกก็ไร้ค่าถ้ารันไม่ได้เพราะเครื่องปิดหรือกระบวนการดับเฉย ๆ ในหัวข้อนี้ผมจะอธิบายวิธีติดตั้งสคริปต์ asyncio
บนเซิร์ฟเวอร์แบบที่ผมใช้กับระบบของ SiamCafe จริง ครับ
| รวมคำขอ | API รองรับหลายรายการ | ลดจำนวนคำขอหลายสิบเท่า |
|---|---|---|
| ตัวจับเวลาและบันทึกเหตุการณ์ | ทุกงาน | รู้จุดขวดคอแม่นยำ |
พอปรับเทคนิคเหล่านี้แล้ว ขั้นถัดไปคือทำให้สคริปต์รันต่อเนื่องโดยไม่ต้องคอยดู ซึ่งเป็นเรื่องการติดตั้งและการบำรุงรักษาในหัวข้อถัดไป
การติดตั้งและการบำรุงรักษาบนเซิร์ฟเวอร์ — ให้สคริปต์รันต่อเนื่องตลอดเวลา
สคริปต์ที่ดีที่สุดในโลกก็ไร้ค่าถ้ารันไม่ได้เพราะเครื่องปิดหรือกระบวนการดับเฉย ๆ ในหัวข้อนี้ผมจะอธิบายวิธีติดตั้งสคริปต์ asyncio บนเซิร์ฟเวอร์แบบที่ผมใช้กับระบบของ SiamCafe จริง ครับ
วิธีมาตรฐานบนเซิร์ฟเวอร์ลินุกซ์คือใช้ systemd สร้างไฟล์หน่วยงานที่กำหนดให้รันสคริปต์อัตโนมัติเมื่อเครื่องเปิด รันใหม่เมื่อดับ และรีสตาร์ตเมื่อใช้หน่วยความจำเกิน
[Unit] Description=SiamCafe Automation Script After=network.target
[Service] Type=simple User=bom WorkingDirectory=/opt/siamcafe ExecStart=/opt/siamcafe/venv/bin/python main.py Restart=always RestartSec=5 MemoryMax=1G Environment=LOG_LEVEL=info
[Install] WantedBy=multi-user.target
จุดสำคัญคือ Restart=always กับ RestartSec=5 หมายถึงถ้ากระบวนการดับด้วยเหตุผลใดก็ตาม ระบบจะเปิดใหม่ใน 5 วินาที ทำให้ไม่ต้องกังวลเรื่องหยุดทำงานข้ามคืน และกำหนด MemoryMax กันกรณีสคริปต์รั่วหน่วยความจำจนเครื่องล่มทั้งเครื่อง
ส่วนการตรวจตรา ผมตั้งให้สคริปต์ส่งสถานะสุขภาพไปยังปลายทางทุกนาที ถ้าหยุดส่งเกิน 5 นาที ระบบแจ้งเตือนจะยิงข้อความเข้าโทรศัพท์ผมทันที อีกทางเลือกคือใช้บริการตรวจสุขภาพ เช่น การส่งหัวใจเต้นไปยังบริการภายนอกที่จะแจ้งเตือนเมื่อสัญญาณหาย
เรื่องการบันทึกเหตุการณ์บนเซิร์ฟเวอร์ ให้เขียนลงไฟล์แบบหมุนเวียน เพื่อไม่ให้ไฟล์โตจนเต็มดิสก์ และเก็บข้อผิดพลาดระดับร้ายแรงแยกไว้ต่างหากเพื่อง่ายต่อการตรวจสอบย้อนหลัง
ข้อควรระวังสุดท้ายคือการจัดการตัวแปรสภาพแวดล้อม ห้ามเขียนกุญแจ API ลงโค้ดโดยเด็ดขาด ให้เก็บในไฟล์ตัวแปรสภาพแวดล้อมแยกและกำหนดสิทธิ์อ่านเฉพาะเจ้าของเท่านั้น ผมเคยเห็นหลายเคสที่กุญแจรั่วเพราะคอมมิตไฟล์การตั้งค่าขึ้นที่เก็บโค้ดสาธารณะโดยไม่รู้ตัว
พอระบบรันต่อเนื่องได้แล้ว มาดูตัวอย่างงานจริงแบบครบวงจรกันในหัวข้อสุดท้าย
ตัวอย่างงานจริง — สคริปต์รวบรวมข้อมูลราคาและแจ้งเตือนอัตโนมัติแบบครบวงจร
เอาละครับ มาถึงหัวข้อที่ผมชอบที่สุด ตัวอย่างจริงที่รวมทุกอย่างจากหัวข้อก่อนหน้าเข้าด้วยกัน สคริปต์นี้คือระบบรวบรวมราคาจากหลายคู่เงินพร้อมกัน ตรวจว่าราคาเคลื่อนพ้นเกณฑ์ที่ตั้งไว้หรือไม่ ถ้าใช่ให้ส่งแจ้งเตือน ผมใช้โครงสร้างคล้ายกันนี้กับงานจริงมาหลายปีแล้ว
import asyncio import aiohttp
เกณฑ์แจ้งเตือน = {"EURUSD": 0.0050, "GBPUSD": 0.0080} ราคาก่อนหน้า = {}
async def ตรวจราคา(session, sem, คู่เงิน): async with sem: async with session.get(f"https://api.example.com/price/{คู่เงิน}") as r: ราคา = (await r.json())["price"] ก่อน = ราคาก่อนหน้า.get(คู่เงิน) ราคาก่อนหน้า[คู่เงิน] = ราคา if ก่อน and abs(ราคา - ก่อน) >= เกณฑ์แจ้งเตือน.get(คู่เงิน, 999): await ส่งแจ้งเตือน(คู่เงิน, ก่อน, ราคา)
async def ส่งแจ้งเตือน(คู่เงิน, ก่อน, ปัจจุบัน): await asyncio.to_thread( บันทึกลงฐานข้อมูล, คู่เงิน, ก่อน, ปัจจุบัน )
async def วงจรหลัก(): sem = asyncio.Semaphore(10) async with aiohttp.ClientSession() as session: while True: งาน = [ตรวจราคา(session, sem, c) for c in เกณฑ์แจ้งเตือน] await asyncio.gather(*งาน, return_exceptions=True) await asyncio.sleep(30)
asyncio.run(วงจรหลัก())
จุดที่ควรสังเกตจากโค้ดนี้ หนึ่ง มันรวบรวมราคาทุกคู่พร้อมกันในแต่ละรอบด้วย gather สอง จำกัดงานพร้อมกันที่ 10 ด้วย Semaphore สาม งานเขียนฐานข้อมูลถูกส่งไปเธรดแยกเพื่อไม่บล็อกวงจรหลัก สี่ ใช้ return_exceptions=True เพื่อให้คู่เงินที่ดึงไม่ได้ไม่ทำให้รอบทั้งหมดพัง และห้า มีรอบทำงานทุก 30 วินาทีผ่าน asyncio.sleep
สำหรับเพื่อน ๆ ที่สนใจจะต่อยอดไปทางเทรดจริงจัง ผมแนะนำให้เริ่มจากโหมดทดลองก่อนเสมอ เก็บสัญญาณไว้ดูก่อนอย่างน้อยหนึ่งเดือน เทียบกับกราฟจริง แล้วค่อยพิจารณาขยับต่อ ใครอยากเริ่มต้นเรียนรู้เรื่องการเทรดจริงไปควบคู่กับการเขียนสคริปต์ สามารถเปิดบัญชีทดลองกับผ่านลิงก์ของเราได้ที่ xmsignal.com/th เพื่อฝึกทดสอบกลยุทธ์แบบไม่เสียเงินจริง
โปรเจคจริงที่ควรฝึกทำตามลำดับ
สคริปต์ดึงข้อมูลจาก API หลายแหล่งพร้อมกันแล้วเก็บลงฐานข้อมูล ระบบแจ้งเตือนเมื่อเงื่อนไขที่กำหนดเป็นจริง ระบบสำรองข้อมูลอัตโนมัติทุกคืนพร้อมรายงานผล ตัวเ
คำถามที่พบบ่อย
asyncio ต่างจากมัลติเธรดใน Python อย่างไร?
asyncio ใช้เธรดเดียวแต่สลับงานอย่างฉลาดผ่านคำสั่ง await และ event loop ซึ่งเป็นหัวใจของระบบทั้งหมด เมื่อโค้ดเจอคำสั่ง await มันจะปล่อยตัวเองไปทำงานอื่นก่อน แล้วกลับมาเมื่องานที่รอเสร็จสิ้น ขณะที่มัลติเธรดจะสร้างหลายเธรดเพื่อทำงานคู่ขนานจริง ๆ ซึ่งมีต้นทุนด้านการจัดการเธรดสูงกว่าและมีปัญหา GIL ใน Python ข้อดีของ asyncio คือเหมาะกับงานที่ต้องรอคอยบ่อย ๆ เช่น การเรียก API การอ่านไฟล์ หรือการสอบถามฐานข้อมูล เพราะระหว่างที่รองานหนึ่ง เราสลับไปทำงานอื่นได้ทันที ทำให้สคริปต์เร็วขึ้นหลายเท่าโดยไม่ต้องเพิ่มเครื่อง ตามประสบการณ์จริง การดึงราคาจากคู่เงิน 50 คู่พร้อมกัน ถ้ารันตามลำดับใช้เวลาเกือบนาที แต่พอใช้ asyncio ใช้เวลาไม่ถึง 3 วินาทีเท่านั้น
คำศัพท์หลักของ asyncio ที่ต้องเข้าใจก่อนเริ่มเขียนมีอะไรบ้าง?
ต้องเข้าใจ 4 คำหลักด้วยกัน ได้แก่ Coroutine คือฟังก์ชันที่เขียนด้วย async def และรองรับการหยุด/กลับมาทำงานได้, Event Loop คือผู้จัดการคิวงานที่คอยสลับ coroutine ตามสถานะการรอ, Task คือ coroutine ที่ถูกส่งไปรันใน event loop แล้ว และ Future คือตัวแทนผลลัพธ์ที่ยังไม่เสร็จ เมื่อเข้าใจสี่คำนี้แล้ว การต่อยอดไปยังสคริปต์ระดับโปรดักชันจะง่ายขึ้นมาก เพราะโครงสร้างของ asyncio ทั้งหมดสร้างขึ้นจากแนวคิดพื้นฐานเหล่านี้ ผมแนะนำให้ฝึกเขียน coroutine ง่าย ๆ ก่อน แล้วค่อยลองส่งงานเข้า event loop ด้วย asyncio.run และ asyncio.gather ทีละขั้น เมื่อคุ้นเคยแล้วจะเห็นภาพการทำงานพร้อมกันของระบบทั้งหมดชัดเจนขึ้นเองตามธรรมชาติ
ข้อผิดพลาดที่มือใหม่ทำบ่อยเมื่อเขียน asyncio automation script มีอะไรบ้าง?
มีสามข้อที่พบบ่อยที่สุด หนึ่ง ลืมใส่ await ทำให้โค้ดได้ coroutine object กลับมาแต่ฟังก์ชันไม่ถูกรันเลย ทำให้สับสนว่าทำไมโปรแกรมทำงานไม่ครบ สอง ใช้คำสั่ง sleep ปกติแทน asyncio.sleep ซึ่งจะบล็อกทั้ง event loop ทำให้งานอื่นที่ควรรันพร้อมกันกลับค้างไปด้วยหมด สาม ใช้ไลบรารีที่ไม่รองรับ async เช่น requests ซึ่งจะบล็อกการทำงานทั้งหมด ต้องเปลี่ยนไปใช้ aiohttp หรือ httpx แทน นอกจากนี้ในงานจริงยังควรระวังเรื่องการยิง request จำนวนมากพร้อมกันเกินไป เพราะถ้ายิงไปหลายพัน request พร้อมกัน เซิร์ฟเวอร์ปลายทางจะบล็อกเราทิ้งทันที ควรใช้ asyncio.Semaphore จำกัดจำนวนงานพร้อมกัน และเพิ่มระบบรีทรายเมื่อล้มเหลวด้วย
จะทำให้สคริปต์ asyncio ปลอดภัยและน่าเชื่อถือสำหรับใช้งานจริง (production) ได้อย่างไร?
สคริปต์ที่รันบนเครื่องตัวเองกับรันเป็นระบบจริงต่างกันคนละเรื่อง เพราะในโลกจริงงานอาจล้ม อินเทอร์เน็ตหลุด เซิร์ฟเวอร์ปลายทางตอบช้า หรือระบบต้องถูกปิดเพื่ออัปเดต ถ้าเขียนแบบห่วน ๆ ข้อมูลจะเสียหายได้ สิ่งที่ต้องทำคือ จัดการข้อผิดพลาดด้วยการครอบ try/except ในแต่ละงาน เพื่อไม่ให้งานหนึ่งล้มแล้วดึงงานที่เหลือลงไปด้วย ใช้ timeout ในทุก request เช่น aiohttp.ClientTimeout(total=10) เพิ่มระบบรีทราย 3 ครั้งพร้อมหน่วงเวลาเพิ่มขึ้นทีละเท่า ใช้ session เดียวร่ว
แนะนำเพิ่มเติม
🎯 เปิดบัญชี XM Forex → สมัคร
📱 แอป iCafeFX → ดาวน์โหลด
📊 สัญญาณฟรี → รับสัญญาณ
📚 คู่มือเทรด → SiamCafeBook
🤝 สมัคร Partner XM → pipaffiliates.com/c?c=72816&l=th&p=6
แนะนำจากเครือข่าย SiamCafe
คู่มือ Forex ที่เกี่ยวข้อง
แหล่งอ้างอิง
- SiamCafe.net - ชุมชนไอทีไทยตั้งแต่ปี 1997
- iCafeFX.com - ศูนย์วิเคราะห์ Forex และทองคำ