Bagaimanakah Python's Multithreading Meningkatkan Kecekapan Kod Menggunakan `map` dan `pool`?

Menggunakan Benang dalam Python

Dalam dunia pengaturcaraan yang sentiasa berkembang, penggunaan berbilang benang telah menjadi semakin berharga untuk meningkatkan kecekapan kod . Artikel ini bertujuan untuk memberikan contoh komprehensif yang mempamerkan cara mengagihkan tugasan dengan berkesan merentas berbilang urutan dalam Python.

Berbilang benang dengan peta dan kumpulan

Ular Python Moden menawarkan kesederhanaan yang ketara apabila ia datang ke multithreading dengan pengenalan peta dan kumpulan. Coretan kod di bawah, yang diperoleh daripada artikel terkenal tentang "Paralelisme dalam satu baris," dengan elegan menunjukkan kuasa pendekatan ini:

from multiprocessing.dummy import Pool as ThreadPool
pool = ThreadPool(4)
results = pool.map(my_function, my_array)

Kod berbilang benang ini berfungsi sebagai setara dengan versi satu benang berikut:

results = []
for item in my_array:
    results.append(my_function(item))

Pemahaman map

Peta, fungsi serba boleh dalam Python, memudahkan keselarian dengan menggunakan fungsi tertentu pada setiap elemen dalam urutan. Ia dengan cekap melelakan jujukan, melaksanakan fungsi dan mengagregatkan hasil ke dalam senarai.

Berbilang pemprosesan dan berbilang pemprosesan dummy

Berbilang pemprosesan dan adik-beradiknya yang kurang dikenali, berbilang pemprosesan .dummy, tawarkan versi selari fungsi peta. Walaupun multiprocessing menggunakan berbilang proses, varian dummy menggunakan benang, menjadikannya ideal untuk tugasan intensif input/output.

Pelaksanaan dengan multiprocessing.dummy

Pertimbangkan kod berikut coretan, yang memanfaatkan multiprocessing.dummy untuk membuka berbilang URL serentak:

import urllib2
from multiprocessing.dummy import Pool as ThreadPool

urls = [
  'http://www.python.org',
  'http://www.python.org/about/',
  'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
  'http://www.python.org/doc/',
  'http://www.python.org/download/',
  'http://www.python.org/getit/',
  'http://www.python.org/community/',
  'https://wiki.python.org/moin/',
]

pool = ThreadPool(4)
results = pool.map(urllib2.urlopen, urls)
pool.close()
pool.join()

Hasil pemasaan menggambarkan peningkatan prestasi yang ketara menggunakan berbilang urutan:

Single thread:   14.4 seconds
       4 Pool:   3.1 seconds
       8 Pool:   1.4 seconds
      13 Pool:   1.3 seconds

Meluluskan berbilang argumen

Dalam Python 3.3 dan kemudian, menghantar berbilang argumen kepada fungsi dalam kolam boleh dilakukan menggunakan yang berikut teknik:

• Melalui berbilang tatasusunan:

results = pool.starmap(function, zip(list_a, list_b))

• Melalui pemalar dan tatasusunan:

results = pool.starmap(function, zip(itertools.repeat(constant), list_a))

Atas ialah kandungan terperinci Bagaimanakah Python's Multithreading Meningkatkan Kecekapan Kod Menggunakan `map` dan `pool`?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!