PyGTK: धाराओं और आवरण जादू

जीटीके + सभी के लिए अच्छा है, लेकिन बहु-थ्रेडेड अनुप्रयोगों में इसके साथ काम करते समय एक बड़ी समस्या है। GTK स्वयं थ्रेड-सुरक्षित है, लेकिन उपयोगकर्ता द्वारा एक मजबूर ब्लॉक की आवश्यकता होती है। दूसरी समस्या यह है कि म्यूटेक्स के माध्यम से लॉक को लागू किया जाता है, और आपको लॉक को एक बार सख्ती से कॉल करना होगा, अन्यथा आपका कोड लिनक्स पर लटका होगा, खिड़कियों पर ठीक काम करेगा।

अनुभव से पता चला है कि एक्सेस विधि "कोई भी धागा जीयूआई का उपयोग करता है, मुख्य बात ताले का कारण है" एक विफलता के रूप में निकला: थोड़ी देर के बाद, आप जीटीके की गहराई में कोर डंप को कई कारणों से पकड़ सकते हैं, जो पकड़ने के लिए बेकार है।

यूपी : कोड गिथब को अपलोड किया गया है, और "मुख्य" परियोजना के कोड के नवीनतम संस्करण के साथ थोड़ा अद्यतन किया गया है। कॉस्मेटिक परिवर्तन (अवधि के बजाय सेकंड, और समस्या क्षेत्रों की खोज के लिए एक गलत धारा के उपयोग के लॉगिंग को जोड़ा गया है।

इस संबंध में, मेरी छोटी परियोजना में मैं स्ट्रीम के साथ सबसे अधिक समस्या-मुक्त कार्य के आयोजन की निम्न विधि पर आया:

1. GTK के लिए कोई भी कॉल केवल एक धागा पैदा करता है। जीयूआई में सभी परिवर्तन समर्पित राज्य अद्यतन कार्यों द्वारा किए जाते हैं।
2. सभी ताले एक सामान्य रेस्ट्रेंट ब्लॉकर के माध्यम से संचालित किए जाते हैं।
3. अवरोधक "गलत" स्ट्रीम से GUI तक पहुंच की निगरानी करता है, इसे लॉग करता है।

GUI भाग की सामान्य संरचना

मुख्य भाग में gui.py मॉड्यूल शामिल है, जो निम्नलिखित "अच्छा" निर्यात करता है:

GtkLocker = CGtkLocker() #  def GtkLocked(f): #    gui,        def IdleUpdater(f): #    ,      gui def SecondUpdater(f): #    ,       def GUIstop(): #       GUI def GuiCall(Func): #    GUI ""  def GuiIdleCall(Func): #    GUI       def GuiSecondCall(Func): #       def GUI(): #     

और आवेदन इस तरह काम करता है:

 import gui, gtk def InitApp(): """       """ with GtkLocker: window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_title(u"  ") window.connect("destroy", gui.GUIstop) window.realize() vbox = gtk.VBox() window.add(vbox) label = gtk.Label("Text label") vbox.add(label) window.show_all() def __main__(): gui.GuiCall( InitApp ) gui.GUI() if __name__ == '__main__': __main__() sys.exit(0) 

यह एप्लिकेशन पाठ "लेबल" के साथ एक विंडो प्रदर्शित करने के अलावा कुछ नहीं करता है। आइए इसे मानवीय रूप से करें: सभी एप्लिकेशन कोड को एक कक्षा में डालें और एक बटन जोड़ें।

 class CMyApp(object): def __init__(self): self.label = None self.times = 0 def CreateGui(self): with gui.GtkLocker: window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_title(u"  ") window.connect("destroy", gui.GUIstop) window.realize() vbox = gtk.VBox() window.add(vbox) label = gtk.Label("Welcome to our coool app!") vbox.pack_start(label) label = gtk.Label("Here will be counter") self.label = label vbox.pack_start(label) button = gtk.Button("Press me!") button.connect("clicked", self.Click) vbox.pack_start(button) window.show_all() @gui.GtkLocked def Click(self, widget): self.times += 1 self.label.set_text("You pressed button %d times" % self.times) MyApp = CMyApp() def InitApp(): """       """ MyApp.CreateGui() 

तो हमने क्या किया है? हमने एक ऑब्जेक्ट बनाया, __init__ विधि, जिसके द्वारा भविष्य के तरीकों को तैयार किया गया था, और सभी वास्तविक निर्माण CreateGui फ़ंक्शन में किए CreateGui हैं, जिसे पहले से ही सामान्य ईवेंट प्रोसेसिंग लूप से कहा जाएगा।

अब जादू के बारे में कि Click विधि निम्न है: ध्यान दें, यह एक आवरण gui.GtkLocked के साथ चिह्नित है। gui.GtkLocked । इसका मतलब है कि यह विधि एक GUI इवेंट प्रोसेसिंग विधि है, और कनेक्ट के माध्यम से कड़ाई से कहा जाता है, इसका मतलब है कि जिस समय विधि को बुलाया जाता है, उसमें पहले से ही GTK लॉक होता है। यह आवरण "पहले से ही अवरोधित" अवरोधक GUI की स्थिति को लागू करता है, इसलिए फ़ंक्शन के अंदर लॉक का उपयोग करने से कोई समस्या नहीं होगी।

एक दूसरा बटन जोड़ें जो समुद्र को उपयोगी बनाता है:

 class CMyApp(object): def CreateGui(self): with gui.GtkLocker: .... button = gtk.Button("Or me!") button.connect("clicked", gui.GtkLocked(self.Count)) vbox.pack_start(button) .... @gui.GtkLocked def Click(self, widget): self.Count() gui.GuiSecondCall( self.Count ) def Count(self, *args, **kwargs): with gui.GtkLocker: self.times += 1 self.label.set_text("You pressed button %d times" % self.times) 

इसलिए, हमने पिछले बटन के Click विधि को कॉल को सामान्य Count पद्धति में बदल दिया, और एक सेकंड तक की देरी के साथ इसे देरी से कॉल किया, जो मंगल पर मौसम की परवाह किए बिना कोड को गिनता और अपडेट करता है, और सीधे दूसरे बटन पर Count लटका दें।
चूंकि Count पद्धति में इसे न केवल connect माध्यम से कॉल करना शामिल है, हम इस पर @gui.GtkLocked को लटका नहीं सकते हैं - विधि को अनब्लॉक संदर्भ (उदाहरण के लिए, केवल निष्क्रिय ईवेंट में कहा जाता है) से कॉल किया जा सकता है, इसलिए हम सीधे gui.GtkLocked को gui.GtkLocked हैं। connect क्षण। नतीजतन, Count विधि को एक अनवरोधित संदर्भ से कॉल किया जा सकता है और यह लॉक को स्वयं कैप्चर करेगा, लेकिन साथ ही यह एक ईवेंट के लिए बाध्य है और इसे किसी अन्य ईवेंट हैंडलर द्वारा कॉल किया जाता है। GtkLocker और GtkLocked के जादू के कारण GtkLocked कोई गतिरोध नहीं होता है, सब कुछ काम करता है।

अब उसकी महामंदी को प्रगति पट्टी और एक जटिल पृष्ठभूमि प्रक्रिया से जोड़ते हैं, जो इस प्रक्रिया में अपनी सामग्री को अपडेट करती है:

 class CMyApp(object): def CreateGui(self): with gui.GtkLocker: .... progress = gtk.ProgressBar() self.progress = progress vbox.pack_start(progress) T = threading.Thread(name="Background work", target=self.Generate) T.setDaemon(1) T.start() @gui.GtkLocked def UpdateProgress(self): self.progress.pulse() def Generate(self): while(True): time.sleep(0.3) gui.GuiIdleCall( self.UpdateProgress ) 

तो, यहाँ Generate मेथड बैकग्राउंड के विरुद्ध काम करता है, और हर 0.3 सेकेंड में प्रगति को अपडेट करना चाहता है, जिसके लिए यह UpdateProgress को निष्पादन UpdateProgress में रखता है। चूंकि UpdateProgress GUI थ्रेड के संदर्भ में चलता है, इसलिए सब कुछ काम करता है। लेकिन क्या होगा यदि हम इसे पूरा करने के लिए आवश्यक समय नहीं जानते हैं? हर छींक को अपडेट करें? 0.3 को 0.001 के साथ बदलें - और परिणाम की प्रशंसा करें। नहीं, यह कोई विकल्प नहीं है। समय माप जोड़ें और कृत्रिम रूप से अपडेट धीमा करें? आम तौर पर एक विकल्प नहीं है। शायद GuiIdleCall बजाय GuiIdleCall बनाते हैं? चलो कोशिश करते हैं ... हम्मम। प्रत्येक सेकंड में इस सेकंड के दौरान पूरी की गई सभी घटनाओं का एक तेज़ अपडेट होता है। हॉरर।

आइए एक और पृष्ठभूमि प्रक्रिया जोड़ें, और इसमें "स्मार्ट" अपडेट विधि:

 class CMyApp(object): def CreateGui(self): with gui.GtkLocker: .... fastprogress = gtk.ProgressBar() self.fastprogress = fastprogress vbox.pack_start(fastprogress) T = threading.Thread(name="Heavy background work", target=self.GenerateFast) T.setDaemon(1) T.start() @gui.SecondUpdater def SingleUpdateProgress(self): self.fastprogress.pulse() def GenerateFast(self): while(True): time.sleep(0.001) self.SingleUpdateProgress() 

जादू, खुशी! हम केवल राज्य अद्यतन फ़ंक्शन की घोषणा करते हैं और उस पर आवश्यक आवरण @gui.SecondUpdater : @gui.SecondUpdater या @gui.IdleUpdater , और विधि स्वचालित रूप से GUI थ्रेड के संदर्भ में प्रति सेकंड या खाली समय में एक बार से अधिक नहीं @gui.IdleUpdater । आवरणों के कारण, एक पंक्ति में विधि की दोहरी शुरुआत को बाहर रखा गया है, इसे अनावश्यक लेखांकन कोड की आवश्यकता नहीं है, चाहे इसे कहा गया हो, और इसे निष्पादन कतार में रखने के बारे में सोचने की कोई आवश्यकता नहीं है।

हुड के नीचे

तो, चलिए gui.py के अंदर जो बात सामने आई है, उस पर करीब से नज़र डालते हैं।

सामान्य कोड कुछ भी जटिल नहीं है, बस आरंभीकरण:

 from __future__ import with_statement import logging, traceback logging.basicConfig(level=logging.DEBUG, filename='debug.log', filemode='a', format='%(asctime)s %(levelname)-8s %(module)s %(funcName)s %(lineno)d %(threadName)s %(message)s') import pygtk pygtk.require('2.0') import gtk gtk.gdk.threads_init() import gobject, gtk.glade, Queue, sys, configobj, threading, thread from functools import wraps import time, os.path gtk.gdk.threads_enter() IGuiCaller = Queue.Queue() IGuiIdleCaller = Queue.Queue() IGuiSecondsCaller = Queue.Queue() IdleCaller = [ None ] IdleCallerLock = threading.Lock() gtk.gdk.threads_leave() class CGtkLocker: .... #    GtkLocker = CGtkLocker() #   GUI  --   main_quit,   GUI  @IdleUpdater def GUIstop(*args, **kwargs): gtk.main_quit() # ,     . #    (gobject)  , #  threading.Queue,     . def GuiCall(Func): IGuiCaller.put(Func) with IdleCallerLock: if IdleCaller[0] == False: gobject.idle_add(GUIrun) IdleCaller[0] = True def GuiIdleCall(Func): IGuiIdleCaller.put(Func) with IdleCallerLock: if IdleCaller[0] == False: gobject.idle_add(GUIrun) IdleCaller[0] = True def GuiSecondCall(Func): IGuiSecondsCaller.put(Func) #    GUI  def GUIrun(): #     GuiCaller try: Run = IGuiCaller.get(0) #   idle ,  GTK   # ,   ,    #      "with GtkLocker:" ,  @GtkLocked with GtkLocker: Run() except Queue.Empty: #    --  GuiIdleCaller try: Run = IGuiIdleCaller.get(0) with GtkLocker: Run() except Queue.Empty: #     -- ,   with GtkLocker: IdleCaller[0] = False return False return True #   :     #     def GUIrunSeconds(): try: with GtkLocker: while (True): Run = IGuiSecondsCaller.get(0) Run() except Queue.Empty: pass return True #    def GUI(): #   gobject.idle_add(GUIrun) IdleCaller[0] = True gobject.timeout_add(1000, GUIrunSeconds) #     gtk.main gtk.gdk.threads_enter() #    GtkLocker, #   gtk.main    GtkLocker.FREE() #     GUI  gtk.main() #   main_quit,   main    gtk.gdk.threads_leave() 

अब आइए सबसे दिलचस्प देखें: रैपर। तो, सबसे महत्वपूर्ण एक रीक्रेंट लॉकिंग का कार्यान्वयन है:

 class CGtkLocker: def __init__(self): #       self.lock = threading.Lock() self.locked = 1 # ,      self.thread = thread.get_ident() #   ,     GUI    self.mainthread = self.thread self.warn = True #   ,   N  # ,     with  def __enter__(self): #       with self.lock: DoLock = (thread.get_ident()!=self.thread) #   ,   -       if self.warn and self.mainthread != thread.get_ident(): logging.error("GUI accessed from wrong thread! Traceback: "+"".join(traceback.format_stack())) #        with  ,      if DoLock: #        gtk.gdk.threads_enter() #             with self.lock: self.thread = thread.get_ident() #  __enter__    self.locked += 1 return None #     with  (  -- ,   ..) def __exit__(self, exc_type, exc_value, traceback): #      ,       with self.lock: self.locked -= 1 if self.thread!=thread.get_ident(): print "!ERROR! Thread free not locked lock!" logging.error("Thread free not locked lock!") sys.exit(0) else: if self.locked == 0: self.thread = None gtk.gdk.threads_leave() return None #    :      . def FREE(self): self.locked -= 1 self.thread = None if self.locked != 0: print "!ERROR! Main free not before MAIN!" logging.error("Main free not before MAIN!") sys.exit(0) GtkLocker = CGtkLocker() 

यह समझा जाना चाहिए कि " with GtkLocker " GUI के साथ काम करने वाले किसी भी टुकड़े को लपेटा जाना चाहिए।
और ज्यादातर मामलों में, यह काम करेगा, भले ही सभी कॉल अलग-अलग थ्रेड्स से जाएं, इसलिए threads_enter / threads_leave बनाए threads_leave । बस कभी-कभी सब कुछ समय के लिए काम करता है, और अचानक जीटीके की गहराई में कहीं गिर जाता है।

GtkLocker साथ GtkLocker रैपर GtkLocker जाता है जो उस घटना विधियों को चिह्नित करने की अनुमति देता है जिसे GTK कर्नेल द्वारा पहले से ही लॉक के अंदर कहा जाता है। स्तर शून्य पर कहा जाता है, यह लॉकिंग स्तर के स्तर को बढ़ाता है, जिससे यह सुनिश्चित होता है कि हम खुद को threads_enter / threads_leave / threads_leave नहीं कहते हैं।

 def GtkLocked(f): @wraps(f) def wrapper(*args, **kwds): with GtkLocker.lock: if GtkLocker.thread == None or GtkLocker.thread==thread.get_ident(): GtkLocker.thread = thread.get_ident() GtkLocker.locked += 1 WeHold = True else: print "!ERROR! GtkLocked for non-owned thread!" logging.error("GtkLocked for non-owned thread!") WeHold = False ret = None try: return f(*args, **kwds) finally: if WeHold: with GtkLocker.lock: GtkLocker.locked -= 1 if GtkLocker.locked == 0: GtkLocker.thread = None return wrapper 

खैर, आखिरी मैजिक पास: IdleUpdater / SecondUpdater :

 def IdleUpdater(f): @wraps(f) def wrapper(*args, **kwds): self = len(args)>0 and isinstance(args[0], object) and args[0] or f if '_idle_wrapper' not in self.__dict__: self._idle_wrapper = {} def runner(): if self._idle_wrapper[f]: try: return f(*args, **kwds) finally: self._idle_wrapper[f] = False return None if f not in self._idle_wrapper or not self._idle_wrapper[f]: self._idle_wrapper[f] = True #  SecondUpdater   GuiSecondCall GuiIdleCall( runner ) return wrapper 

उस ऑब्जेक्ट में जिसका विधि हम कॉल कर रहे हैं, _idle_wrapper डिक्शनरी _idle_wrapper , जिसमें एक मॉनिटरिंग है कि दी गई विधि पहले से ही निष्पादन के लिए कतार में लगाई गई है या नहीं, और यदि नहीं, तो हमें याद है कि हम एक स्टार्टअप रैपर जोड़ते हैं जो इस विधि को निष्पादित करेगा और याद किए गए निष्पादन के झंडे को साफ करेगा। । नतीजतन, विधि का पहला कॉल अपने लॉन्च को GuiIdleCall (या *Seconds* ) कतार में जोड़ देगा, और जब तक इसे निष्पादित नहीं किया जाता है तब तक बार-बार कॉल को अनदेखा किया जाएगा।

कोड और उपयोगी जानकारी डाउनलोड करें

इस उदाहरण के सभी स्रोत उपलब्ध हैं: pygtk-Demo.tar.bz2 ।
PyGTK पर उपयोगी जानकारी के लिए इसके आधिकारिक FAQ में ज्ञात समस्याएँ।
PyGTK के तहत लिखने के बारे में सवालों के लिए, मैं सबसे अधिक बार ट्यूटोरियल और मैनुअल की ओर रुख करता हूं।