Многопроцессорная обработка с несколькими объектами классов

Вы хотите передать рабочие экземпляры своих классов, а затем вызвать метод push каждого из них. Классы не подлежат сериализации (внутренне Python использует для этого стандартную библиотеку pickle) и не могут передаваться в качестве аргументов рабочим процессам.

С другой стороны, экземпляры обычного класса могут передаваться (обратите внимание, что специальные классы, созданные расширениями в собственном коде, могут не иметь поддержки Pickle - но это можно реализовать - проверьте документацию протокола Pickle) - и тогда все рабочие нужно сделать, это вызвать метод push для каждого.

TL;DR: вы должны заставить его работать, изменив оболочку и одну строку карты:

...
def push_wrapper(push_callable):
    return push_callable()
...
with Pool(...) as pool:
    pool.map(push_wrapper, (cls().push for cls in class_objects))
...

Обратите внимание, что выражение (cls().push for cls in class_objects) является выражением-генератором, то есть итерацией, приемлемой для pool.map, и для каждого элемента в последовательности вашего класса создается экземпляр (cls()) и ссылается на его метод .push как целевой вызываемый объект, который будет запущен в рабочем процессе. .

Подпроцесс (или любая подключаемая библиотека) будет сериализовать только что созданный экземпляр (если вам нужна ссылка на экземпляр в корневом процессе, измените код по своему усмотрению) вместе со ссылкой на его метод push.

Ваш вопрос несколько расплывчатый. Если push_wrapper ожидает передачи экземпляра класса, экземпляр которого был создан основным процессом (что, судя по коду, так и есть), но вы хотите, чтобы вызовы метода push выполнялись параллельно, тогда:

class A:
    def __init__(self):
        print('A.__init__ called')

    def push(self):
        print('A.push called')

class B:
    def __init__(self):
        print('B.__init__ called')

    def push(self):
        print('B.push called')

def push_wrapper(class_instance):
    class_instance.push()

def main():
    from multiprocessing import Pool

    class_instances = [A(), B()]

    with Pool() as pool:
        pool.map(push_wrapper, class_instances)

if __name__ == '__main__':
    main()

Распечатки:

A.__init__ called
B.__init__ called
A.push called
B.push called

Но это не соответствует приведенному вами описанию на английском языке, а именно:

3. Все эти методы должны выполняться параллельно.

Итак, если вы действительно хотите параллельно выполнить создание экземпляра класса с последующим вызовом push (т. е. «все эти методы»), то вы можете передать своей рабочей функции имя класса следующим образом:

class A:
    def __init__(self):
        print('A.__init__ called')

    def push(self):
        print('A.push called')

class B:
    def __init__(self):
        print('B.__init__ called')

    def push(self):
        print('B.push called')


def create_class_instance(class_name, *args, **kwargs):
    the_class = globals()[class_name]
    return the_class(*args, **kwargs)

def push_wrapper(class_name):
    class_instance = create_class_instance(class_name)
    class_instance.push()

def main():
    from multiprocessing import Pool

    class_names = ['A', 'B']

    with Pool() as pool:
        pool.map(push_wrapper, class_names)

if __name__ == '__main__':
    main()

Распечатки:

A.__init__ called
A.push called
B.__init__ called
B.push called

Другой способ передачи типов классов

class A:
    def __init__(self):
        print('A.__init__ called')

    def push(self):
        print('A.push called')

class B:
    def __init__(self):
        print('B.__init__ called')

    def push(self):
        print('B.push called')


def create_class_instance(class_type, *args, **kwargs):
    return class_type(*args, **kwargs)
    # Or return class_type.__call__(*args, **kwargs)

def push_wrapper(class_type):
    class_instance = create_class_instance(class_type)
    class_instance.push()

def main():
    from multiprocessing import Pool

    class_types = [A, B]

    with Pool() as pool:
        pool.map(push_wrapper, class_types)

if __name__ == '__main__':
    main()

Распечатки:

A.__init__ called
A.push called
B.__init__ called
B.push called

И если вы, возможно, указываете имя класса в другом пакете/модуле

Мы предполагаем, что каждый класс реализует метод append:

class A:
    def __init__(self, l=None):
        self.l = l or []

    def append(self, value):
        self.l.append(value)


    def __repr__(self):
        return f'A({self.l})'

def create_class_instance(package_class_name, *args, **kwargs):
    parts = package_class_name.split('.')
    l = len(parts)
    if l != 1:
        package_name = '.'.join(parts[0:l-1])
        class_name = parts[-1]
        module = __import__(package_name, globals(), locals(), [class_name])
        return module.__dict__[class_name](*args, *kwargs)
    return globals()[package_class_name](*args, **kwargs)

def append_wrapper(package_class_name, *args, **kwargs):
    class_instance = create_class_instance(package_class_name, *args, **kwargs)
    class_instance.append(4)
    print(class_instance)

def main():
    from multiprocessing import Pool

    class_names_and_args = [
        ('A', [1, 2, 3]),
        ('collections.deque', [1, 2, 3]),
        ('array.array', 'i', [1, 2, 3])
    ]

    with Pool() as pool:
        pool.starmap(append_wrapper, class_names_and_args)

if __name__ == '__main__':
    main()

Распечатки:

A([1, 2, 3, 4])
deque([1, 2, 3, 4])
array('i', [1, 2, 3, 4])