kill socket.accept() call on closed unix socket

问题

Socket.close() does not stop any blocking socket.accept() calls that are already running on that socket.

I have several threads in my python program that only run a blocking socket.accept() call on a unix domain socket that has been closed already. I want to kill these threads by making the socket.accept() calls stop or raise an exception.

I am trying to do this by loading new code in the program, without stopping the program. Therefore, changing the code that spawned these threads or that closed the sockets is not an option.

Is there any way to do this?

This is similar to https://stackoverflow.com/a/10090348/3084431, but these solutions wont work for my code:

This point is not true, closing won't raise an exception on the accept. shutdown does, but that can not be called anymore when the thread is closed.
I can not connect to this socket anymore. The socket is closed.
The threads with the accept calls are already running, I can't change them.
Same as 3

For clarification, I have written some example code that has this problem. This code works in both python 2 and python 3.

import socket
import threading
import time

address = "./socket.sock"

sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(address)
sock.listen(5)

def accept():
    print(sock.accept())

t = threading.Thread(target=accept, name="acceptorthread")
t.start()

sock.close()

time.sleep(0.5) # give the thread some time to register the closing

print(threading.enumerate()) # the acceptorthread will still be running

What I need is something that I can run after this code has finished that can stop the acceptor thread somehow.

回答1:

There is no mechanism in kernel to notify every listener that a socket is closed. You have to write something yourself. A simple solution is to use timeout on socket:

sock.settimeout(1)

def accept():
    while True:
        try:
            print(sock.accept())
        except socket.timeout:
            continue
        break

Now when you close the socket the next call (after a timeout) to .accept() will throw a "bad descriptor" exception.

Also remember that sockets api in Python is not thread safe. Wrapping every socket call with a lock (or other synchronization methods) is advised in multi-threaded environment.

More advanced (and efficient) would be to use wrap your socket with a select call. Note that the socket does not have to be in non-blocking mode in order to use it.

Therefore, changing the code that spawned these threads or that closed the sockets is not an option.

If that's the case, then you are doomed. Without changing the code running in threads it is impossible to achieve. It's like asking "how can I fix my broken car without modifying the car". Won't happen, mate.

回答2:

You should only call .accept() on a socket that has given the "readable" result from some selectors. Then, accept doesn't need to be interrupted.

But in case of spurious wakeup, you should have the listening socket in O_NONBLOCK mode anyway.

来源：https://stackoverflow.com/questions/43834926/kill-socket-accept-call-on-closed-unix-socket

标签

python

multithreading

sockets

unix-socket