5

I would like to stop a Python thread when the main program stops. It is for a class that connects to a server. The connection is maintained by the background thread, the foreground thread answers to callbacks. The following is a minimal example. 

#!/usr/bin/python
import time, threading
class test():
    running = False
    def __init__(self):
        print "init"
        self.running = True
        self.thread = threading.Thread(target = self.startThread)
        self.thread.start()

    def __del__(self):
        running = False
        print "del"

    def startThread(self):
        print "thread start"
        while self.running:
            time.sleep(1)
            print "thread running"

a = test()

When the program ends, I would naively expect __del__() to be called so that the background thread can be informed to stop, but i is not called untill after the background thread stops. Explicitly calling some function is not an option since the class is used by other people, whom I do not want to force to use some extra lines of code.

Wilbert
  • 1,618
  • 15
  • 13

4 Answers4

3

__del__ is not called as long as there are references to self, and you have one such reference in the background thread itself: in the self argument of def startThread(self):.

You need to move the function that runs the background thread outside of the class. And rather than a __del__ I would recommend for example using a weakref, as follows. This code should work without the __del__() method and without using a self.running attribute.

self.thread = threading.Thread(target=run_me, args=(weakref.ref(self),))
...
def run_me(weak_self):
    "Global function"
    while True:
        self = weak_self()
        if self is None: break    # no more reference to self
        ...
        del self        # forget this reference for now
        time.sleep(1)
Armin Rigo
  • 12,048
  • 37
  • 48
  • This helps partly, but it does not do what I wanted it to do. Although explicitly deleting the instance of the test object `del a` now stops the code and calls the destructor, the object is not deleted when the program simply reaches the end, and also it still does not respond to ctrl-c. – Wilbert Feb 20 '13 at 16:23
1

As per gnibbler's comment, it may be better to use a context manager for explicit resource deallocation. Opinions appear to vary on whether __del__ should be used for resource deallocation. A couple of good posts on the subject are here and here.

If you're used to a language like C++ where RAII is used, it's sometimes a bit difficult to get accustomed to the idea that destructors in Python may not be called when you expect, if at all, usually because of how reference counting and garbage collection works.

So, the usual approach in Python is to use a context manager which can be used to provide explicit deallocation of resource.

A simple threading example might look like this (untested):

#!/usr/bin/python
import time, threading

class test():
    def __init__(self):
        print "init"
        self.stop_event = threading.Event()
        self.thread = threading.Thread(target = self.startThread)
        self.thread.start()

    def startThread(self):
        print "thread start"
        while not self.stop_event.isSet():
            time.sleep(1)
            print "thread running"

    def close(self):
        # Request thread to stop.
        self.stop_event.set()
        # Wait for thread to exit.
        self.thread.join()

    def __enter__(self):
        # Nothing to do, thread already started.  Could start
        # thread here to enforce use of context manager.

    def __exit__(self, exc_type, exc_value, traceback):
        self.close()

The test() class is then used like this in a context manager:

with test():
    # Thread will be active here.
    pass

# Thread will have been stopped and joined.

or, use the Python contextlib.closing helper function which will ensure that close is called on exit.

import contextlib

with contextlib.closing(test()):
    # Thread will be active here.
# But not here
Austin Phillips
  • 15,228
  • 2
  • 51
  • 50
  • 1
    This does what I want, but requires the user of my class to put his entire program in a contextmanager block. That is not an option. – Wilbert Feb 21 '13 at 11:11
  • Using a context manager *is* the correct way to guarantee resource clean up, irrespective of how you want users to use your class. You are not guaranteed when or if `__del__` will be called, especially in implementations other than CPython. There are many posts on SO which provide useful explanations on why. You could use `setDaemon(True)` on your thread, but this will not guarantee clean exit of your thread. – Austin Phillips Feb 21 '13 at 22:55
1

I was facing the same problem and finally found the answer to this question in the answer to another question.

Use the daemon = True flag. Documentation for 3.x and 2.x

So your code would be this:

#!/usr/bin/python
import time, threading

class test():
    def __init__(self):
        print "init"
        self.thread = threading.Thread(target = self.startThread)
        self.thread.daemon = True
        self.thread.start()

    def startThread(self):
        print "thread start"
        while True:
            time.sleep(1)
            print("thread running")

a = test()

Remark: this is propably not cleanly ending your thread, but it stops it when you exit your program, I guess this is what you were looking for.

Community
  • 1
  • 1
heine
  • 599
  • 5
  • 18
0

You forgot to change the "running" variable of your current test() instance, in your del function. It should be

 def __del__(self):
        self.running = False
        print "del"

That should do the trick.

knight
  • 435
  • 5
  • 18