你可以在一个单独的Thread中运行socket consumer（接收器），并将它接收到的消息放入Queue中，然后使用tkinter的after方法在tkinter事件循环中消费消息。下面是一个例子：

...  # I'm leaving out your other imports for brevity's sake
import tkinter as tk
import tkinter.messagebox as tkm
from queue import Queue, Full, Empty
from threading import Thread, Event
from tkinter import ttk

class Root(tk.Tk):
    def __init__(self):
        super().__init__()  # initialze Tk
        self.title('My App!')
        self.geometry('200x200')
        # tell the app what to do when closing
        self.protocol('WM_DELETE_WINDOW', self.on_close)
        # this queue passes the msg from the worker to the main UI
        self.message_queue = Queue(maxsize=1) 
        # this event flag is how we'll stop the thread worker on exit
        self.stop_event = Event()  
        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        self.text = ttk.Label(self, text='Waiting for a message...')
        self.text.pack(expand=True, fill='both')
        self.consumer_loop_id = None  # placeholder for the consumer 'after' ID
        # this sets how quickly you want the consumer loop to check for updates
        self.loop_rate_ms = 100

        try:
            self.sock.connect(server_address)
        except socket.error as msg:
            tkm.showerror('An Error Occurred', msg)
            self.on_close()  # clean up and quit
        else:
            self.start_worker_thread()  # let's go!
            self.message_consumer()  # start the consumer loop

    # this function will get run in its own thread
    @staticmethod
    def socket_worker(sock, message_queue, stop_event):
        """Receive messages and put them into a lossy queue"""
        # keep running until the stop_event flag is set
        while not stop_event.is_set():  
            try:
                message = sock.recv(128).decode()
                # put msg in queue without blocking
                message_queue.put_nowait(message)  
            except Full:  # queue is full, last message hasn't been consumed yet...
                pass  # too bad, better luck next time
            except socket.error:
                stop_event.set()  # bail

    def start_socket_worker(self): 
        """Launch the worker thread"""
        self.worker_thread = Thread(
            name='Message Worker',  # not necessary, but helpful for debugging!
            target=self.socket_worker,
            args=(self.sock, self.message_queue, self.stop_event,)
        )
        self.worker_thread.start()

    def message_consumer(self):
        """Get messages from the queue and update the UI"""
        try:
            message = self.message_queue.get_nowait()
        except Empty:
            pass  # no message, nothing to do
        else: 
            self.text.config(text=message)  # update the label with the new message
        finally:
            self.consumer_loop_id = self.after(
                self.loop_rate_ms,
                self.message_consumer  # call this method again to keep looping!
            )
    
    def on_close(self):
        if self.consumer_loop_id:
            self.after_cancel(consumer_loop_id)  # stop the consumer loop
        if not self.stop_event.is_set():
            self.stop_event.set()  # stop the worker thread
        
        # NOTE: apparently 'join' is unnecessary for non-daemonic threads!
        # if self.worker_thread.is_alive():
            # self.worker_thread.join()

        self.sock.close()
        self.quit()

if __name__ == '__main__':
    app = Root()
    app.mainloop()  # start the app