Question

在Python中，人们习惯于做

def runTaskInNonEDT():
  pass
tRunTask = threading.Thread( target = runTaskInNonEDT )
tRunTask.start()

在Jython中，我发现如果我想向EDT提交一个方法，我必须去

def makeRunnableClass():
  class RunnableClass( Runnable ):
    def run( rSelf ):
      pass
  return RunnableClass
SwingUtilities.invokeAndWait( makeRunnableClass()() )

显然，你有关于传递参数等的随之而来的问题。我只是想知道是否可能有更快速的，更多的Pythonesque方式向EDT提交方法？

@lvc

谢谢......是的，事实上我得到了......实际上是成语

def makeSthgClass():
  class SthgClass():
    pass
  return SthgClass

是我惯用的，只是为了阻止使用一次性子类化实例的类名来混淆命名空间。

事实上，我已经得到了减轻任务的责任

def runToMessageTree( self, method, *args, **kvargs ):
  if SwingUtilities.isEventDispatchThread():
    method( *args, **kvargs )
  else:
    def makeRunnableClass():
      class RunnableClass( Runnable ):
        def run( self ):
          method( *args, **kvargs )
      return RunnableClass
    SwingUtilities.invokeAndWait( makeRunnableClass()() )

所以你可以去

def doSthg():
  pass
self.runToMessageTree( doSthg )

......但没有什么令人满意的Pythonic关于它。

后：

  class EDTWorkerThread( WorkerThread ):
    def __init__( ewt_self, name ):
      super( EDTWorkerThread, ewt_self ).__init__( name )
      class EDTWorker( SwingWorker ):
        def doInBackground(self ):
          check_event_thread( False )
          while True:
            method_call_elements = ewt_self.input_queue.get()
            if method_call_elements is None: # "poison pill"
              break
            self.super__publish( [ method_call_elements ])
          ewt_self.input_queue.task_done()
          return
        def process( self, chunks ):
          check_event_thread( True )
          for chunk in chunks:
            assert type( chunk ) is list
            assert chunk # i.e. must have at least one element!
            # check that first item is callable
            assert hasattr( chunk[ 0 ], "__call__" )
            method_call_elements = chunk
            method_args = method_call_elements[ 1 : ] 
            method_call_elements[ 0 ]( *method_args )
            ewt_self.input_queue.task_done()
      ewt_self.swing_worker = EDTWorker()
    def run( self ):
      self.swing_worker.execute()

ẀorkerThread是一个非常简单，经典的python成语：

class WorkerThread( threading.Thread ):
  def __init__( self, *args, **kvargs ):
    threading.Thread.__init__( self, *args, **kvargs )
    self.input_queue = Queue()

  def send( self, item ):
    assert type( item ) is list
    assert item # i.e. must have at least one element!
    # check that first item is callable
    assert hasattr( item[ 0 ], "__call__" )
    self.input_queue.put( item )

  def close( self ):
    self.input_queue.put( None )
    self.input_queue.join()

  def run( self ):
    while True:
      method_call_elements = self.input_queue.get()
      if method_call_elements is None: # "poison pill"
        break
      method_args = method_call_elements[ 1 : ]
      method_call_elements[ 0 ]( *method_args ) 
      self.input_queue.task_done()
    self.input_queue.task_done()
    return

所以你提交一个方法，然后是可选的args ...然后这个方法最后在EDT中运行，使用有争议的args。不必创建Runnables ......

当然另一种可能性是从SwingWorker继承...然后你就不会有这种稍微令人不安的“双队列”安排（即WorkerThread队列，以及EDT自己的队列，它传递给process（））。 ..但是你必须在doInBackground中有一个相当不合适的循环（使用sleep（））......

会对人们的观点感兴趣

Answer 1

要实现的主要事情是SwingUtilities.invokeAndWait需要单方法接口的实例，因为Java没有第一类函数。对于此功能，如果不使用SwingUtilities之外的其他内容（使用更多Pythonic接口），则无法避免该位。

如果您的心脏已经开始使用该特定API，您仍然可以避免使用包装器功能。只是做：

class RunnableClass(Runnable):
    def run(self):
       pass

SwingUtilities.invokeAndWait(RunnableClass())

使用包装函数的唯一原因是能够使用传递函数来使用闭包在run中调用;您仍然可以通过将函数传递到RunnableClass.__init__并存储它来执行此操作：

class RunnableClass(Runnable):
    def __init__(self, func):
       self._func = func

    def run(self):
       self._func()

请注意，func 不应将self作为第一个参数 - 因为它是实例上的属性而不是类，它不会被处理作为一种方法。

根据您的编辑 - 将func传递给RunnableClass.__init__的重点是它不再需要是一次性子类 - 您不需要{{1}的一个子类对于你要运行的每个函数，只有Runnable的一个实例。 类本身是从Python习语到Java的通用适配器，因此您不需要围绕它来执行相同的工作。

这意味着您的RunnableClass可能如下所示：

runToMessageTree

在Jython中，有一种Pythonesque方式向EDT提交方法吗？

1 个答案: