Gunakan teknik ini untuk menjalankan kode secara bersamaan dan memberikan pengalaman pengguna yang lebih lancar.

Poin Penting

  • Konkurensi dan paralelisme adalah prinsip dasar pelaksanaan tugas dalam komputasi, yang masing-masing memiliki karakteristik berbeda.
  • Konkurensi memungkinkan pemanfaatan sumber daya secara efisien dan meningkatkan respons aplikasi, sementara paralelisme sangat penting untuk kinerja dan skalabilitas yang optimal.
  • Python menyediakan opsi untuk menangani konkurensi, seperti threading dan pemrograman asinkron dengan asyncio, serta paralelisme menggunakan modul multiprosesing.

Konkurensi dan paralelisme adalah dua teknik yang memungkinkan Anda menjalankan beberapa program secara bersamaan. Python memiliki banyak opsi untuk menangani tugas secara bersamaan dan paralel, yang dapat membingungkan.

Jelajahi alat dan pustaka yang tersedia untuk mengimplementasikan konkurensi dan paralelisme dengan benar di Python, dan perbedaannya.

Memahami Konkurensi dan Paralelisme

Konkurensi dan paralelisme mengacu pada dua prinsip dasar pelaksanaan tugas dalam komputasi. Masing-masing mempunyai karakteristik tersendiri.

instagram viewer

  1. Konkurensi adalah kemampuan suatu program untuk mengelola banyak tugas pada waktu yang sama tanpa harus menjalankannya pada waktu yang sama. Ini berkisar pada gagasan menyisipkan tugas, beralih di antara tugas-tugas tersebut dengan cara yang tampak simultan.
  2. Paralelisme, di sisi lain, melibatkan pelaksanaan banyak tugas secara paralel. Ini biasanya memanfaatkan beberapa inti CPU atau prosesor. Paralelisme mencapai eksekusi simultan yang sebenarnya, memungkinkan Anda melakukan tugas lebih cepat, dan sangat cocok untuk operasi komputasi intensif.

Pentingnya Konkurensi dan Paralelisme

Kebutuhan akan konkurensi dan paralelisme dalam komputasi tidak bisa dilebih-lebihkan. Inilah mengapa teknik ini penting:

  1. Pemanfaatan sumber daya: Konkurensi memungkinkan pemanfaatan sumber daya sistem secara efisien, memastikan bahwa tugas-tugas mengalami kemajuan secara aktif daripada hanya menunggu sumber daya eksternal.
  2. Daya tanggap: Konkurensi dapat meningkatkan respons aplikasi, terutama dalam skenario yang melibatkan antarmuka pengguna atau server web.
  3. Pertunjukan: Paralelisme sangat penting untuk mencapai kinerja optimal, khususnya dalam tugas-tugas yang terikat CPU seperti penghitungan kompleks, pemrosesan data, dan simulasi.
  4. Skalabilitas: Baik konkurensi maupun paralelisme sangat penting untuk membangun sistem yang skalabel.
  5. Bukti masa depan: Ketika tren perangkat keras terus mendukung prosesor multicore, kemampuan untuk memanfaatkan paralelisme akan menjadi semakin diperlukan.

Konkurensi dengan Python

Anda dapat mencapai konkurensi dengan Python menggunakan threading dan pemrograman asinkron dengan perpustakaan asyncio.

Mengikat dengan Python

Threading adalah mekanisme konkurensi Python yang memungkinkan Anda membuat dan mengelola tugas dalam satu proses. Thread cocok untuk jenis tugas tertentu, khususnya tugas yang terikat I/O dan dapat memperoleh manfaat dari eksekusi bersamaan.

ular piton threading modul menyediakan antarmuka tingkat tinggi untuk membuat dan mengelola thread. Meskipun GIL (Global Interpreter Lock) membatasi thread dalam hal paralelisme sebenarnya, mereka masih dapat mencapai konkurensi dengan menyisipkan tugas secara efisien.

Kode di bawah ini menunjukkan contoh implementasi konkurensi menggunakan thread. Ia menggunakan pustaka permintaan Python untuk mengirim permintaan HTTP, tugas pemblokiran I/O yang umum. Itu juga menggunakan modul waktu untuk menghitung waktu eksekusi.

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


# function to request a URL
defdownload_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")

Menjalankan program ini, Anda akan melihat seberapa cepat permintaan berulir dibandingkan permintaan berurutan. Meskipun perbedaannya hanya sepersekian detik, Anda dapat merasakan dengan jelas peningkatan kinerja saat menggunakan thread untuk tugas yang terikat I/O.

Pemrograman Asinkron Dengan Asyncio

asyncio menyediakan loop peristiwa yang mengelola tugas asinkron yang disebut coroutine. Coroutine adalah fungsi yang dapat Anda jeda dan lanjutkan, sehingga ideal untuk tugas yang terikat I/O. Pustaka ini sangat berguna untuk skenario ketika tugas memerlukan menunggu sumber daya eksternal, seperti permintaan jaringan.

Anda dapat memodifikasi contoh pengiriman permintaan sebelumnya agar dapat digunakan asyncio:

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


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


# Main asynchronous function
asyncdefmain():
# 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")

Dengan menggunakan kode ini, Anda dapat mengunduh halaman web secara bersamaan menggunakan asyncio dan memanfaatkan operasi I/O asinkron. Ini bisa lebih efisien daripada threading untuk tugas-tugas yang terikat I/O.

Paralelisme dengan Python

Anda dapat menerapkan paralelisme menggunakan ular piton multiproses modul, yang memungkinkan Anda memanfaatkan sepenuhnya prosesor multicore.

Multiproses dengan Python

ular piton multiproses modul menyediakan cara untuk mencapai paralelisme dengan membuat proses terpisah, masing-masing dengan interpreter Python dan ruang memorinya sendiri. Ini secara efektif melewati Global Interpreter Lock (GIL), sehingga cocok untuk tugas-tugas yang terikat dengan 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
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")


defmain():
# 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()

Dalam contoh ini, multiproses memunculkan banyak proses, memungkinkan unduh_url berfungsi untuk berjalan secara paralel.

Kapan Menggunakan Konkurensi atau Paralelisme

Pilihan antara konkurensi dan paralelisme bergantung pada sifat tugas Anda dan sumber daya perangkat keras yang tersedia.

Anda dapat menggunakan konkurensi ketika menangani tugas-tugas yang terikat I/O, seperti membaca dan menulis ke file atau membuat permintaan jaringan, dan ketika kendala memori menjadi perhatian.

Gunakan multiprosesing ketika Anda memiliki tugas-tugas yang terikat dengan CPU yang bisa mendapatkan manfaat dari paralelisme yang sebenarnya dan ketika Anda memiliki isolasi yang kuat antar tugas, di mana kegagalan satu tugas tidak akan berdampak pada tugas lainnya.

Manfaatkan Konkurensi dan Paralelisme

Paralelisme dan konkurensi adalah cara efektif untuk meningkatkan daya tanggap dan kinerja kode Python Anda. Penting untuk memahami perbedaan antara konsep-konsep ini dan memilih strategi yang paling efektif.

Python menawarkan alat dan modul yang Anda perlukan untuk membuat kode Anda lebih efektif melalui konkurensi atau paralelisme, terlepas dari apakah Anda bekerja dengan proses yang terikat CPU atau terikat I/O.