Callback at random times from a child process with infinite loop, and termination

I need to react in a main process to random events happening in a child process. I have implemented this with a queue between the main and the child process, and a 'queue poller' ruing in a secondary thread of the main process and calling a callback function each time it finds an item in the queue. The code is below and seems to work. Question 1: Could you please tell me if the strategy is correct or if something simpler exists ? Question 2: I tried to have both the child process and the secondary thread terminated when stopping the main loop, but it fails, at least in spyder. What should I do to terminate everything properly? Thanks for your help :-)

from threading import Thread
from multiprocessing import Process, Queue
from time import sleep
from random import random

class MyChildProcess(Process):
    """
    This process run as a child process of the main process.
    It fills a queue (instantiated in the main process - main thread) at random times.
    """
    def __init__(self,queue):
        super(MyChildProcess,self).__init__()
        self._q = queue             # memorizes the queue
        self._i = 0                 # attribute to be incremented and put in the queue

    def run(self):
        while True:
            self._q.put(self._i)    # put in the queue
            self._i += 1            # increment for next time
            sleep(random())         # wait between 0 and 1s

class myListenerInSeparateThreadOfMainProcess():
    """
    This listener runs in a secondary thread of the main process.
    It polls a queue and calls back a function for each item found.
    """
    def __init__(self, queue, callbackFunction):
        self._q = queue              # memorizes the queue
        self._cbf = callbackFunction # memorizes the queue
        self.pollQueue()

    def pollQueue(self):
        while True:
            sleep(0.2)               # polls 5 times a second max
            self.readQueue()   
    def readQueue(self):
        while not self._q.empty():   # empty the queue each time
            self._cbf(self._q.get()) # calls the call back function for each item

def runListener(q,cbf):
    """Target function for the secondary thread"""
    myListenerInSeparateThreadOfMainProcess(q,cbf)    

def callBackFunc(*args):
    "This is my reacting function"""
    print 'Main process gets data from queue: ', args

if __name__ == '__main__':     
    q= Queue()
    t = Thread(target=runListener, args=(q,callBackFunc))
    t.daemon=True        # try to have the secondary thread terminated if main thread terminates
    t.start()
    p = MyChildProcess(q)
    p.daemon = True      # try to have the child process terminated if parent process terminates
    p.start()            # no target scheme and no parent blocking by join
    while True:          # this is the main application loop
        sleep(2)
        print 'In main loop doing something independant from the rest'