Theo mặc định, mã chạy trong các quy trình khác nhau không chia sẻ cùng một dữ liệu. Tuy nhiên, mô-đun
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
import multiprocessing
plain_num = 0
shared_num = multiprocessing.Value['d', 0]
lock = multiprocessing.Lock[]
def increment[]:
global plain_num
with lock:
# ordinary variable modifications are not visible across processes
plain_num += 1
# multiprocessing.Value modifications are
shared_num.value += 1
ps = [multiprocessing.Process[target=increment] for n in range[4]]
for p in ps:
p.start[]
for p in ps:
p.join[]
print["plain_num is %d, shared_num is %d" % [plain_num, shared_num.value]]
# Out: plain_num is 0, shared_num is 4
Tôi có một đối tượng Python khá phức tạp mà tôi cần chia sẻ giữa nhiều quy trình. Tôi khởi chạy các quy trình này bằng cách sử dụng
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Tôi đã thử sử dụng đa xử lý. Giá trị. Nhưng tôi không chắc loại nên là gì? . Nhưng khi tôi thử
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Có ai biết cái gì đang xảy ra không?
Giải pháp tốt nhất
Sau khi nghiên cứu và thử nghiệm rất nhiều, tôi thấy "Người quản lý" thực hiện công việc này ở cấp độ đối tượng không phức tạp
Đoạn mã dưới đây cho thấy đối tượng
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class SimpleClass[object]:
def __init__[self]:
self.var = 0
def set[self, value]:
self.var = value
def get[self]:
return self.var
def change_obj_value[obj]:
obj.set[100]
if __name__ == '__main__':
BaseManager.register['SimpleClass', SimpleClass]
manager = BaseManager[]
manager.start[]
inst = manager.SimpleClass[]
p = Process[target=change_obj_value, args=[inst]]
p.start[]
p.join[]
print inst #
print inst.get[] # 100
Được rồi, mã trên là đủ nếu bạn chỉ cần chia sẻ các đối tượng đơn giản
Tại sao không phức tạp?
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Tôi nghĩ lý do chính của hành vi này là vì
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Vì vậy, phương pháp này không được khuyến nghị tốt cho trường hợp đa xử lý. Sẽ luôn tốt hơn nếu bạn có thể sử dụng các công cụ cấp thấp như lock/semaphore/pipe/queue hoặc các công cụ cấp cao như Redis queue hoặc Redis publish/subscribe cho trường hợp sử dụng phức tạp [chỉ đề xuất của tôi lol]
Giải pháp liên quan
Python - Sự khác biệt giữa staticmethod và classmethod
Có lẽ một chút mã ví dụ sẽ giúp. Lưu ý sự khác biệt trong chữ ký cuộc gọi của
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Dưới đây là cách thông thường mà một đối tượng gọi một phương thức. Thể hiện của đối tượng,
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Với các phương thức lớp, lớp của thể hiện đối tượng được chuyển hoàn toàn làm đối số đầu tiên thay vì
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Bạn cũng có thể gọi
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Một cách sử dụng mà mọi người đã tìm thấy cho các phương thức lớp là tạo các hàm tạo thay thế có thể kế thừa
Với các phương thức tĩnh, cả
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Các phương thức tĩnh được sử dụng để nhóm các hàm có một số kết nối logic với một lớp với lớp
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Với
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Ở đây, với một phương thức tĩnh, mặc dù nó là một phương thức, nhưng
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Và tất nhiên, điều tương tự cũng xảy ra khi bạn gọi
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter[object]:
def __init__[self]:
self.var = None
def set[self, value]:
self.var = value
def get[self]:
return self.var
class ChildClass[GetSetter]:
pass
class ParentClass[GetSetter]:
def __init__[self]:
self.child = ChildClass[]
GetSetter.__init__[self]
def getChild[self]:
return self.child
def change_obj_value[obj]:
obj.set[100]
obj.getChild[].set[100]
if __name__ == '__main__':
BaseManager.register['ParentClass', ParentClass]
manager = BaseManager[]
manager.start[]
inst2 = manager.ParentClass[]
p2 = Process[target=change_obj_value, args=[inst2]]
p2.start[]
p2.join[]
print inst2 #
print inst2.getChild[] #
print inst2.get[] # 100
#good!
print inst2.getChild[].get[] # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :]
Sự khác biệt giữa một quá trình và một chủ đề
Cả quy trình và luồng đều là các chuỗi thực thi độc lập. Sự khác biệt điển hình là các luồng [của cùng một quy trình] chạy trong một không gian bộ nhớ dùng chung, trong khi các quy trình chạy trong các không gian bộ nhớ riêng biệt
Tôi không chắc bạn có thể đang đề cập đến chủ đề "phần cứng" và "phần mềm" nào. Các luồng là một tính năng của môi trường hoạt động, chứ không phải là một tính năng của CPU [mặc dù CPU thường có các hoạt động giúp cho các luồng hoạt động hiệu quả]
Erlang sử dụng thuật ngữ "quy trình" vì nó không hiển thị mô hình đa chương trình bộ nhớ dùng chung. Gọi chúng là "chủ đề" có nghĩa là chúng có bộ nhớ dùng chung
Đa xử lý có chia sẻ bộ nhớ không?
shared_memory — Bộ nhớ dùng chung để truy cập trực tiếp giữa các quy trình . Mới trong phiên bản 3. 8. Mô-đun này cung cấp một lớp, SharedMemory, để phân bổ và quản lý bộ nhớ dùng chung được truy cập bởi một hoặc nhiều quy trình trên máy đa xử lý hoặc đa xử lý đối xứng [SMP].
Đa xử lý Python là gì?
đa xử lý là gói hỗ trợ các quy trình sinh sản bằng API tương tự như mô-đun phân luồng . Gói đa xử lý cung cấp cả đồng thời cục bộ và từ xa, hỗ trợ hiệu quả Khóa thông dịch viên toàn cầu bằng cách sử dụng các quy trình con thay vì các luồng.