Confusion with weakref, __del__ and threading

George Sakkis george.sakkis at
Wed Jun 11 04:15:16 CEST 2008

I'm baffled with a situation that involves:
1) an instance of some class that defines __del__,
2) a thread which is created, started and referenced by that instance,
3) a weakref proxy to the instance that is passed to the thread
instead of 'self', to prevent a cyclic reference.

This probably sounds like gibberish so here's a simplified example:


import time
import weakref
import threading

num_main = num_other = 0
main_thread = threading.currentThread()

class Mystery(object):

    def __init__(self):
        proxy = weakref.proxy(self)
        self._thread = threading.Thread(target=target, args=(proxy,))

    def __del__(self):
        global num_main, num_other
        if threading.currentThread() is main_thread:
            num_main += 1
            num_other += 1

    def sleep(self, t):

def target(proxy):
    try: proxy.sleep(0.01)
    except weakref.ReferenceError: pass

if __name__ == '__main__':
    for i in xrange(1000):
    print '%d __del__ from main thread' % num_main
    print '%d __del__ from other threads' % num_other


When I run it, I get around 950 __del__ from the main thread and the
rest from non-main threads. I discovered this accidentally when I
noticed some ignored AssertionErrors caused by a __del__ that was
doing "self._thread.join()", assuming that the current thread is not
self._thread, but as it turns out that's not always the case.

So what is happening here for these ~50 minority cases ? Is __del__
invoked through the proxy ?


More information about the Python-list mailing list