Panduan untuk Python Multiprocessing dan Pengaturcaraan Selari

Mempercepatkan perhitungan adalah matlamat yang semua orang mahu mencapai. Bagaimana jika anda mempunyai skrip yang boleh berjalan sepuluh kali lebih cepat daripada masa berjalan semasa? Dalam artikel ini, kita akan melihat multiprocessing python dan perpustakaan yang dipanggil multiprocessing. Kami akan bercakap tentang apa yang multiprocessing, kelebihannya, dan bagaimana untuk memperbaiki masa berjalan program Python anda dengan menggunakan pengaturcaraan selari.

okay, jadi mari kita pergi!

Takeaways Key

Pengkomputeran selari adalah kaedah untuk mempercepatkan perhitungan dengan menggunakan pelbagai teras CPU secara serentak. Ini dapat dicapai dalam python melalui multiprocessing, modul yang membolehkan penciptaan pelbagai proses, masing -masing berjalan pada teras berasingan.
modul multiprocessing Python memberikan manfaat seperti penggunaan CPU yang lebih baik untuk tugas intensif tinggi, lebih banyak kawalan ke atas proses kanak-kanak berbanding dengan benang, dan pelaksanaan mudah untuk tugas-tugas yang sesuai untuk pengaturcaraan selari.
• multiprocessing python tidak selalu lebih cekap daripada pengkomputeran siri. Untuk tugas-tugas intensif CPU yang rendah, pengiraan siri boleh lebih cepat kerana overhead yang diperkenalkan oleh pemisahan pengiraan antara proses.
• Modul multiprocessing di Python mencipta proses baru untuk setiap tugas yang perlu dilaksanakan secara serentak. Setiap proses mempunyai penterjemah python sendiri dan ruang ingatan, yang membolehkannya berjalan secara bebas dari proses lain.
• Walaupun multiprocessing di Python dapat meningkatkan kelajuan dan kecekapan program, ia juga meningkatkan kerumitan kod. Tidak semua tugas yang sesuai untuk selaras, dan dalam beberapa kes, overhead mewujudkan dan menguruskan pelbagai proses boleh melebihi keuntungan prestasi yang berpotensi.
Pengenalan kepada Paralelisme

Sebelum kita menyelam ke kod python, kita perlu bercakap tentang pengkomputeran selari, yang merupakan konsep penting dalam sains komputer.

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

Bayangkan anda mempunyai masalah besar untuk diselesaikan, dan anda bersendirian. Anda perlu mengira akar kuadrat lapan nombor yang berbeza. Apa yang anda buat? Nah, anda tidak mempunyai banyak pilihan. Anda bermula dengan nombor pertama, dan anda mengira hasilnya. Kemudian, anda pergi dengan yang lain.

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.

model untuk pengaturcaraan selari

Kami telah menubuhkan apa pengaturcaraan selari, tetapi bagaimana kami menggunakannya? Nah, kami katakan sebelum pengkomputeran selari melibatkan pelaksanaan pelbagai tugas di antara pelbagai teras pemproses, yang bermaksud bahawa tugas -tugas tersebut dilaksanakan secara serentak. Terdapat beberapa soalan yang perlu anda pertimbangkan sebelum menghampiri penyejukan. Sebagai contoh, adakah terdapat pengoptimuman lain yang dapat mempercepat perhitungan kami?

Buat masa ini, mari kita ambil perhatian bahawa parallelization adalah penyelesaian terbaik untuk anda. Terdapat tiga model dalam pengkomputeran selari:

sempurna selari. Tugas boleh dijalankan secara bebas, dan mereka tidak perlu berkomunikasi antara satu sama lain.
Paralelisme memori yang dikongsi. Proses (atau benang) perlu berkomunikasi, jadi mereka berkongsi ruang alamat global.
Mesej lulus. Proses perlu berkongsi mesej apabila diperlukan.

Dalam artikel ini, kami akan menggambarkan model pertama, yang juga paling mudah. ​​

multiprocessing python: paralelisme berasaskan proses dalam python

Satu cara untuk mencapai paralelisme dalam Python adalah dengan menggunakan modul multiprocessing. Modul multiprocessing membolehkan anda membuat pelbagai proses, masing -masing dengan penterjemah python sendiri. Atas sebab ini, multiprocessing Python menyelesaikan paralelisme berasaskan proses.

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

Berikut adalah beberapa manfaat multiprocessing:

• penggunaan CPU yang lebih baik ketika berurusan dengan tugas-tugas intensif CPU yang tinggi
• lebih banyak kawalan ke atas kanak -kanak berbanding dengan benang
• mudah untuk kod

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.

Bermula dengan Python Multiprocessing

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:

• Proses induk. Hanya ada satu proses induk, yang boleh mempunyai beberapa kanak -kanak.
• proses kanak -kanak. Ini dibuang oleh ibu bapa. Setiap kanak -kanak juga boleh mempunyai anak -anak baru.

Kami akan menggunakan proses kanak -kanak untuk melaksanakan fungsi tertentu. Dengan cara ini, ibu bapa boleh meneruskan pelaksanaannya.

contoh multiprocessing python mudah

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.

Kelas Proses

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:

• target = bubble_sort, yang bermaksud bahawa proses baru kami akan menjalankan fungsi bubble_sort
• args = ([1,9,4,52,6,8,4],), yang merupakan array yang diluluskan sebagai argumen kepada fungsi sasaran

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.

Kelas kolam

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!

memanfaatkan python multiprocessing python

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.

Kesimpulan

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.

Soalan Lazim Mengenai Python Multiprocessing dan Pengaturcaraan Selari

Apakah kelebihan utama menggunakan multiprocessing dalam python?

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.

Bagaimana modul multiprocessing dalam kerja python? dilaksanakan secara serentak. Setiap proses mempunyai penterjemah python sendiri dan ruang ingatan, yang bermaksud bahawa ia dapat berjalan secara bebas dari proses lain. Modul multiprocessing menyediakan beberapa kelas dan fungsi yang menjadikannya mudah untuk membuat dan mengurus proses ini. Sebagai contoh, kelas proses digunakan untuk membuat proses baru, manakala kelas kolam digunakan untuk menguruskan kumpulan proses pekerja.

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.

Bagaimanakah saya dapat berkongsi data antara proses dalam Python? Ini termasuk kelas nilai dan array, yang membolehkan penciptaan pembolehubah dan tatasusunan bersama. Walau bagaimanapun, penting untuk diperhatikan bahawa kerana setiap proses mempunyai ruang ingatan sendiri, perubahan yang dibuat kepada pembolehubah atau tatasusunan yang dikongsi dalam satu proses tidak akan dapat dilihat dalam proses lain melainkan jika mereka disegerakkan secara jelas menggunakan kunci atau primitif penyegerakan lain yang disediakan oleh modul multiprocessing.

Apakah perangkap yang berpotensi menggunakan multiprocessing dalam python?

Semasa multiprocessing Di Python dapat meningkatkan kelajuan dan kecekapan program anda, ia juga datang dengan cabarannya sendiri. Salah satu perangkap utama ialah peningkatan kerumitan kod anda. Menguruskan pelbagai proses boleh menjadi lebih kompleks daripada menguruskan program tunggal, terutamanya apabila mengendalikan data bersama dan proses penyegerakan. Di samping itu, mewujudkan proses baru adalah lebih intensif sumber daripada mencipta benang baru, yang boleh membawa kepada peningkatan penggunaan memori. Akhirnya, tidak semua tugas yang sesuai untuk penyesuaian, dan dalam beberapa kes, overhead mewujudkan dan menguruskan pelbagai proses boleh melebihi keuntungan prestasi yang berpotensi. 🎜> mengendalikan pengecualian dalam multiprocessing di python boleh sedikit rumit, kerana pengecualian yang berlaku dalam proses kanak -kanak tidak secara automatik menyebarkan kepada proses induk. Walau bagaimanapun, modul multiprocessing menyediakan beberapa cara untuk mengendalikan pengecualian. Salah satu cara ialah menggunakan kaedah IS_alive () kelas proses untuk memeriksa sama ada proses masih berjalan. Sekiranya kaedah itu kembali palsu, ini bermakna proses telah ditamatkan, yang mungkin disebabkan oleh pengecualian. Cara lain ialah menggunakan atribut ExitCode Kelas Proses, yang dapat memberikan lebih banyak maklumat tentang mengapa proses ditamatkan. Perpustakaan Python lain. Walau bagaimanapun, penting untuk diperhatikan bahawa tidak semua perpustakaan direka untuk digunakan dalam persekitaran multiprocessing. Sesetengah perpustakaan mungkin tidak selamat benang atau mungkin tidak menyokong pelaksanaan serentak. Oleh itu, ia adalah idea yang baik untuk menyemak dokumentasi perpustakaan yang anda gunakan untuk melihat sama ada ia menyokong multiprocessing.

Bagaimanakah saya boleh menyahpepijat program multiprocessing di Python? Walau bagaimanapun, terdapat beberapa teknik yang boleh anda gunakan untuk debug program anda. Salah satu cara ialah menggunakan pernyataan cetak atau pembalakan untuk mengesan pelaksanaan program anda. Cara lain ialah menggunakan fungsi set_trace modul PDB untuk menetapkan titik putus dalam kod anda. Anda juga boleh menggunakan alat penyahpepijatan khusus yang menyokong multiprocessing, seperti fungsi log_to_stderr () modul multiprocessing, yang membolehkan anda log aktiviti proses anda ke ralat standard. Sistem Operasi?

Ya, anda boleh menggunakan multiprocessing dalam python pada sistem operasi yang berbeza. Modul multiprocessing adalah sebahagian daripada perpustakaan Python standard, yang bermaksud ia tersedia pada semua platform yang menyokong Python. Walau bagaimanapun, tingkah laku modul multiprocessing mungkin berbeza -beza sedikit antara sistem operasi yang berbeza kerana perbezaan bagaimana mereka mengendalikan proses. Oleh itu, adalah idea yang baik untuk menguji program anda pada sistem pengendalian sasaran untuk memastikan ia berfungsi seperti yang diharapkan. Menggunakan multiprocessing dalam python termasuk:

- 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.

- Mengendalikan pengecualian dengan betul untuk mengelakkan program anda daripada terhempas tanpa diduga.

- Uji program anda dengan teliti untuk memastikan ia berfungsi dengan betul dalam multiprocessing Persekitaran.

Atas ialah kandungan terperinci Panduan untuk Python Multiprocessing dan Pengaturcaraan Selari. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!