CODEWITHSUNDEEP
pythonpython-multithreading
AppleJuice
AppleJuice

Reputation: 95

Cross Thread Update Observer Pattern (non-blocking)

New to SO, please forgive any etiquette errors (point out if there are!).

I'm working on a script that is running on the programs main UI thread. That being said, I need to avoid all blocking calls to ensure user can still interact. I do not have access to the UI event loop so any busy loop solutions aren't possible in my situation.

I have a simple background thread that is communicating to another app and gathering data, and storing in a simple array for consumption. Each time this data is updated I need to use the data to modify the UI (this must run in main thread). Ideally the background thread would emit a signal each time the data is updated then in the main thread a listener would handle this and modify the UI. A busy loop is not an option everything must be asyncronous/event based.

I have the data gathering continuossly running in the background using threading.timer(..). However since this runs in a seperate thread, the UI operations need to be called externally to this.

def _pollLoop(self): 
    if (self._isCubeControl):
        self._getNewData()
        #in a perfect world, updateUI() would be here
        self._pollThread = threading.Timer(0.1,self._pollLoop)
        self._pollThread.start()

I need a way for this pollLoop to callback to main thread so I can update the UI. I've tried direct callbacks within the pollLoop but the callback are ran within the seperate thread causing errors.

Looking for a way to attach listener to the data object so that on change updateUI() can be ran IN MAIN THREAD.

Thanks for any help you can offer! If this is at all vague please let me know

Update

Based off of @CAB's answer I'm now trying to implement an Observer Pattern. The difficulty is that the Observable is to be ran in a spawned thread while the Observer update function must run in the main thread. I've implemented the example chad lung (http://www.giantflyingsaucer.com/blog/?p=5117).

import threading

class Observable(object):

    def __init__(self):
        self.observers = []

    def register(self, observer):
        if not observer in self.observers:
            self.observers.append(observer)

    def unregister(self, observer):
        if observer in self.observers:
            self.observers.remove(observer)

    def unregister_all(self):
        if self.observers:
             del self.observers[:]

    def update_observers(self, *args, **kwargs):
        for observer in self.observers:
            observer.update(*args, **kwargs)
        thread = threading.Timer(4,self.update_observers).start()

from abc import ABCMeta, abstractmethod

class Observer(object):
    __metaclass__ = ABCMeta

    @abstractmethod
    def update(self, *args, **kwargs):
        pass

class myObserver(Observer):  
    def update(self, *args, **kwargs):
        '''update is called in the source thread context'''
        print(str(threading.current_thread()))

observable = Observable()

observer = myObserver()
observable.register(observer)

observable.update_observers('Market Rally', something='Hello World')

What I get in response is:

<_MainThread(MainThread, started 140735179829248)>
<_Timer(Thread-1, started 123145306509312)>
<_Timer(Thread-2, started 123145310715904)>

So clearly the Observer is running in the spawned thread and not main. Anyone have another method for me? :) Once again I cannot have a busy loop to periodically check for value change (i wish.. :( ) This script is running overtop a UI and I do not have access to the GUI event loop, so everything needs to be asynchronous and non-blocking.

Upvotes: 2

Views: 3213

Answers (1)

CAB
CAB

Reputation: 1147

Let's build on that example from http://www.giantflyingsaucer.com/blog/?p=5117. 

from abc import ABCMeta, abstractmethod

class Observer(object):
    __metaclass__ = ABCMeta

    @abstractmethod
    def update(self, *args, **kwargs):
        pass

The onus is then on the Observer implementation to disconnect the threads. Let's say we do this using a simplistic thread. (syntax might be off, I'm cramming this in and need to catch a bus).

from observer import Observer
from threading import Thread

class myObserver(Observer):

    def update(self, *args, **kwargs):
        '''update is called in the source thread context'''
        Thread(target=self.handler, args=(self,*args), kwargs=**kwargs).start()

    def handler(self, *args, **kwargs):
       '''handler runs in an independent thread context'''
       pass # do something useful with the args

Upvotes: 3

Related Questions