CODEWITHSUNDEEP
pythonmultithreadingsockets
pzk
pzk

Reputation: 19

Listening for socket input in multiple threads

I'm using python sockets.

Here's the problem. I've 2 threads:

Now the problem is in case of second thread when I send something, the response doesn't come to this thread. Rather it comes to thread mentioned in (1) point.

This is thread (1) 

def client_handler(client):
    global client_name_to_sock_mapping
    client.send(first_response + server_name[:-1] + ", Press ^C to exit")
    user_name = None
    while True:
        request = client.recv(RECV_BUFFER_LIMIT)
        if not user_name:
            user_name = process_input(client, request.decode('utf-8'))
            user_name = user_name.rstrip()
            if user_name not in client_name_to_sock_mapping.keys():
                client_name_to_sock_mapping[user_name] = client
            else:
                msg = "Username not available".encode('ascii')
                client.send(msg)
        else:
            process_input(client, request.decode('utf-8'), user_name)

This is run from thread (2) 

def send_compute_to_client():
    time.sleep(20)
    print("Sleep over")
    for _, client_sock in client_name_to_sock_mapping.iteritems():
        print("client = {}".format(client_sock))
        client_sock.sendall("COMPUTE 1,2,3")
        print("send completed = {}".format(client_sock))
        data = client_sock.recv(1024)
        print("Computed results from client {}".format(data))

Can someone please explain this behaviour?

Upvotes: 0

Views: 634

Answers (1)

adriantunez
adriantunez

Reputation: 1038

I have faced similar problems in the past. That happens when in one thread you start a blocking action listening for a connection while in the other thread you send through the same socket.

If I understand it well, you always want to receive the response from the previously send data. So in order to solve it I would use locks to force that behaviour, so just create a class:

from threading import Lock

class ConnectionSession:
  def __init__(self, address, conn):
    self.ip = address[0]  # Optional info
    self.port = address[1] # Optional info
    self.conn = conn
    self.lock = Lock()

Here it goes how to create a ConnectionSession object properly when a listening socket is created:

address = ('127.0.0.1', 46140)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(address)
conn, addr = s.accept()
session = ConnectionSession(addr, conn)

And here it goes when a 'sending' connection is created:

address = ('127.0.0.1', 46140)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(address)
session = ConnectionSession(address, s)

Keep in mind that the created session instance is the one that needs to be shared among threads.

Afterwards, to send information through the shared socket you could do in each thread something like:

# Previous code
try:
    session.lock.acquire()
    session.conn.sendall("Hi there buddy!")
    # Do something if needed
    message = session.conn.recv(1024)
except Exception as e:
    print "Exception e=%s should be handled properly" % e
finally:
    if session.lock.locked():
        session.lock.release()
# Other code

Note that the finally block is important as it will free the locked connection whether if the action succeeded or not.

You can also wrap the previous code in a class, e.g: SocketManager with the following code in order to avoid having to explicitly acquire and release locks.

I hope it helps

Upvotes: 1

Related Questions