Bagaimana untuk mengendalikan ralat 'Pipa Tertutup' dengan baik dalam komunikasi paip pelbagai proses Python?

Python Multi-Process Pipa Komunikasi: Penyelesaian Elegant Untuk Kesalahan "Paip Tertutup"

Anda mungkin menghadapi kesilapan "Pipa Tertutup" sakit kepala apabila menggunakan kaedah Pipe dalam modul multiprocessing Python untuk komunikasi interprocess. Artikel ini akan menganalisis masalah ini secara mendalam dan memberikan penyelesaian yang lebih mantap.

Masalah biasanya berlaku dalam senario komunikasi proses ibu bapa dan kanak-kanak. Sebagai contoh, selepas proses kanak-kanak melakukan tugas yang memakan masa, ia menghantar data ke proses induk melalui saluran paip dan menunggu isyarat proses induk untuk mengakhiri dirinya sendiri. Sekiranya proses induk berakhir lebih awal dan proses kanak -kanak cuba menerima data dari saluran paip tertutup, kesilapan "saluran paip tertutup" dinaikkan.

Semasa menambah time.sleep() dan secara eksplisit menutup proses kanak -kanak dalam proses induk dapat menyelesaikan masalah, ini bukan penyelesaian yang ideal kerana ia bergantung pada menunggu dan mengawal proses induk aktif.

Penyelesaian yang lebih elegan adalah untuk menangkap pengecualian EOFError dalam proses kanak -kanak . Pengecualian ini dibangkitkan apabila proses kanak -kanak cuba menerima data dari saluran paip apabila proses induk berakhir lebih awal. Dengan menangkap pengecualian ini, proses kanak -kanak boleh keluar dengan anggun, mengelakkan kemalangan program.

Berikut ini menunjukkan service.py yang lebih baik.py dan single.py Code:

service.py yang lebih baik.py:

 Import OS
dari proses import multiprocessing, paip

def start_child_process (child_conn):
    # Mensimulasikan tugas memakan masa# run_server_for_long_time ()
    child_conn.send ({"port": 123, "ret": 1, "pid": os.getpid ()})

    Cuba:
        isyarat = child_conn.recv () # tunggu isyarat proses induk jika isyarat:
            child_conn.close ()
    Kecuali eoferror sebagai e:
        cetak (f "eoferror: {e}") # Pengendalian elegan Pengecualian # Anda boleh menambah kerja pembersihan yang diperlukan di sini pelayan kelas:
    def __init __ (diri):
        self.child_conn = Tiada
        self.child = Tiada
        self.parent_conn, self.child_conn = paip ()

    Def Run (Diri):
        self.child = proses (sasaran = start_child_process, name = "my_child_process", args = (self.child_conn,))
        self.child.start ()

        data = self.parent_conn.recv ()
        hasil = {
            "endpoints": {
                "http": f "http://127.0.0.1: {data }/cmd",
                "WS": F "WS: //127.0.0.1: {data ['port']}/api",
            }
        }
        Keputusan pulangan

    Def berhenti (diri):
        self.parent_conn.send (benar)
        self.child.join ()
        self.child = Tiada

jika __name__ == "__main__":
    pelayan = pelayan ()
    r = server.run ()
    cetak ("r:", r)

single.py yang lebih baik:

 dari pelayan import perkhidmatan

def utama ():
    pelayan = pelayan ()
    hasil = server.run ()
    Cetak ("R:", Hasil)
    # server.stop () # Pilihan: Secara jelas menghentikan proses kanak -kanak jika __name__ == "__main__":
    utama ()

Menangkap EOFError dengan menambah try...except blok dalam proses kanak -kanak, proses kanak -kanak berakhir dengan anggun walaupun proses induk keluar tanpa diduga, mengelakkan kesilapan "saluran paip tertutup". Pendekatan ini meningkatkan keteguhan program tanpa bergantung pada operasi penutupan eksplisit proses induk.

Atas ialah kandungan terperinci Bagaimana untuk mengendalikan ralat 'Pipa Tertutup' dengan baik dalam komunikasi paip pelbagai proses Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!