wxpython使用多进程_线程执行wxPython使用delayedresult进行耗时处理 线程执行

PS:今天上午，非常郁闷，有很多简单基础的问题搞得我有些迷茫，哎，代码几天不写就忘。目前又不当COO，还是得用心记代码哦！

delayedresult应用背景绍介

在行进wxPython GUI画面编程时，如直接在画面主线程行进大批耗时算计处置，就会成造画面假死，不能响应用户输入。

应用wxPython的delayedresult块模，可省力处理该问题，甚至都不需要懂得相干线程处置机制，可即便方的把耗时处置放到独单的线程中，处置结束后把结果返回GUI画面主线程，并调用先预义定的相干处置，行进画面更新等。

为了演示delayedresult的应用情况，先新建一TestWindow框架，doSomeThing()是我们模拟行进大批耗时处置的数函。

1 import wx

2 from wx.lib.delayedresult import startWorker

3 import threading

4

5 class TestWindow(wx.Frame):

6 def __init__(self, title='Test Window'):

7 self.app = wx.App(False)

8 wx.Frame.__init__(self, None, -1, title)

9 panel = wx.Panel(self)

10 self.btnBegin = wx.Button(panel, -1, label='Begin')

11 self.Bind(wx.EVT_BUTTON, self.handleButton, self.btnBegin)

12 self.txtCtrl = wx.TextCtrl(panel, style=wx.TE_READONLY, size=(300, -1))

13 vsizer = wx.BoxSizer(wx.VERTICAL)

14 vsizer.Add(self.btnBegin, 0, wx.ALL, 5)

15 vsizer.Add(self.txtCtrl, 0, wx.ALL, 5)

16 panel.SetSizer(vsizer)

17 vsizer.SetSizeHints(self)

18 self.Show()

19

20 #处置Begin按钮件事

21 def handleButton(self, event):

22 self.workFunction()

23

24 #开始执行耗时处置，有继承类实现

25 def workFunction(self, *args, **kwargs):

26 print'In workFunction(), Thread=', threading.currentThread().name

27 print '\t*args:', args

28 print '\t**kwargs:', kwargs

29

30 self.btnBegin.Enable(False)

31

32 #耗时处置处置成完后，调用该数函执行画面更新示显，由继承类实现

33 def consumer(self, delayedResult, *args, **kwargs):

34 print 'In consumer(), Thread=', threading.currentThread().name

35 print '\tdelayedResult:', delayedResult

36 print '\t*args:', args

37 print '\t**kwargs:', kwargs

38

39 self.btnBegin.Enable(True)

40

41 #模拟行进耗时处置并返回处置结果，给继承类应用

42 def doSomeThing(self, *args, **kwargs):

43 print'In doSomeThing(), Thread=', threading.currentThread().name

44 print '\t*args:', args

45 print '\t**kwargs:', kwargs

46

47 count = 0

48 while count < 10**8:

49 count += 1

50

51 return count

行运面界：

先看看如在GUI画面主线程行进doSomeThing()处置的

1 class DoSomeThingInGUI(TestWindow):

2 def __init__(self):

3 TestWindow.__init__(self, 'Do Something In GUI Thread')

4 self.app.MainLoop()

5

6 #执行doSomeThing()，并在执行成完后，动主调用consumer()更新画面示显

7 def workFunction(self, *args, **kwargs):

8 TestWindow.workFunction(self, args, kwargs)

9 var = self.doSomeThing()

10 self.consumer(var)

11

12 def consumer(self, delayedResult, *args, **kwargs):

13 TestWindow.consumer(self, delayedResult, args, kwargs)

14 self.txtCtrl.SetValue(str(delayedResult))

15

16 if __name__ == '__main__':

17 win = DoSomeThingInGUI()

执行后，点Begin开始后，直到处置成完画面口窗没法动移。

由以下log出输可以晓得，处置都是在GUI画面主线程中成完的。

In workFunction(), Thread= MainThread

*args: ((), {})

**kwargs: {}

In doSomeThing(), Thread= MainThread

*args: ()

**kwargs: {}

In consumer(), Thread= MainThread

delayedResult: 100000000

*args: ((), {})

**kwargs: {}

应用wx.lib.delayedresult后的处置情况：

1 class DoSomeThingInSeperateThread(TestWindow):

2 def __init__(self):

3 TestWindow.__init__(self, 'Do Something In Seperate Thread')

4 self.jobId = 100

5 self.app.MainLoop()

6

7 #调用wx.lib.delayedresult.startWorker，把数函处置放到独单的线程中去成完。

8 #成完后会动主调用consumer行进画面更新处置

9 #startWorker数函的各数参接下来分析

10 def workFunction(self, *args, **kwargs):

11 TestWindow.workFunction(self, args, kwargs)

12 startWorker(self.consumer, self.doSomeThing, jobID=self.jobId)

13

14 #第一数参要为DelayedResult类型，即含包处置结果或常异息信，调用get口接获得。

15 def consumer(self, delayedResult, *args, **kwargs):

16 TestWindow.consumer(self, delayedResult, args, kwargs)

17 assert(self.jobId == delayedResult.getJobID())

18 try:

19 var = delayedResult.get()

20 except Exception, e:

21 print 'Result for job %s raised exception:%s' %(delayedResult.getJobID, e)

22

23 self.txtCtrl.SetValue(str(var))

24

25 if __name__ == '__main__':

26 win = DoSomeThingInSeperateThread()

执行后，点Begin开始后，口窗动移不受影响，也就是说处置是异步的。

由以下log出输可以晓得，耗时处置doSomeThing是在独立线程行运的。

处置成完后的画面更新处置consumer还是在GUI画面主线程成完的。

In workFunction(), Thread= MainThread

*args: ((), {})

**kwargs: {}

In doSomeThing(), Thread= 100

*args: ()

**kwargs: {}

In consumer(), Thread= MainThread

delayedResult:

*args: ((), {})

**kwargs: {}

startWorker数函绍介

该数函创立独立线程(Producer线程)执行workerFn(*wargs, **wkwargs)，并将其结果发送给行运在Main线程的consumer(*cargs, ckwargs)。

jobID即为创立的Producer线程的名字，也可在consumer中判断是那个Producer线程。

具体可考参 help(wx.lib.delayedresult)

startWorker(consumer,

workerFn,

cargs=(), ckwargs={},

wargs=(), wkwargs={},

jobID=None,

group=None,

daemon=False,

sendReturn=True,

senderArg=None)

注意事项：

1)sendResurn为True的情况下，workFn执行结束后才执行consumer处置。

2)consumer第一数参为DelayedResult，可应用其结果get()获得workFn中返回的结果，getJobID()用于返回数参jobID或者None(jobID未指定时)

3)cargs, ckwargs传递给consumer；wargs, wkargs传递给workerFn

文章结束给大家分享下程序员的一些笑话语录： 不会，Intel会维持高利润，也会维持竞争局面，国外的竞争不是打死对方的那种。你看日本有尼康，佳能，索尼，都做相机，大家都过得很滋润。别看一堆厂，其实真正控制的是后面的那几个财团——有些竞争对手，后面其实是一家人。