TypeError: can ' T pickle _thread.lock-Objekte

Versuchen, zwei unterschiedliche Funktionen in der gleichen Zeit mit gemeinsamen Warteschlange und bekomme eine Fehlermeldung...wie kann ich zwei Funktionen gleichzeitig mit einer gemeinsamen Warteschlange? Dies ist die Python-version 3.6 unter Windows 7.

from multiprocessing import Process
from queue import Queue
import logging

def main():
    x = DataGenerator()
    try:
        x.run()
    except Exception as e:
        logging.exception("message")


class DataGenerator:

    def __init__(self):
        logging.basicConfig(filename='testing.log', level=logging.INFO)

    def run(self):
        logging.info("Running Generator")
        queue = Queue()
        Process(target=self.package, args=(queue,)).start()
        logging.info("Process started to generate data")
        Process(target=self.send, args=(queue,)).start()
        logging.info("Process started to send data.")

    def package(self, queue): 
        while True:
            for i in range(16):
                datagram = bytearray()
                datagram.append(i)
                queue.put(datagram)

    def send(self, queue):
        byte_array = bytearray()
        while True:
            size_of__queue = queue.qsize()
            logging.info(" queue size %s", size_of_queue)
            if size_of_queue > 7:
                for i in range(1, 8):
                    packet = queue.get()
                    byte_array.append(packet)
                logging.info("Sending datagram ")
                print(str(datagram))
                byte_array(0)

if __name__ == "__main__":
    main()

Die Protokolle geben einen Fehler, ich habe versucht mit console als administrator an und ich bekomme die gleiche Meldung...

INFO:root:Running Generator
ERROR:root:message
Traceback (most recent call last):
  File "test.py", line 8, in main
    x.run()
  File "test.py", line 20, in run
    Process(target=self.package, args=(queue,)).start()
  File "C:\ProgramData\Miniconda3\lib\multiprocessing\process.py", line 105, in start
    self._popen = self._Popen(self)
  File "C:\ProgramData\Miniconda3\lib\multiprocessing\context.py", line 223, in _Popen
    return _default_context.get_context().Process._Popen(process_obj)
  File "C:\ProgramData\Miniconda3\lib\multiprocessing\context.py", line 322, in _Popen
    return Popen(process_obj)
  File "C:\ProgramData\Miniconda3\lib\multiprocessing\popen_spawn_win32.py", line 65, in __init__
    reduction.dump(process_obj, to_child)
  File "C:\ProgramData\Miniconda3\lib\multiprocessing\reduction.py", line 60, in dump
    ForkingPickler(file, protocol).dump(obj)
TypeError: can't pickle _thread.lock objects

queue.Queue ist für die inter-thread-Kommunikation. multiprocessing.Queue ist für das senden Dinge zwischen Prozessen.
Ich habe die änderung zu multiprocessing.Queue und, dass das Problem behoben wurde. Danke.

InformationsquelleAutor Jonathan Kittell | 2017-05-23

python-3.x

5

multiprocessing.Pool - PicklingError: Can ' T pickle <geben Sie 'thread.lock'>: - Attribut-lookup-thread.Sperre fehlgeschlagen

Bewegen Sie die Warteschlange, um sich selbst, anstatt als argument, um Ihre Funktionen package und send

InformationsquelleAutor PvdL

Ich hatte das gleiche problem mit Pool() in Python 3.6.3.

Fehler erhalten: TypeError: can't pickle _thread.RLock objects

Sagen wir, wir wollen, fügen Sie einige Anzahl num_to_add auf jedes element der Liste einige num_list parallel. Der code ist schematisch so:

class DataGenerator:
    def __init__(self, num_list, num_to_add)
        self.num_list = num_list # e.g. [4,2,5,7]
        self.num_to_add = num_to_add # e.g. 1 

        self.run()

    def run(self):
        new_num_list = Manager().list()

        pool = Pool(processes=50)
        results = [pool.apply_async(run_parallel, (num, new_num_list)) 
                      for num in num_list]
        roots = [r.get() for r in results]
        pool.close()
        pool.terminate()
        pool.join()

    def run_parallel(self, num, shared_new_num_list):
        new_num = num + self.num_to_add # uses class parameter
        shared_new_num_list.append(new_num)

Hier das problem, dass self in Funktion run_parallel() kann nicht gebeizt werden, da es eine Instanz der Klasse. Verschieben diese Funktion parallelisiert run_parallel() aus der Klasse geholfen. Aber es ist nicht die beste Lösung, da diese Funktion wohl nutzen muss, die Klasse Parameter wie self.num_to_add und dann übergibt man es als argument.

Lösung:

def run_parallel(num, shared_new_num_list, to_add): # to_add is passed as an argument
    new_num = num + to_add
    shared_new_num_list.append(new_num)

class DataGenerator:
    def __init__(self, num_list, num_to_add)
        self.num_list = num_list # e.g. [4,2,5,7]
        self.num_to_add = num_to_add # e.g. 1

        self.run()

    def run(self):
        new_num_list = Manager().list()

        pool = Pool(processes=50)
        results = [pool.apply_async(run_parallel, (num, new_num_list, self.num_to_add)) # num_to_add is passed as an argument
                      for num in num_list]
        roots = [r.get() for r in results]
        pool.close()
        pool.terminate()
        pool.join()

Anderen Vorschläge oben hat mir nicht helfen.

InformationsquelleAutor Marina

2

Müssen Sie ändern from queue import Queue zu from multiprocessing import Queue.

Die Wurzel Grund ist die ehemalige Warteschlange ist ausgelegt für Gewinde für Modul-Warteschlange, während die letzteren ist für multiprocessing.Prozess-Modul.

Für details, Lesen Sie einige source-code oder Kontaktieren Sie mich!

InformationsquelleAutor user8675687

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.