CustomTkinter messaging app using socket and threading slowing down once threading and server start

[JoshuaSizemore1]

So when I implemented a new GUI using customtkinter (replacing tkinter and ttk), my server and client both run very slowly when moving the application window and when updating widget info such as text. after they start their own threads (the client connecting to the server, and the server starting the server). All my threads are set up correctly and do not cause any problems with the old GUI. Wondering if there are any known problems witth customttkinter and threads.

[dipeshSam]

Try to put all GUI callbacks in different threads.

[JoshuaSizemore1]

I don't understand what you mean by this. I have all my GUI stuff in the main part of my code running with win.mainloop(). And everything involving my socket server are in their own separate threads. Sorry I am a bit new to socket, and threading, and customtkinter.

[dipeshSam]

No worries. By default, neither Tkinter nor CustomTkinter provides built-in support for multi-threading. Consequently, if a widget callback takes longer than the event loop to execute, the GUI window will pause or stuck, and other functionalities will become temporarily unavailable.

So, in such applications, we need to use Threads explicitly. Here are two code examples, Problem Example and Solution Example to demonstrate it better that without Threading it holds the GUI window, while using Threads, provides smoother experience.

Problem example:

from time import sleep
from customtkinter import CTk, CTkButton 


def send_msg():
    send_button.configure(text="Sending...", state="disabled")
    send_button.update()
    
    sleep(8)
    send_button.configure(text="Send", state="normal")
    
    

if __name__ == "__main__":
    app = CTk()
    app.geometry("500x300")

    send_button = CTkButton(app, text="Send", command=send_msg)
    send_button.place(relx=0.5, anchor="center", rely=0.5)


    app.mainloop()

Solution Example:

from time import sleep
from threading import Thread
from customtkinter import CTk, CTkButton 

def send_msg():
    send_button.configure(text="Sending...", state="disabled")
    send_button.update()

    sleep(8)
    send_button.configure(text="Send", state="normal")
 


def send_msg_thread():
    Thread(target=send_msg).start()
    
    

if __name__ == "__main__":
    app = CTk()
    app.geometry("500x300")
    

    send_button = CTkButton(app, text="Send", command=send_msg_thread)
    send_button.place(relx=0.5, anchor="center", rely=0.5)


    app.mainloop()

In the above two codes, first Problem example will create discrepancies and will pause or stuck the window. And, second Solution Example will run smoothly and correctly.

Hope this may be helpful to you. If there is anything else you want to have, mention here.
Regards

[JoshuaSizemore1]

The part that confuses me is that I believe I am already doing this or something similar for the buttons that start the server. Here is the button and the different methods it calls.

`
startButton = customtkinter.CTkButton(win, text= "Start Server", command= startServerThread)

def startServerThread():

global serverRunning
serverRunning = True
serverThread = threading.Thread(target= startServer)
serverThread.start()

def startServer():

global server
global serverRunning
global clientNumChange

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serverIp = "10.18.184.1"
print(serverIp)
port = 443
server.bind((serverIp, port))
server.listen(1)

clientTetheringThread = threading.Thread(target= clientTethering)
clientTetheringThread.start()

print("Online")


while serverRunning:

    if clientNumChange == True:
        currentUserText.configure(state= "normal")
        currentUserText.delete("1.0",customtkinter.END)
        for i in range(len(clients)):
            currentUserText.insert(customtkinter.END, "\n" + str(clients[i].id))
        for j in range(len(rooms)):
            currentUserText.insert(customtkinter.END, "\n" + str(rooms[j][0]))
        currentUserText.configure(state= "disabled")
        clientNumChange = False


print("Killed")
server.close()

`

And then it starts another thread that connects the client when they try to join. I don't know if this helps show what I am doing wrong. I am not threading all my button callbacks because some are very minimal I don't know if this will cause problems like you said though. Here is the button that is not threaded

`
endButton = customtkinter.CTkButton(win, text= "Shut Off Server", command= stopServer)

def stopServer():

global serverRunning
global clientNum
global totalClientsConnected

clients.clear()
clientNum = 0
totalClientsConnected = 0
serverRunning = False

`

Sorry this comment is a mess I have not used much github

[dipeshSam]

If this so, then an image or video demonstration on how your application window is lagging might be helpful in mitigating this problem.

Regards.

[JoshuaSizemore1]

2024-08-27 12-25-57.zip

Here is a video I took showing both the old and new GUI and how the application starts lagging when the server is started only on the new GUI using customtkinter. (I had to zip it because github would not allow me to just select the video if you want it another way just let me know).

[dipeshSam]

Fine. Is this https://github.com/JoshuaSizemore1/peerMessenger/blob/main/messagingServer.py your working file? May I test it?

[JoshuaSizemore1]

That is the file with the new GUI and the old GUI commented out you can probably figure it out you just have to change the ip to your machine because I have not worked on auto ip yet.

[dipeshSam]

I'll test it, then I'll put my views here.

[JoshuaSizemore1]

Alright thank you.

[dipeshSam]

In the file messagingServer.py, the issue of a slow GUI response can be addressed with the following modifications:

In the while loop of the startServer() function, it's essential to introduce a delay of at least 100 milliseconds. This helps prevent the GUI from becoming unresponsive if there are enough resources to increase computation complexity. Below is the revised version of your function:

def startServer():
    global server
    global serverRunning
    global clientNumChange

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serverIp = ...
    print(serverIp)
    port = 443
    server.bind((serverIp, port))
    server.listen(1)

    clientTetheringThread = threading.Thread(target= clientTethering)
    clientTetheringThread.start()
    
    print("Online")


    while serverRunning:

        if clientNumChange == True:
            currentUserText.configure(state= "normal")
            currentUserText.delete("1.0",customtkinter.END)
            for i in range(len(clients)):
                currentUserText.insert(customtkinter.END, "\n" + str(clients[i].id))
            for j in range(len(rooms)):
                currentUserText.insert(customtkinter.END, "\n" + str(rooms[j][0]))
            currentUserText.configure(state= "disabled")
            clientNumChange = False
            
            
        sleep(0.1)  # 100 milliseconds delay
            

    print("Killed")
    server.close()

Along with this change, it's recommended to set the serverThread as a daemon thread. This ensures that the server thread will be terminated when the GUI is closed, preventing any potential issues with lingering background processes. Here’s the updated version of your function:

def startServerThread():
    global serverRunning

    serverRunning = True
    serverThread = threading.Thread(target= startServer, daemon=True)
    serverThread.start()

These changes address the slow response issue in customtkinter, which is often due to its higher resource usage for rendering elements like rounded corners in Canvas. The Canvas component itself can be slow in updating its drawings, contributing to the lag. Implementing these modifications should improve the responsiveness of your GUI.

Also, in Tkinter GUI applications, an efficient way to handle loops is by using recursion in functions combined with the after() method. This method allows you to schedule a function to run after a specified delay, effectively creating a loop without blocking the main thread. For example, widget.after(100, func) will call the function func after 100 milliseconds. This approach ensures that the GUI remains responsive while the loop continues to execute, making it ideal for tasks that need to be performed repeatedly without freezing the interface.

Hope, above description would be helpful to you. What do you expect more, please mention here.
Regards.