How to make "nested multithreading" work in tkinter? [RuntimeError: main thread is not in main loop]

Question

As I mentioned in the comment lines, the idea behind is like this:

There is a root and a button on it, once the button's clicked there will be a splash screen popping up first while the elements of the top level getting ready but without the root screen getting frozen. Is there any way to make this happen? Thanks in advance!

from tkinter import *
import customtkinter
import threading

def splash_screen():
    global splash_screen
    splash_screen = Tk()

    label = customtkinter.CTkLabel(splash_screen, text="PLEASE WAIT...")
    label.pack(pady=30, padx=30)


def initiate():
    # get elements of the toplevel
    pass

def toplevel():
    # second main window after root
    pass

def func1():
    # to avoid root freezing
    threading.Thread(target=func2).start()

def func2():
    thread = threading.Thread(target=initiate)
    thread.start()

    splash_screen()
    # wait until toplevel is ready
    thread.join()
    splash_screen.destroy()

    toplevel()


root = customtkinter.CTk()

button = customtkinter.CTkButton(root, command=func1)
button.pack(pady=10, padx=10)

root.mainloop()

Traceback:

Exception in Tkinter callback
Traceback (most recent call last):
  File "D:\Python311\Lib\tkinter\__init__.py", line 1948, in __call__
    return self.func(*args)
           ^^^^^^^^^^^^^^^^
  File "D:\Python311\Lib\tkinter\__init__.py", line 861, in callit
    func(*args)
  File "D:\Python311\Lib\site-packages\customtkinter\windows\widgets\scaling\scaling_tracker.py", line 178, in check_dpi_scaling
    if window.winfo_exists() and not window.state() == "iconic":
       ^^^^^^^^^^^^^^^^^^^^^
  File "D:\Python311\Lib\tkinter\__init__.py", line 1139, in winfo_exists
    self.tk.call('winfo', 'exists', self._w))
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: main thread is not in main loop

Answer 1

Don't manipulate UI objects in a background thread.(Even though the tkinter allows manipulating UI objects in a background thread in some degree unlike other UI frameworks, it's best to avoid that.)

Call after_idle() in a background thread to interact with the main thread, like the following example. With this pattern, you don't need a nested thread.

import time
import threading
import tkinter

worker_thread = None
def worker_entry():
    def update_status(v):
        # This will run in the main UI thread.
        status_text.delete(1.0, 'end')
        status_text.insert('end', v)
    for i in range(30):
        root.after_idle(update_status, f'i:{i}')
        time.sleep(0.1)
    def join_worker():
        # This will run in the main UI thread.
        global worker_thread
        worker_thread.join()
        worker_thread = None
        start_worker_button['state'] = 'normal'
    root.after_idle(join_worker)
def on_start_worker():
    global worker_thread
    worker_thread = threading.Thread(target=worker_entry)
    worker_thread.start()
    start_worker_button['state'] = 'disabled'

root = tkinter.Tk()
start_worker_button = tkinter.Button(root, text='start worker',
    command=on_start_worker)
start_worker_button.pack()  
status_text = tkinter.Text(root)
status_text.pack()

root.mainloop()

As a side note, the above pattern is a de facto standard for UI frameworks. For example, there are the Dispatcher.BeginInvoke() in WPF, the QTimer::singleShot() in Qt, the gdk_threads_add_idle_full() in Gtk, the Activity.runOnUiThread() in Android, etc.

The following is another example covering the scenario of the OP, showing a splash window. The pattern is identical as the above.

import time
import threading
import tkinter

worker_thread = None
def worker_entry():
    def update_status(v):
        text = splash_win.status_text
        text.delete(1.0, 'end')
        text.insert('end', v)
    for i in range(30):
        root.after_idle(update_status, f'i:{i}')
        time.sleep(0.1)
    def join_worker():
        global worker_thread, splash_win
        worker_thread.join()
        worker_thread = None
        splash_win.destroy()
        splash_win = None
        start_worker_button['state'] = 'normal'
    root.after_idle(join_worker)
def on_start_worker():
    global worker_thread, splash_win
    splash_win = win = tkinter.Toplevel(root)
    splash_win.status_text = text = tkinter.Text(win)
    text.pack()
    worker_thread = threading.Thread(target=worker_entry)
    worker_thread.start()
    start_worker_button['state'] = 'disabled'

root = tkinter.Tk()
start_worker_button = tkinter.Button(root, text='start worker',
    command=on_start_worker)
start_worker_button.pack()  

root.mainloop()

As another side note, I experimented a scenario similar to one of the OP, where a second Tk root(Tcl interpreter) is created in the first background thread and found calling after_idle() in the second(nested) background thread causes a problem. By looking at the source, I found that the current implementation does not support this scenario.