Cara menggunakan modul berbilang pemprosesan untuk pengurusan berbilang proses dalam Python 2.x

Cara menggunakan modul berbilang pemprosesan untuk pengurusan berbilang proses dalam Python 2. Dalam Python 2.x, kita boleh menggunakan modul berbilang pemprosesan untuk melaksanakan pengurusan berbilang proses Artikel ini akan memperkenalkan cara menggunakan modul berbilang pemprosesan untuk pengurusan berbilang proses.

Pengenalan kepada modul berbilang pemprosesan:

Modul berbilang pemprosesan ialah modul terbina dalam Python yang menyokong pengaturcaraan berbilang proses. Ia menyediakan kelas Proses, menjadikannya lebih mudah untuk mencipta dan mengurus berbilang proses. Dengan menggunakan modul multiprocessing, kami boleh memperuntukkan tugas kepada berbilang sub-proses untuk pelaksanaan selari, dengan itu meningkatkan kecekapan pelaksanaan program.

1. Buat subproses menggunakan modul berbilang pemprosesan:
   Berikut ialah contoh kod untuk mencipta subproses menggunakan modul berbilang pemprosesan:

2. from multiprocessing import Process
   
   def func():
       # 子进程要执行的代码
       print("This is a child process.")
   
   if __name__ == "__main__":
       # 创建子进程
       p = Process(target=func)
       # 启动子进程
       p.start()
       # 等待子进程结束
       p.join()
       # 输出结果
       print("This is the main process.")

   
   Dalam kod sampel di atas, kami mula-mula mengimport kelas Proses dan kemudian menentukan fungsi func sebagai anak proses Kod untuk dilaksanakan. Dalam fungsi utama, kami mencipta objek Proses p dan menentukan fungsi yang akan dilaksanakan sebagai fungsi melalui parameter sasaran. Kemudian mulakan subproses dengan memanggil kaedah p.start() dan kemudian panggil kaedah p.join() untuk menunggu subproses tamat. Akhirnya keluarkan hasilnya.

Gunakan modul berbilang pemprosesan untuk mencipta berbilang sub-proses:

Untuk tugas yang kompleks, kita selalunya perlu mencipta berbilang sub-proses untuk dilaksanakan secara selari. Berikut ialah contoh kod yang menggunakan modul berbilang pemprosesan untuk mencipta berbilang sub-proses:

3. from multiprocessing import Process
   
   def func(index):
       # 子进程要执行的代码
       print("This is child process %d." % index)
   
   if __name__ == "__main__":
       # 创建多个子进程
       processes = []
       for i in range(5):
           p = Process(target=func, args=(i,))
           processes.append(p)
       # 启动所有子进程
       for p in processes:
           p.start()
       # 等待所有子进程结束
       for p in processes:
           p.join()
       # 输出结果
       print("This is the main process.")

   
   Dalam kod sampel di atas, kami menggunakan gelung untuk mencipta 5 sub-proses Fungsi fungsi setiap sub-proses menerima parameter indeks, yang mewakili nombor sub-proses. Apabila mencipta proses kanak-kanak, kami menghantar indeks parameter kepada proses kanak-kanak melalui parameter args, supaya setiap proses kanak-kanak melaksanakan tugas yang berbeza.

Gunakan modul berbilang pemprosesan untuk melaksanakan komunikasi antara proses:

Dalam pengaturcaraan berbilang proses, kadangkala perlu berkomunikasi dengan berbilang proses. Modul multiprocessing menyediakan beberapa kelas Queue untuk menghantar data antara proses. Berikut ialah contoh kod yang menggunakan kelas Queue untuk melaksanakan komunikasi antara proses:

4. from multiprocessing import Process, Queue
   
   def producer(queue):
       # 生产者进程
       for i in range(5):
           item = "item %d" % i
           queue.put(item)
           print("Produced", item)
   
   def consumer(queue):
       # 消费者进程
       while True:
           item = queue.get()
           print("Consumed", item)
           if item == "item 4":
               break
   
   if __name__ == "__main__":
       # 创建Queue对象
       queue = Queue()
       # 创建生产者进程和消费者进程
       p1 = Process(target=producer, args=(queue,))
       p2 = Process(target=consumer, args=(queue,))
       # 启动子进程
       p1.start()
       p2.start()
       # 等待子进程结束
       p1.join()
       p2.join()
       # 输出结果
       print("This is the main process.")
   

   
   Dalam kod sampel di atas, kami mencipta objek baris gilir melalui kelas Queue untuk menghantar data antara proses pengeluar dan proses pengguna. Dalam proses pengeluar, kami menggunakan kaedah put untuk meletakkan data ke dalam baris gilir, dalam proses pengguna, kami menggunakan kaedah dapatkan untuk mengeluarkan data daripada baris gilir. Apabila baris gilir kosong, proses pengguna akan menyekat secara automatik sehingga terdapat data dalam baris gilir untuk diambil. Dalam kod sampel, proses pengeluar meletakkan 5 item ke dalam baris gilir, dan kemudian proses pengguna mengambil item dari baris gilir dan mencetaknya. Apabila item yang dibawa keluar adalah "item 4", proses pengguna berakhir.

Kesimpulan:

Menggunakan modul berbilang pemprosesan untuk pengurusan berbilang proses boleh meningkatkan kecekapan pelaksanaan program dengan berkesan. Melalui pengenalan artikel ini, pembaca boleh belajar cara menggunakan modul berbilang pemprosesan untuk mencipta sub-proses, mencipta berbilang sub-proses untuk pelaksanaan selari dan melaksanakan komunikasi antara proses. Semoga artikel ini berguna untuk pengaturcaraan berbilang proses dalam Python 2.x.

Atas ialah kandungan terperinci Cara menggunakan modul berbilang pemprosesan untuk pengurusan berbilang proses dalam Python 2.x. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!