CODEWITHSUNDEEP
pythonmultithreadingsockets
Norling
Norling

Reputation: 1171

Close listening socket in python thread

I have a problem trying to learn about sockets for network communication. I have made a simple thread that listens for connections and creates processes for connecting clients, my problem though is that I can't get the thread to join properly as I haven't found a way to cancel the socket.accept()-call when I want to quit the program.

My code looks like this;

class ServerThread( threading.Thread ):

    def __init__(self, queue, host, port):
        threading.Thread.__init__(self)
        self.queue = queue
        self.running = True
        self.hostname = host
        self.port = port

    def run(self):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.bind((self.hostname, self.port))
        self.socket.listen(1)
        while self.running:
            try:
                conn, address = self.socket.accept()
                process = Process(target=server_slave, args=(conn, address, self.queue))
                process.daemon = True
                process.start()
            except socket.timeout:
                pass

    def stop(self):
        self.running = False
        self.socket.close()

I have managed to get the program to close by setting self.setDaemon(True) and just exiting the main program, handing everything to the great garbage collector - but that seems like a bad solution. I've also tried setting a timeout for the socket but that results in getting [Errno 35] Resource temporarily unavailable (regardless of the actual timeout, even when I set it to years...).

What am I doing wrong? Have I designed the thread in a dumb way or have I missed something about accepting connections?

Upvotes: 16

Views: 42254

Answers (5)

Tatarize
Tatarize

Reputation: 10796

The best way to do this is to have a single listening thread that has nothing to do with your connection threads and give it a reasonable length timeout. On timeout, check if this thread should shutdown and if not, loop again and go back to listening.

    def tcp_listen_handle(self, port=23, connects=5, timeout=2):
        """This is running in its own thread."""
        sock = socket.socket()
        sock.settimeout(timeout)
        sock.bind(('', port))
        sock.listen(connects)  # We accept more than one connection.
        while self.keep_running_the_listening_thread():
            connection = None
            addr = None
            try:
                connection, addr = sock.accept()
                print("Socket Connected: %s" % str(addr))
                # makes a thread deals with that stuff. We only do listening.
                self.handle_tcp_connection_in_another_thread(connection, addr)
            except socket.timeout:
                pass
            except OSError:
                # Some other error.
                print("Socket was killed: %s" % str(addr))
                if connection is not None:
                    connection.close()
        sock.close()

The only thing this does is listen, timeout, checks if it should die during the timeout, and goes back to listening. The general rule of thumb is that threads should check whether they should die and try to do that themselves as fast as they can. And if you don't want to take the 2 second hit for timeout wait before the thread unblocks and checks. You can connect to it yourself.

Upvotes: 0

Jean-François Fabre
Jean-François Fabre

Reputation: 140168

A dirty solution which allows to exit your program is to use os._exit(0).

def stop(self):
    self.socket.close()
    os._exit(0)

note that sys.exit doesn't work/blocks as it tries to exit cleanly/release resources. But os._exit is the most low level way and it works, when nothing else does.

The operating system itself will release the resources (on any modern system) like when doing exit in a C program.

Upvotes: 4

rtxndr
rtxndr

Reputation: 922

Partially tested solution

  1. Put self.socket.settimeout(0.1) right before while
  2. Put conn.settimeout(None) right after accept

Upvotes: -1

Eddie
Eddie

Reputation: 1536

In most cases you will open a new thread or process once a connection is accepted. To close the connection, break the while loop. Garbage collection will remove the thread or process but join will ensure none get left behind.

Persistent sockets close when the user closes them or they timeout. Non-persistent, like static webpages will close after they've sent the information.

Here's a good example of a persistent socket server in Python. It uses multiprocessing which means it can run across multiple cores for CPU-bound tasks. More commonly known as multithreading.

import socket
import multiprocessing

def run():
    host = '000.000.000.000'
    port = 1212
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind(('', port))
    sock.listen(3)
    while True:
        p = multiprocessing.Process(target=worker, args=sock.accept()).start()
def worker(conn, addr):
    while True:
        if data == '':
            #remote connection closed
            break
         if len(dataList) > 2:
            # do stuff
            print 'This code is untested'

run()

Upvotes: 1

Norling
Norling

Reputation: 1171

One way to get the thread to close seems to be to make a connection to the socket, thus continuing the thread to completion.

def stop(self):
    self.running = False
    socket.socket(socket.AF_INET, 
                  socket.SOCK_STREAM).connect( (self.hostname, self.port))
    self.socket.close()

This works, but it still feels like it might not be optimal...

Upvotes: 20

Related Questions