okay, jadi mari kita pergi!
Takeaways Key
Biasanya, apabila anda menjalankan skrip python, kod anda pada satu ketika menjadi proses, dan proses berjalan pada satu teras CPU anda. Tetapi komputer moden mempunyai lebih daripada satu teras, jadi bagaimana jika anda boleh menggunakan lebih banyak teras untuk pengiraan anda? Ternyata pengiraan anda akan lebih cepat.
mari kita ambil ini sebagai prinsip umum buat masa ini, tetapi kemudian, dalam artikel ini, kita akan melihat bahawa ini tidak benar secara universal.
tanpa mendapat terlalu banyak butiran, idea di sebalik paralelisme adalah menulis kod anda dengan cara yang boleh menggunakan pelbagai teras CPU.
Untuk membuat perkara lebih mudah, mari kita lihat contoh.
pengkomputeran selari dan bersiri
Bagaimana jika anda mempunyai tiga kawan yang baik di matematik bersedia membantu anda? Setiap daripada mereka akan mengira akar kuadrat dua nombor, dan tugas anda akan lebih mudah kerana beban kerja diedarkan sama antara rakan anda. Ini bermakna masalah anda akan diselesaikan dengan lebih cepat.
Baiklah, jadi semuanya jelas? Dalam contoh -contoh ini, setiap rakan mewakili teras CPU. Dalam contoh pertama, keseluruhan tugas diselesaikan secara berurutan oleh anda. Ini dipanggil pengkomputeran siri. Dalam contoh kedua, kerana anda bekerja dengan empat teras secara keseluruhan, anda menggunakan pengkomputeran selari. Pengkomputeran selari melibatkan penggunaan proses atau proses selari yang dibahagikan di antara pelbagai teras dalam pemproses.
Buat masa ini, mari kita ambil perhatian bahawa parallelization adalah penyelesaian terbaik untuk anda. Terdapat tiga model dalam pengkomputeran selari:
multiprocessing python: paralelisme berasaskan proses dalam python
Anda mungkin pernah mendengar perpustakaan lain, seperti threading, yang juga dibina dengan Python, tetapi terdapat perbezaan penting di antara mereka. Modul multiprocessing mencipta proses baru, sementara threading mencipta benang baru.
Di bahagian seterusnya, kita akan melihat kelebihan menggunakan multiprocessing.
faedah menggunakan multiprocessing
Kelebihan pertama berkaitan dengan prestasi. Oleh kerana multiprocessing mencipta proses baru, anda boleh menggunakan lebih baik penggunaan kuasa pengiraan CPU anda dengan membahagikan tugas anda di antara teras lain. Kebanyakan pemproses adalah pemproses berbilang teras pada masa kini, dan jika anda mengoptimumkan kod anda, anda boleh menjimatkan masa dengan menyelesaikan pengiraan selari.
Kelebihan kedua melihat alternatif kepada multiprocessing, yang multithreading. Threads bukan proses walaupun, dan ini mempunyai akibatnya. Jika anda membuat benang, ia berbahaya untuk membunuhnya atau bahkan mengganggu seperti yang anda lakukan dengan proses biasa. Oleh kerana perbandingan antara multiprocessing dan multithreading tidak dalam skop artikel ini, saya menggalakkan anda untuk melakukan bacaan selanjutnya di atasnya.
Kelebihan ketiga multiprocessing adalah bahawa ia agak mudah dilaksanakan, memandangkan tugas yang anda cuba mengendalikan sesuai untuk pengaturcaraan selari.
kami akhirnya bersedia untuk menulis beberapa kod python!
Kami akan bermula dengan contoh yang sangat asas dan kami akan menggunakannya untuk menggambarkan aspek teras Python multiprocessing. Dalam contoh ini, kita akan mempunyai dua proses:
Kami akan menggunakan proses kanak -kanak untuk melaksanakan fungsi tertentu. Dengan cara ini, ibu bapa boleh meneruskan pelaksanaannya.
inilah kod yang akan kami gunakan untuk contoh ini:
<span>from multiprocessing import Process
</span>
<span>def bubble_sort(array):
</span> check <span>= True
</span> <span>while check == True:
</span> check <span>= False
</span> <span>for i in range(0, len(array)-1):
</span> <span>if array[i] > array[i+1]:
</span> check <span>= True
</span> temp <span>= array[i]
</span> array<span>[i] = array[i+1]
</span> array<span>[i+1] = temp
</span> <span>print("Array sorted: ", array)
</span>
<span>if __name__ == '__main__':
</span> p <span>= Process(target=bubble_sort, args=([1,9,4,5,2,6,8,4],))
</span> p<span>.start()
</span> p<span>.join()
</span>Dalam coretan ini, kami telah menentukan fungsi yang dipanggil bubble_sort (array). Fungsi ini adalah pelaksanaan algoritma penyortiran jenis gelembung yang benar -benar naif. Jika anda tidak tahu apa itu, jangan risau, kerana ia tidak penting. Perkara penting yang perlu diketahui ialah fungsi yang berfungsi.
Dari multiprocessing, kami mengimport proses kelas. Kelas ini mewakili aktiviti yang akan dijalankan dalam proses yang berasingan. Sesungguhnya, anda dapat melihat bahawa kami telah lulus beberapa hujah:
Sebaik sahaja kita telah membuat contoh ke kelas proses, kita hanya perlu memulakan proses. Ini dilakukan dengan menulis P.Start (). Pada ketika ini, proses dimulakan.
Sebelum kita keluar, kita perlu menunggu proses kanak -kanak untuk menyelesaikan perhitungannya. Kaedah gabungan () menunggu proses untuk ditamatkan.
Dalam contoh ini, kami telah membuat hanya satu proses kanak -kanak. Seperti yang anda rasa, kami boleh membuat lebih banyak proses kanak -kanak dengan membuat lebih banyak contoh dalam kelas proses.
Bagaimana jika kita perlu membuat pelbagai proses untuk mengendalikan lebih banyak tugas intensif CPU? Adakah kita sentiasa perlu memulakan dan menunggu secara eksplisit untuk penamatan? Penyelesaian di sini adalah menggunakan kelas kolam.
Kelas Kolam membolehkan anda membuat kumpulan proses pekerja, dan dalam contoh berikut, kita akan melihat bagaimana kita boleh menggunakannya. Ini adalah contoh baru kami:
<span>from multiprocessing import Process
</span>
<span>def bubble_sort(array):
</span> check <span>= True
</span> <span>while check == True:
</span> check <span>= False
</span> <span>for i in range(0, len(array)-1):
</span> <span>if array[i] > array[i+1]:
</span> check <span>= True
</span> temp <span>= array[i]
</span> array<span>[i] = array[i+1]
</span> array<span>[i+1] = temp
</span> <span>print("Array sorted: ", array)
</span>
<span>if __name__ == '__main__':
</span> p <span>= Process(target=bubble_sort, args=([1,9,4,5,2,6,8,4],))
</span> p<span>.start()
</span> p<span>.join()
</span>Dalam coretan kod ini, kami mempunyai fungsi kiub (x) yang hanya mengambil integer dan mengembalikan akar kuadratnya. Mudah, betul?
Kemudian, kami membuat contoh kelas kolam, tanpa menentukan sebarang atribut. Kelas Kolam Mewujudkan secara lalai satu proses setiap teras CPU. Seterusnya, kami menjalankan kaedah peta dengan beberapa hujah.
Kaedah peta menggunakan fungsi kiub untuk setiap elemen yang dapat kami berikan - yang, dalam kes ini, adalah senarai setiap nombor dari 10 hingga N.
kelebihan besar ini ialah pengiraan dalam senarai dilakukan secara selari!
Membuat pelbagai proses dan melakukan perhitungan selari tidak semestinya lebih cekap daripada pengkomputeran siri. Untuk tugas-tugas intensif CPU yang rendah, pengiraan siri lebih cepat daripada pengiraan selari. Atas sebab ini, penting untuk difahami apabila anda perlu menggunakan multiprocessing - yang bergantung kepada tugas yang anda lakukan.
Untuk meyakinkan anda tentang ini, mari kita lihat contoh mudah:
<span>from multiprocessing import Pool
</span><span>import time
</span><span>import math
</span>
N <span>= 5000000
</span>
<span>def cube(x):
</span> <span>return math.sqrt(x)
</span>
<span>if __name__ == "__main__":
</span> <span>with Pool() as pool:
</span> result <span>= pool.map(cube, range(10,N))
</span> <span>print("Program finished!")
</span>Coretan ini didasarkan pada contoh sebelumnya. Kami menyelesaikan masalah yang sama, yang mengira akar kuadrat nombor N, tetapi dalam dua cara. Yang pertama melibatkan penggunaan multiprocessing Python, sementara yang kedua tidak. Kami menggunakan kaedah perf_counter () dari perpustakaan masa untuk mengukur prestasi masa.
pada komputer riba saya, saya mendapat hasil ini:
<span>from multiprocessing import Pool
</span><span>import time
</span><span>import math
</span>
N <span>= 5000000
</span>
<span>def cube(x):
</span> <span>return math.sqrt(x)
</span>
<span>if __name__ == "__main__":
</span> <span># first way, using multiprocessing
</span> start_time <span>= time.perf_counter()
</span> <span>with Pool() as pool:
</span> result <span>= pool.map(cube, range(10,N))
</span> finish_time <span>= time.perf_counter()
</span> <span>print("Program finished in {} seconds - using multiprocessing".format(finish_time-start_time))
</span> <span>print("---")
</span> <span># second way, serial computation
</span> start_time <span>= time.perf_counter()
</span> result <span>= []
</span> <span>for x in range(10,N):
</span> result<span>.append(cube(x))
</span> finish_time <span>= time.perf_counter()
</span> <span>print("Program finished in {} seconds".format(finish_time-start_time))
</span>Seperti yang anda lihat, terdapat lebih daripada satu perbezaan saat. Jadi dalam kes ini, multiprocessing lebih baik.
mari kita ubah sesuatu dalam kod, seperti nilai N. Mari turunkannya ke n = 10000 dan lihat apa yang berlaku.
inilah yang saya dapat sekarang:
<span>> python code.py </span>Program finished <span>in 1.6385094 seconds - using multiprocessing </span>--- Program finished <span>in 2.7373942999999996 seconds </span>
apa yang berlaku? Nampaknya multiprocessing kini menjadi pilihan yang buruk. Kenapa?
overhead yang diperkenalkan dengan memisahkan perhitungan antara proses terlalu banyak berbanding dengan tugas yang diselesaikan. Anda dapat melihat berapa banyak perbezaan yang ada dari segi persembahan masa.
Dalam artikel ini, kami telah bercakap tentang pengoptimuman prestasi kod python dengan menggunakan multiprocessing python.
Pertama, kami memperkenalkan secara ringkas apa pengkomputeran selari dan model utama untuk menggunakannya. Kemudian, kami mula bercakap mengenai multiprocessing dan kelebihannya. Akhirnya, kita melihat bahawa parallelizing pengiraan tidak semestinya pilihan terbaik dan modul multiprocessing harus digunakan untuk selari tugas-tugas CPU yang terikat. Seperti biasa, ia adalah satu perkara yang mempertimbangkan masalah khusus yang anda hadapi dan menilai kebaikan dan keburukan penyelesaian yang berbeza.
Saya harap anda dapat belajar tentang python multiprocessing sebagai berguna seperti yang saya lakukan.
Kelebihan utama menggunakan multiprocessing di Python adalah bahawa ia membolehkan pelaksanaan pelbagai proses secara serentak. Ini amat bermanfaat apabila bekerja dengan tugas-tugas intensif CPU, kerana ia membolehkan program menggunakan pelbagai teras CPU, dengan itu meningkatkan kelajuan dan kecekapan program dengan ketara. Tidak seperti threading, multiprocessing tidak mengalami kunci penterjemah global (GIL) di Python, yang bermaksud bahawa setiap proses boleh berjalan secara bebas tanpa terjejas oleh proses lain. Ini menjadikan multiprocessing alat yang berkuasa untuk pengaturcaraan selari dalam python.
Apakah perbezaan antara multiprocessing dan multithreading dalam python? > Perbezaan utama antara multiprocessing dan multithreading dalam python terletak pada bagaimana mereka mengendalikan tugas. Walaupun multiprocessing mencipta proses baru untuk setiap tugas, multithreading mencipta benang baru dalam proses yang sama. Ini bermakna bahawa walaupun multiprocessing boleh memanfaatkan sepenuhnya teras CPU, multithreading dibatasi oleh Lock Interpreter Global (GIL) di Python, yang membolehkan hanya satu benang untuk dilaksanakan pada satu masa. Walau bagaimanapun, multithreading masih boleh berguna untuk tugas-tugas I/O yang terikat, di mana program menghabiskan sebahagian besar waktunya menunggu operasi input/output selesai.
Apakah perangkap yang berpotensi menggunakan multiprocessing dalam python?
- elakkan berkongsi data antara proses apabila mungkin, kerana ini boleh membawa kepada isu penyegerakan kompleks.
- Gunakan kelas kolam untuk menguruskan proses pekerja anda, kerana ia menyediakan antara muka peringkat tinggi yang memudahkan proses membuat dan mengurus proses. program berterusan.Atas ialah kandungan terperinci Panduan untuk Python Multiprocessing dan Pengaturcaraan Selari. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Perbezaan antara berlabuh dan bertujuan
Semak sepuluh mata wang kripto teratas yang bernilai melabur
Pengenalan kepada perisian pemodelan parametrik
Bagaimana untuk menyelesaikan ralat parsererror
Apa yang perlu dilakukan jika notepad.exe tidak bertindak balas
Apakah maksud memformat telefon mudah alih?
Bagaimana untuk membuka fail dmp
Cara menggunakan fungsi isihan
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
