Threads e gui pygtk: Soluzione definitiva

Se avete letto questo post vi avevo spiegato come usare
gtk.gdk.threads_init(), gtk.gdk.threads_enter() e
gtk.gdk.threads_leave().
Nel post successivo vi ho spiegato che quell'approccio però
penalizza la portabilità su windows. Ora per rendere il nostro codice
portabile potremmo utilizzare due diverse soluzioni. La prima che vi
propongo la mostro solo per completezza ma la sconsiglio e poi vi
spiegherò perché. La seconda è invece la più sicura ed è garanzia
di funzionamento anche in situazioni con più threads attivi.
Allora la prima soluzione consiste nell'eseguire le funzioni che danno
problemi con una gobject.idle_add() e "circondare" il main
con gtk.gdk.threads_enter() e gtk.gdk.threads_leave()
Il codice diventa (date uno sguardo qui per capire le differenze):

import threading
import time
import gtk
import gobject


gtk.gdk.threads_init()



class MyThread(threading.Thread):
  def __init__(self, pbar):
          self.pbar = pbar
          self.stop = False
          threading.Thread.__init__(self)

  def run(self):
          t = 0
          while not self.stop :
                  gtk.gdk.threads_enter()
                  # uso la idle_add
                  gobject.idle_add(self.pbar.set_fraction, t)
                  gtk.gdk.threads_leave()

                  t = t + 0.1
                  if t > 1.0:
                          t = 0.0

                  time.sleep(0.5)


def exit(arg):
  th.stop = True
  gtk.main_quit()

window = gtk.Window()
pbar = gtk.ProgressBar()
window.add(pbar)
window.show_all()

window.connect('destroy', exit)


th = MyThread(pbar)
th.start()

gtk.gdk.threads_enter()
gtk.main()
gtk.gdk.threads_leave()

Questo codice funziona anche su windows ma se i threads iniziano a diventare tanti ( ma non solo ) spesso si hanno dei problemi. Quindi se non volete impazzire vi consiglio vivamente questa seconda soluzione che consiste nell'evitare come la morte le varie threads_enter, threads_leave e init_threads e fare in modo che tutte le operazioni che hanno a che fare con le gtk vengano eseguite dallo stesso thread. L'esempio precedente può essere riscritto in questo modo:

import threading
import time
import gtk


class MyThread(threading.Thread):
    def __init__(self, main):
            self.main = main
            threading.Thread.__init__(self)

    def run(self):
            while not self.main.stop :
                    self.main.pbar_fraction += 0.1
                    if self.main.pbar_fraction > 1.0:
                            self.main.pbar_fraction = 0.0

                    time.sleep(0.5)

class Main:
    def __init__(self):
            self.pbar_fraction = 0
            self.stop = False

            window = gtk.Window()
            self.pbar = gtk.ProgressBar()
            window.add(self.pbar)
            window.show_all()
            window.connect('destroy', self.exit)

            th = MyThread(self)
            th.start()

            self.main_loop()

    def exit(self, arg):
            self.stop = True

    def main_loop(self):
            while not self.stop:
                    self.pbar.set_fraction(self.pbar_fraction)
                    while gtk.events_pending():
                            gtk.main_iteration()
                    time.sleep(0.01)

Main()

Come vedete non abbiamo usato neppure il gtk.main() e
il gtk.main_quit() ma facciamo tutto da noi ;)
Questo codice è portabile, funzionante e non vi farà imprecare :)

Download