Python 에서 Actor 작업 을 정의 합 니 다.

문제.
actor 모드 에서'actors'캐릭터 와 유사 한 작업 을 정의 하고 싶 습 니 다.
해결 방안
actor 모델 은 가장 오래 되 고 가장 간단 한 병행 과 분포 식 계산 해결 방안 이다.사실 타고 난 단순 성 이 이렇게 인기 있 는 중요 한 원인 중 하나 다.쉽게 말 하면 하나의 actor 는 동시에 수행 하 는 임무 이 고 그 에 게 보 낸 메시지 임 무 를 간단하게 수행 할 뿐이다.이 메시지 에 응답 할 때 다른 actor 에 더 많은 메 시 지 를 보 낼 수 있 습 니 다.actor 간 의 통신 은 단 방향 과 비동기 이다.따라서 메시지 발송 자 는 메시지 가 언제 발송 되 는 지 모 르 고 메시지 가 처 리 된 응답 이나 통 지 를 받 지 못 한다.
하나의 스 레 드 와 하나의 대기 열 을 결합 하면 actor 를 쉽게 정의 할 수 있 습 니 다.예 를 들 어:

from queue import Queue
from threading import Thread, Event

# Sentinel used for shutdown
class ActorExit(Exception):
  pass

class Actor:
  def __init__(self):
    self._mailbox = Queue()

  def send(self, msg):
    '''
    Send a message to the actor
    '''
    self._mailbox.put(msg)

  def recv(self):
    '''
    Receive an incoming message
    '''
    msg = self._mailbox.get()
    if msg is ActorExit:
      raise ActorExit()
    return msg

  def close(self):
    '''
    Close the actor, thus shutting it down
    '''
    self.send(ActorExit)

  def start(self):
    '''
    Start concurrent execution
    '''
    self._terminated = Event()
    t = Thread(target=self._bootstrap)

    t.daemon = True
    t.start()

  def _bootstrap(self):
    try:
      self.run()
    except ActorExit:
      pass
    finally:
      self._terminated.set()

  def join(self):
    self._terminated.wait()

  def run(self):
    '''
    Run method to be implemented by the user
    '''
    while True:
      msg = self.recv()

# Sample ActorTask
class PrintActor(Actor):
  def run(self):
    while True:
      msg = self.recv()
      print('Got:', msg)

# Sample use
p = PrintActor()
p.start()
p.send('Hello')
p.send('World')
p.close()
p.join()

이 예 에서 actor 인 스 턴 스 send() 방법 으로 메 시 지 를 보 냅 니 다.이 방법 은 한 팀 에 메 시 지 를 넣 고 받 아들 여진 메 시 지 를 처리 하 는 내부 라인 에 전달 하 는 메커니즘 이다.close() 방법 은 대기 열 에 특수 한 보초병 값(ActorExit)을 넣 어 이 actor 를 닫 습 니 다.사용 자 는 Actor 를 계승 하고 자신의 처리 논리 run()방법 을 정의 하여 새로운 actor 를 정의 할 수 있 습 니 다.ActorExit이상 한 사용 은 사용자 정의 코드 가 필요 할 때 종료 요청(이상 get()방법 에 의 해 던 져 지고 전 파 될 수 있 음)을 캡 처 하 는 것 입 니 다.
동기 화 및 비동기 메시지 전송 에 대한 요 구 를 완화 하면 클래스 actor 대상 은 생 성 기 를 통 해 정 의 를 간소화 할 수 있 습 니 다.예 를 들 면:

def print_actor():
  while True:

    try:
      msg = yield   # Get a message
      print('Got:', msg)
    except GeneratorExit:
      print('Actor terminating')

# Sample use
p = print_actor()
next(p)   # Advance to the yield (ready to receive)
p.send('Hello')
p.send('World')
p.close()

토론 하 다.
actor 모델 의 매력 은 단순 성에 있다.실제로 여 기 는 하나의 핵심 조작send() 만 있 을 뿐이다.심지어 actor 시스템 을 바탕 으로 하 는'메시지'에 대한 일반화 개념 은 여러 가지 방식 으로 확 대 될 수 있다.예 를 들 어 태그 메 시 지 를 원 그룹 으로 전달 하여 actor 가 서로 다른 작업 을 수행 하도록 할 수 있 습 니 다.다음 과 같 습 니 다.

class TaggedActor(Actor):
  def run(self):
    while True:
       tag, *payload = self.recv()
       getattr(self,'do_'+tag)(*payload)

  # Methods correponding to different message tags
  def do_A(self, x):
    print('Running A', x)

  def do_B(self, x, y):
    print('Running B', x, y)

# Example
a = TaggedActor()
a.start()
a.send(('A', 1))   # Invokes do_A(1)
a.send(('B', 2, 3))  # Invokes do_B(2,3)
a.close()
a.join()

다른 예 로 다음 actor 는 한 작업 자 에서 임의의 함 수 를 실행 하고 특수 한 Result 대상 을 통 해 결 과 를 되 돌려 줍 니 다.

from threading import Event
class Result:
  def __init__(self):
    self._evt = Event()
    self._result = None

  def set_result(self, value):
    self._result = value

    self._evt.set()

  def result(self):
    self._evt.wait()
    return self._result

class Worker(Actor):
  def submit(self, func, *args, **kwargs):
    r = Result()
    self.send((func, args, kwargs, r))
    return r

  def run(self):
    while True:
      func, args, kwargs, r = self.recv()
      r.set_result(func(*args, **kwargs))

# Example use
worker = Worker()
worker.start()
r = worker.submit(pow, 2, 3)
worker.close()
worker.join()
print(r.result())

마지막 으로'전송'작업 메시지 의 개념 은 다 중 프로 세 스,심지어 대형 분포 식 시스템 으로 확 대 될 수 있다.예 를 들 어 하나의 actor 대상send() 방법 은 소켓 연결 에 데 이 터 를 전송 하거나 특정한 메시지 미들웨어(예 를 들 어 AMQP,ZMQ 등)를 통 해 보 낼 수 있 도록 프로 그래 밍 될 수 있다.
이상 은 Python 이 Actor 작업 을 정의 하 는 상세 한 내용 입 니 다.Python actor 작업 에 관 한 자 료 는 다른 관련 글 을 주목 하 십시오!