multithreading to run UDP client and UDP server in the same program

Question

I am trying to write a code in python, using multithreading, that runs UDP server side and UDP client side in a single program file. I need to make sure that the threads are synchronized.

The problem (as far as i have understood) with my code is that when thread1 runs, it acquires the lock since thread1's run() method runs the serverSide() method which contains a forever while loop, thread1 does not release the lock and therefore, the program gets stuck.

Can anyone please help me synchronize the threads while making sure the server and client run properly

import threading
import time
import sys
from datetime import datetime
from socket import *


class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print "Starting " + self.name
        # Get lock to synchronize threads
        threadLock.acquire()
        serverSide()
        # Free lock to release next thread
        threadLock.release()

class myThread1 (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print "Starting " + self.name
        # Get lock to synchronize threads
        threadLock.acquire()
        clientSide()
        # Free lock to release next thread
        threadLock.release()



def serverSide():
    serverPort = 44000
    serverIP = '192.168.0.0'
    serverSocket = socket(AF_INET, SOCK_DGRAM)
    serverSocket.bind((serverIP,serverPort))
    print ("SERVER HERE!\nThe server is ready to receive")
    while 1:
        message, clientAddress = serverSocket.recvfrom(2048)
        modifiedMessage = message.upper()
        serverSocket.sendto(modifiedMessage, clientAddress)


def clientSide():
    serverIP = "192.168.0.0"
    serverPort = 44000
    clientSocket = socket(AF_INET, SOCK_DGRAM)
    message = raw_input("CLIENT HERE!\nInput lowercase sentence:")

    clientSocket.sendto(message.encode(),(serverIP, serverPort))
    modifiedMessage, serverAddress = clientSocket.recvfrom(2048)
    print(modifiedMessage) # print the received message

    clientSocket.close() # Close the socket

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread1(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"

Answer 1

Your code works fine except the synchronisation part.

So the issue is this, There is one threadLock = threading.Lock() which once acquired by either of the two threads the other thread wont be able to acquire.

Once a thread has acquired it, It wont release it till its job is done. It's job cant be done unless the other thread is up and running. The other thread is waiting for the 1st thread to release lock.

You have artificially manage to induce a race condition in your code which is not at all required. I simply removed the entire part with thread lock and its working fine. Except that i had to interrupt the program to end it.

import threading
import time
import sys
from datetime import datetime
from socket import *


class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("Starting " + self.name)
        # Get lock to synchronize threads
        # threadLock.acquire()
        serverSide()
        # Free lock to release next thread
        # threadLock.release()

class myThread1 (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("Starting " + self.name)
        # Get lock to synchronize threads
        # threadLock.acquire()
        clientSide()
        # Free lock to release next thread
        # threadLock.release()



def serverSide():
    serverPort = 44000
    serverIP = '127.0.0.1'
    serverSocket = socket(AF_INET, SOCK_DGRAM)
    serverSocket.bind((serverIP,serverPort))
    print ("SERVER HERE!\nThe server is ready to receive")
    while 1:
        message, clientAddress = serverSocket.recvfrom(2048)
        modifiedMessage = message.upper()
        serverSocket.sendto(modifiedMessage, clientAddress)


def clientSide():
    serverIP = "127.0.0.1"
    serverPort = 44000
    clientSocket = socket(AF_INET, SOCK_DGRAM)
    message = input("CLIENT HERE!\nInput lowercase sentence:")

    clientSocket.sendto(message.encode(),(serverIP, serverPort))
    modifiedMessage, serverAddress = clientSocket.recvfrom(2048)
    print("received", modifiedMessage) # print the received message

    clientSocket.close() # Close the socket

# threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread1(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print ("Exiting Main Thread")

output:

Starting Thread-1
Starting Thread-2
SERVER HERE!
The server is ready to receive
CLIENT HERE!
Input lowercase sentence:viki
received b'VIKI'

NOTE:

i am trying to write a code in python, using multithreading, that runs UDP server side and UDP client side in a single program file. i need to make sure that the threads are synchronized.

A client server architecture is in most cases not supposed to be synchronized. Google server and my browser are not synchronized. And they are not supposed to be same applies for your code. Reason for that being that a server should run independent of wether a client is running or not.

A client should run independent of wether a server is up or not. Client request will fail if the server is down. But still it should run.