วิธีปรับปรุงโค้ด Python ของคุณด้วยความพร้อมกันและความเท่าเทียม

ประเด็นที่สำคัญ

การเห็นพ้องต้องกันและความเท่าเทียมแสดงถึงหลักการสำคัญของการปฏิบัติงานด้านการคำนวณ โดยแต่ละอย่างมีคุณลักษณะเฉพาะที่แยกความแตกต่างออกจากกัน

การทำงานพร้อมกันช่วยให้สามารถจัดสรรทรัพยากรได้อย่างมีประสิทธิภาพและเพิ่มการตอบสนองในแอปพลิเคชัน ในขณะที่การทำงานแบบขนานมีบทบาทสำคัญในการบรรลุประสิทธิภาพสูงสุดและความสามารถในการปรับขนาด

Python นำเสนอแนวทางที่หลากหลายในการจัดการการดำเนินงานที่เกิดขึ้นพร้อมกัน รวมถึงการใช้ประโยชน์จากเธรดผ่านไลบรารีเธรดในตัว ตลอดจนการสนับสนุนการเขียนโปรแกรมแบบอะซิงโครนัสโดยใช้เฟรมเวิร์กอะซินซิโอ นอกจากนี้ โมดูลมัลติโปรเซสเซอร์ยังช่วยให้นักพัฒนาสามารถควบคุมพลังของการประมวลผลแบบขนานในแอปพลิเคชันของตนได้

การเห็นพ้องกันหมายถึงความสามารถของระบบในการดำเนินการหลายกระบวนการหรือเธรดในเวลาเดียวกัน ในขณะที่ความเท่าเทียมคือความสามารถในการแบ่งงานออกเป็นงานย่อยที่เล็กลงและดำเนินการพร้อมกันตามส่วนต่างๆ ของระบบ ใน Python มีหลายวิธีในการจัดการภาวะพร้อมกันและความขนาน เช่น การประมวลผลหลายตัว การทำเธรด การเขียนโปรแกรมแบบอะซิงโครนัสด้วย async/await และการใช้ไลบรารี เช่น Celery หรือ Dask สำหรับการคำนวณแบบกระจาย อย่างไรก็ตาม ตัวเลือกเหล่านี้อาจทำให้เกิดความสับสนเมื่อตัดสินใจเลือกแนวทางที่เหมาะสมที่สุดสำหรับสถานการณ์เฉพาะ

เจาะลึกอาร์เรย์ของทรัพยากรและเฟรมเวิร์กที่สามารถอำนวยความสะดวกในการใช้งานเทคนิคการเขียนโปรแกรมพร้อมกันใน Python ได้อย่างมีประสิทธิภาพ รวมถึงความแตกต่างจากเทคนิคอื่น

ทำความเข้าใจเรื่องเห็นพ้องและความเท่าเทียม

การเกิดขึ้นพร้อมกันและความเท่าเทียมเป็นแนวคิดสำคัญสองประการที่อธิบายวิธีดำเนินการงานต่างๆ ในระบบคอมพิวเตอร์ โดยแต่ละงานมีคุณลักษณะเฉพาะของตัวเอง

⭐ การเห็นพร้อมกันคือความสามารถของโปรแกรมในการจัดการงานหลาย ๆ งานพร้อมกันโดยไม่จำเป็นต้องดำเนินการงานเหล่านั้นในเวลาเดียวกัน มันหมุนรอบแนวคิดของการสลับงานโดยสลับระหว่างงานเหล่านั้นในลักษณะที่ปรากฏพร้อมกัน

⭐ ในทางกลับกัน ความเท่าเทียมเกี่ยวข้องกับการทำงานหลายอย่างพร้อมกันอย่างแท้จริง โดยทั่วไปจะใช้ประโยชน์จากคอร์ CPU หรือโปรเซสเซอร์หลายตัว ความเท่าเทียมทำให้สามารถดำเนินการพร้อมกันได้อย่างแท้จริง ช่วยให้คุณทำงานได้เร็วขึ้น และเหมาะอย่างยิ่งสำหรับการดำเนินการที่เน้นการประมวลผล

ความสำคัญของการเห็นพ้องต้องกันและความเท่าเทียม

ความสำคัญของการประมวลผลพร้อมกันและแบบขนานในการประมวลผลนั้นไม่อาจโต้แย้งได้ เนื่องจากช่วยให้สามารถดำเนินการงานหลายอย่างพร้อมกันได้ ซึ่งจะช่วยเพิ่มประสิทธิภาพและลดเวลาดำเนินการโดยรวม แนวทางนี้มีความสำคัญมากขึ้นเรื่อยๆ เนื่องจากความต้องการความสามารถในการประมวลผลที่รวดเร็วและมีประสิทธิภาพมากขึ้นในแอปพลิเคชันที่หลากหลาย ตั้งแต่การจำลองทางวิทยาศาสตร์ไปจนถึงระบบอัตโนมัติของเวิร์กโฟลว์ทางธุรกิจ ด้วยการใช้ประโยชน์จากพลังของโปรเซสเซอร์แบบมัลติคอร์และระบบแบบกระจาย การประมวลผลพร้อมกันและแบบขนานช่วยให้ใช้ทรัพยากรได้ดีขึ้นและเพิ่มความสามารถในการปรับขนาด ซึ่งท้ายที่สุดจะนำไปสู่ประสิทธิภาพที่ดีขึ้นและความสามารถในการผลิตที่เพิ่มขึ้น

การจัดสรรทรัพยากรที่ได้รับการปรับปรุงประสิทธิภาพสามารถทำได้พร้อมกัน เนื่องจากช่วยให้สามารถใช้ประโยชน์จากทรัพย์สินของระบบได้อย่างมีประสิทธิภาพ รับประกันว่ากระบวนการต่างๆ จะก้าวหน้าอย่างมีประสิทธิผลอย่างต่อเนื่อง แทนที่จะยืนหยัดเพื่อทรัพยากรภายนอกอย่างอดทน

ความสามารถในการปรับปรุงการตอบสนองของแอปพลิเคชัน โดยเฉพาะอย่างยิ่งในส่วนติดต่อผู้ใช้และการโต้ตอบของเว็บเซิร์ฟเวอร์ ถือเป็นข้อได้เปรียบที่โดดเด่นที่เกี่ยวข้องกับการทำงานพร้อมกัน

ประสิทธิภาพที่เพิ่มขึ้นสามารถบรรลุได้ผ่านทางการทำงานแบบขนาน โดยเฉพาะอย่างยิ่งในงานคำนวณที่ต้องอาศัยหน่วยประมวลผลกลาง (CPU) อย่างมาก เช่น การคำนวณที่ซับซ้อน การจัดการข้อมูล และการจำลองการสร้างแบบจำลอง

ความสามารถในการขยายขนาดเป็นส่วนสำคัญของการออกแบบระบบ โดยต้องใช้ทั้งการดำเนินการพร้อมกันและการประมวลผลแบบขนานเพื่อให้ได้ประสิทธิภาพสูงสุดในวงกว้าง ความสามารถในการจัดการกับปริมาณงานที่เพิ่มขึ้นในขณะที่ยังคงรักษาประสิทธิภาพเป็นสิ่งสำคัญยิ่งในการพัฒนาซอฟต์แวร์สมัยใหม่

เมื่อคำนึงถึงแนวโน้มที่เกิดขึ้นใหม่ในเทคโนโลยีฮาร์ดแวร์ที่ให้ความสำคัญกับความสามารถในการประมวลผลแบบมัลติคอร์ จึงกลายเป็นสิ่งจำเป็นสำหรับระบบซอฟต์แวร์ที่จะใช้ประโยชน์จากการทำงานแบบขนานอย่างมีประสิทธิภาพ เพื่อให้มั่นใจถึงความมีชีวิตและความยั่งยืนในระยะยาว

เห็นพ้องต้องกันใน Python

การดำเนินการพร้อมกันสามารถทำได้ใน Python โดยใช้เทคนิคเธรดหรืออะซิงโครนัส ซึ่งอำนวยความสะดวกโดยไลบรารี asyncio

เธรดใน Python

เธรดเป็นคุณสมบัติที่แท้จริงในการเขียนโปรแกรม Python ที่ช่วยให้สามารถสร้างและจัดการงานหลายอย่างที่เกิดขึ้นพร้อมกันภายในกระบวนการที่เป็นหนึ่งเดียว กลไกนี้พิสูจน์ให้เห็นถึงข้อได้เปรียบโดยเฉพาะสำหรับงานที่มีการดำเนินการอินพุต/เอาท์พุตจำนวนมาก หรืองานที่อาจได้รับประโยชน์จากการดำเนินการแบบขนาน

โมดูลเธรดของ Python มอบอินเทอร์เฟซระดับสูงสำหรับการสร้างและจัดการเธรด แม้ว่า GIL (Global Interpreter Lock) จะจำกัดเธรดในแง่ของความขนานที่แท้จริง แต่เธรดเหล่านี้ยังคงสามารถบรรลุการทำงานพร้อมกันได้โดยการแทรกงานอย่างมีประสิทธิภาพ

โค้ดที่ให้มาสาธิตอินสแตนซ์ของการเขียนโปรแกรมพร้อมกันผ่านการใช้งานเธรดใน Python โดยเฉพาะอย่างยิ่ง ใช้ไลบรารีคำขอ Python เพื่อเริ่มต้นคำขอ HTTP ซึ่งเป็นการดำเนินการทั่วไปที่เกี่ยวข้องกับการดำเนินการอินพุต-เอาท์พุต (I/O) และอาจส่งผลให้เกิดการบล็อกงานได้ นอกจากนี้โค้ดยังใช้ประโยชน์จากโมดูลเวลาเพื่อกำหนดระยะเวลาในการทำงานของโปรแกรม

 import requests
import time
import threading

urls = [
    'https://www.google.com',
    'https://www.wikipedia.org',
    'https://www.makeuseof.com',
]

# function to request a URL
def download_url(url):
    response = requests.get(url)
    print(f"Downloaded {url}-Status Code: {response.status_code}")


# Execute without threads and measure execution time
start_time = time.time()

for url in urls:
    download_url(url)

end_time = time.time()
print(f"Sequential download took {end_time-start_time:.2f} seconds\n")


# Execute with threads, resetting the time to measure new execution time
start_time = time.time()
threads = []

for url in urls:
    thread = threading.Thread(target=download_url, args=(url,))
    thread.start()
    threads.append(thread)

# Wait for all threads to complete
for thread in threads:
    thread.join()

end_time = time.time()
print(f"Threaded download took {end_time-start_time:.2f} seconds")

อันที่จริง การรันโปรแกรมนี้เผยให้เห็นการเพิ่มประสิทธิภาพที่มองเห็นได้ชัดเจน เมื่อใช้เธรดที่เกิดขึ้นพร้อมกันเพื่อดำเนินการที่ต้องใช้ I/O มาก แม้ว่าเวลาจะต่างกันเล็กน้อยระหว่างการประมวลผลตามลำดับและขนานก็ตาม

การเขียนโปรแกรมแบบอะซิงโครนัสด้วย Asyncio

asyncio จัดให้มีลูปเหตุการณ์ที่จัดการงานอะซิงโครนัสที่เรียกว่า coroutineÂs Coroutine เป็นฟังก์ชันที่คุณสามารถหยุดชั่วคราวและทำงานต่อได้ ทำให้เหมาะสำหรับงาน I/O-bound ไลบรารีมีประโยชน์อย่างยิ่งสำหรับสถานการณ์ที่งานเกี่ยวข้องกับการรอทรัพยากรภายนอก เช่น คำขอเครือข่าย

หากต้องการปรับตัวอย่างการส่งคำขอแบบซิงโครนัสก่อนหน้านี้เพื่อใช้กับการเขียนโปรแกรมแบบอะซิงโครนัสใน Python คุณจะต้องทำการเปลี่ยนแปลงเล็กน้อย ประการแรก แทนที่จะใช้ request.get() และ time.sleep() ซึ่งบล็อกการดำเนินการที่หยุดการดำเนินการชั่วคราวจนกว่าจะเสร็จสิ้นหรือเวลาที่ผ่านไปตามลำดับ คุณควรใช้ทางเลือกอื่นที่ไม่ปิดกั้น เช่น asyncio และ aiohttp. สิ่งนี้เกี่ยวข้องกับการรวมโค้ดที่มีอยู่ในฟังก์ชันอะซิงโครนัสโดยใช้ async def และแทนที่การดำเนินการ I/O แบบดั้งเดิมด้วยการดำเนินการแบบอะซิงโครนัส ตัวอย่างเช่น async with aiohttp.ClientSession().post(url) สามารถใช้เพื่อส่งคำขอ POST แบบอะซิงโครนัสโดยไม่ต้องรอการตอบกลับ นอกจากนี้ การจัดการข้อผิดพลาดและการบันทึกอาจต้องมีการปรับเปลี่ยนเพื่อรองรับเฟรมเวิร์กอะซิงก์ใหม่

 import asyncio
import aiohttp
import time

urls = [
    'https://www.google.com',
    'https://www.wikipedia.org',
    'https://www.makeuseof.com',
]

# asynchronous function to request URL
async def download_url(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            content = await response.text()
            print(f"Downloaded {url}-Status Code: {response.status}")

# Main asynchronous function
async def main():
    # Create a list of tasks to download each URL concurrently
    tasks = [download_url(url) for url in urls]

    # Gather and execute the tasks concurrently
    await asyncio.gather(*tasks)

start_time = time.time()

# Run the main asynchronous function
asyncio.run(main())

end_time = time.time()

print(f"Asyncio download took {end_time-start_time:.2f} seconds")

การใช้โค้ดที่ให้มาสามารถดำเนินการดาวน์โหลดหน้าเว็บพร้อมกันหลายรายการได้อย่างมีประสิทธิภาพ โดยใช้ประโยชน์จากความสามารถของ อะซินซิโอ และควบคุมพลังของการดำเนินการ I/O แบบอะซิงโครนัส ตรงกันข้ามกับเทคนิคการทำเธรดแบบเดิมซึ่งเหมาะกว่าสำหรับงานที่ใช้ CPU มาก วิธีการนี้มีประสิทธิภาพเป็นพิเศษในการปรับกระบวนการผูกกับ I/O ให้เหมาะสม

ความเท่าเทียมใน Python

คุณสามารถใช้การทำงานแบบขนานได้โดยใช้ Python’s multiprocessing module ซึ่งช่วยให้คุณใช้ประโยชน์จากโปรเซสเซอร์แบบมัลติคอร์ได้อย่างเต็มที่

การประมวลผลหลายตัวใน Python

โมดูลการประมวลผลหลายตัวของ Python นำเสนอแนวทางในการควบคุมการทำงานแบบขนานผ่านการสร้างแต่ละกระบวนการ โดยแต่ละกระบวนการมีตัวแปล Python และโดเมนหน่วยความจำที่แตกต่างกัน เมื่อทำเช่นนี้ วิธีการนี้จะหลีกเลี่ยง Global Interpreter Lock (GIL) ซึ่งมักพบในงานที่เชื่อมโยงกับ CPU

 import requests
import multiprocessing
import time

urls = [
    'https://www.google.com',
    'https://www.wikipedia.org',
    'https://www.makeuseof.com',
]

# function to request a URL
def download_url(url):
    response = requests.get(url)
    print(f"Downloaded {url}-Status Code: {response.status_code}")

def main():
    # Create a multiprocessing pool with a specified number of processes
    num_processes = len(urls)
    pool = multiprocessing.Pool(processes=num_processes)

    start_time = time.time()
    pool.map(download_url, urls)
    end_time = time.time()

    # Close the pool and wait for all processes to finish
    pool.close()
    pool.join()

    print(f"Multiprocessing download took {end_time-start_time:.2f} seconds")

main()

การประมวลผลหลายรายการช่วยให้สามารถเรียกใช้ฟังก์ชัน download\_url ในหลายกระบวนการพร้อมกันได้ จึงช่วยอำนวยความสะดวกในการประมวลผล URL ที่กำหนดแบบขนาน

เมื่อใดควรใช้การเห็นพ้องต้องกันหรือความเท่าเทียม

การตัดสินใจเลือกใช้การประมวลผลพร้อมกันหรือการประมวลผลแบบขนานขึ้นอยู่กับลักษณะของการดำเนินการที่กำลังดำเนินการและความจุของทรัพยากรฮาร์ดแวร์ของระบบพื้นฐาน

เมื่อจัดการการดำเนินการอินพุต/เอาท์พุต (I/O) ที่เน้นศูนย์กลาง เช่น การดำเนินการอ่าน/เขียนไฟล์ หรือการร้องขอเครือข่าย ขอแนะนำให้ใช้การทำงานพร้อมกันเนื่องจากความสามารถในการจัดการงานหลายอย่างพร้อมกัน นอกจากนี้ อาจใช้ในสถานการณ์ที่ข้อจำกัดของหน่วยความจำก่อให้เกิดความท้าทาย

เมื่อใช้การประมวลผลหลายตัวจะเหมาะสมสำหรับการดำเนินการที่ใช้ CPU มากซึ่งอาจได้รับการปรับปรุงโดยการดำเนินการพร้อมกัน และเมื่อทำให้แน่ใจว่าการแยกกระบวนการที่มีประสิทธิภาพเป็นสิ่งสำคัญอันดับแรก เนื่องจากความล้มเหลวของแต่ละกระบวนการไม่ควรส่งผลกระทบต่อกระบวนการอื่นๆ มากเกินไป

ใช้ประโยชน์จากความเห็นพ้องต้องกันและความเท่าเทียม

ความเท่าเทียมและการดำเนินการพร้อมกันเป็นวิธีการที่มีประสิทธิภาพในการเพิ่มประสิทธิภาพและปริมาณงานของโปรแกรม Python อย่างไรก็ตาม จำเป็นอย่างยิ่งที่จะต้องเข้าใจถึงความแตกต่างระหว่างเทคนิคเหล่านี้ เพื่อประกอบการตัดสินใจอย่างมีข้อมูลว่าแนวทางใดเหมาะสมกับสถานการณ์เฉพาะที่สุด

Python จัดเตรียมชุดเครื่องมือและโมดูลที่ครอบคลุมซึ่งช่วยให้นักพัฒนาสามารถเพิ่มประสิทธิภาพโค้ดของตนโดยใช้ประโยชน์จากเทคนิคการประมวลผลที่เกิดขึ้นพร้อมกันหรือแบบขนาน ไม่ว่างานที่ทำอยู่จะเป็นงานด้านการคำนวณเป็นหลักหรือเน้นอินพุต/เอาท์พุตก็ตาม