diff --git a/Lib/tkinter/__init__.py b/Lib/tkinter/__init__.py
@@ -591,10 +591,15 @@ def get(self):
 
 
 def mainloop(n=0):
-    """Run the main loop of Tcl."""
+    """Run the main loop of tkinter."""
     _default_root.tk.mainloop(n)
 
 
+def dispatching():
+    """Determine if the tkinter main loop is running"""
+    return _default_root.tk.dispatching()
+
+
 getint = int
 
 getdouble = float
@@ -1303,13 +1308,13 @@ def winfo_y(self):
             self.tk.call('winfo', 'y', self._w))
 
     def update(self):
-        """Enter event loop until all pending events have been processed by Tcl."""
+        """Process all events, including idle tasks, in the Tcl queue."""
         self.tk.call('update')
 
     def update_idletasks(self):
-        """Enter event loop until all idle callbacks have been called. This
-        will update the display of windows but not process events caused by
-        the user."""
+        """Process all idle callbacks in the Tcl queue.
+        This will update the display of windows but not process events
+        caused by the user."""
         self.tk.call('update', 'idletasks')
 
     def bindtags(self, tagList=None):
@@ -1418,9 +1423,13 @@ def unbind_class(self, className, sequence):
         self.tk.call('bind', className , sequence, '')
 
     def mainloop(self, n=0):
-        """Call the mainloop of Tk."""
+        """Call the main loop of tkinter."""
         self.tk.mainloop(n)
 
+    def dispatching(self):
+        """Determine if the tkinter main loop is running."""
+        return self.tk.dispatching()
+
     def quit(self):
         """Quit the Tcl interpreter. All widgets will be destroyed."""
         self.tk.quit()

diff --git a/Lib/tkinter/test/support.py b/Lib/tkinter/test/support.py
@@ -22,7 +22,7 @@ def setUpClass(cls):
 
     @classmethod
     def tearDownClass(cls):
-        cls.root.update_idletasks()
+        cls.root.update()
         cls.root.destroy()
         del cls.root
         tkinter._default_root = None
@@ -38,7 +38,7 @@ def tearDown(self):
 
 def destroy_default_root():
     if getattr(tkinter, '_default_root', None):
-        tkinter._default_root.update_idletasks()
+        tkinter._default_root.update()
         tkinter._default_root.destroy()
         tkinter._default_root = None
 

diff --git a/Lib/tkinter/test/test_tkinter/test_misc.py b/Lib/tkinter/test/test_tkinter/test_misc.py
@@ -109,15 +109,15 @@ def callback(start=0, step=1):
         idle1 = root.after_idle(callback)
         self.assertIn(idle1, root.tk.call('after', 'info'))
         (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
-        root.update_idletasks()  # Process all pending events.
+        root.update()  # Process all pending events.
         self.assertEqual(count, 1)
         with self.assertRaises(tkinter.TclError):
             root.tk.call(script)
 
         # Set up with callback with args.
         count = 0
         idle1 = root.after_idle(callback, 42, 11)
-        root.update_idletasks()  # Process all pending events.
+        root.update()  # Process all pending events.
         self.assertEqual(count, 53)
 
         # Cancel before called.
@@ -192,6 +192,51 @@ def test_clipboard_astral(self):
         with self.assertRaises(tkinter.TclError):
             root.clipboard_get()
 
+    def test_mainloop_dispatching(self):
+        # reconstruct default root destroyed by AbstractTkTest
+        root = tkinter._default_root = self.root
+        for thing in (root.tk, root, tkinter):
+            #mainloop, dispatching, willdispatch
+            self.assertFalse(thing.dispatching())
+            root.after(0, lambda:self.assertTrue(thing.dispatching()))
+            root.after(0, root.quit)
+            root.mainloop()
+            self.assertFalse(thing.dispatching())
+
+    def test_thread_must_wait_for_mainloop(self):
+        import threading, time
+        def target():
+            self.assertFalse(root.dispatching())
+            with self.assertRaises(RuntimeError):
+                root.after(0)  # Null op
+
+            ready_for_mainloop.set()
+
+            # self.assertTrue(root.dispatching()) but patient
+            t = time.monotonic()
+            while not root.dispatching():
+                time.sleep(.001)
+                self.assertTrue(time.monotonic() < (t + 10))
+
+            root.quit()
+
+        root = self.root
+
+        # remove on eventual WaitForMainloop behavior change
+        root.tk.setmainloopwaitattempts(0)
+
+        ready_for_mainloop = threading.Event()
+        thread = threading.Thread(target=target)
+        self.assertFalse(root.dispatching())
+        thread.start()
+        ready_for_mainloop.wait()
+        root.mainloop()
+        self.assertFalse(root.dispatching())
+        thread.join()
+
+        with self.assertWarns(DeprecationWarning):
+            root.tk.setmainloopwaitattempts(10)
+
 
 tests_gui = (MiscTest, )
 

diff --git a/Lib/tkinter/test/test_ttk/test_extensions.py b/Lib/tkinter/test/test_ttk/test_extensions.py
@@ -10,7 +10,7 @@
 class LabeledScaleTest(AbstractTkTest, unittest.TestCase):
 
     def tearDown(self):
-        self.root.update_idletasks()
+        self.root.update()
         super().tearDown()
 
     def test_widget_destroy(self):
@@ -219,7 +219,7 @@ def test_widget_destroy(self):
         var = tkinter.StringVar(self.root)
         optmenu = ttk.OptionMenu(self.root, var)
         name = var._name
-        optmenu.update_idletasks()
+        optmenu.update()
         optmenu.destroy()
         self.assertEqual(optmenu.tk.globalgetvar(name), var.get())
         del var

diff --git a/Lib/tkinter/test/test_ttk/test_widgets.py b/Lib/tkinter/test/test_ttk/test_widgets.py
@@ -64,7 +64,7 @@ def setUp(self):
 
 
     def test_identify(self):
-        self.widget.update_idletasks()
+        self.widget.update()
         self.assertEqual(self.widget.identify(
             int(self.widget.winfo_width() / 2),
             int(self.widget.winfo_height() / 2)
@@ -327,7 +327,7 @@ def test_bbox(self):
     def test_identify(self):
         self.entry.pack()
         self.entry.wait_visibility()
-        self.entry.update_idletasks()
+        self.entry.update()
 
         # bpo-27313: macOS Cocoa widget differs from X, allow either
         if sys.platform == 'darwin':
@@ -439,7 +439,7 @@ def _show_drop_down_listbox(self):
         width = self.combo.winfo_width()
         self.combo.event_generate('<ButtonPress-1>', x=width - 5, y=5)
         self.combo.event_generate('<ButtonRelease-1>', x=width - 5, y=5)
-        self.combo.update_idletasks()
+        self.combo.update()
 
 
     def test_virtual_event(self):
@@ -1134,7 +1134,7 @@ def _click_increment_arrow(self):
         y = height//2 - 5
         self.spin.event_generate('<ButtonPress-1>', x=x, y=y)
         self.spin.event_generate('<ButtonRelease-1>', x=x, y=y)
-        self.spin.update_idletasks()
+        self.spin.update()
 
     def _click_decrement_arrow(self):
         width = self.spin.winfo_width()
@@ -1143,7 +1143,7 @@ def _click_decrement_arrow(self):
         y = height//2 + 4
         self.spin.event_generate('<ButtonPress-1>', x=x, y=y)
         self.spin.event_generate('<ButtonRelease-1>', x=x, y=y)
-        self.spin.update_idletasks()
+        self.spin.update()
 
     def test_command(self):
         success = []
@@ -1159,7 +1159,7 @@ def test_command(self):
 
         # testing postcommand removal
         self.spin['command'] = ''
-        self.spin.update_idletasks()
+        self.spin.update()
         self._click_increment_arrow()
         self._click_decrement_arrow()
         self.spin.update()

diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
@@ -360,21 +360,36 @@ Sleep(int milli)
 }
 #endif /* MS_WINDOWS */
 
-/* Wait up to 1s for the mainloop to come up. */
+/* Wait for the mainloop to come up. */
+static int mainloopwaitattempts = 10; // 1 second
 
 static int
 WaitForMainloop(TkappObject* self)
 {
     int i;
-    for (i = 0; i < 10; i++) {
-        if (self->dispatching)
-            return 1;
+    if (self->dispatching)
+    {
+        return 1;
+    }
+    for (i = 0; i < mainloopwaitattempts; i++) {
         Py_BEGIN_ALLOW_THREADS
         Sleep(100);
         Py_END_ALLOW_THREADS
+        if (self->dispatching) 
+        {
+            if (PyErr_WarnEx(PyExc_DeprecationWarning,
+                "It seems you are implicitly waiting for "
+                "the mainloop to come up.\n"
+                "This behavior is deprecated; consider polling "
+                "dispatching() instead.\n", 1))
+            {
+                /* return something nonzero, an error will be
+                raised elsewhere soon */
+                return -1;
+            }
+            return 1;
+        }
     }
-    if (self->dispatching)
-        return 1;
     PyErr_SetString(PyExc_RuntimeError, "main thread is not in main loop");
     return 0;
 }
@@ -1500,7 +1515,10 @@ Tkapp_Call(PyObject *selfptr, PyObject *args)
            marshal the parameters to the interpreter thread. */
         Tkapp_CallEvent *ev;
         Tcl_Condition cond = NULL;
-        PyObject *exc_type, *exc_value, *exc_tb;
+        PyObject *exc_type, *exc_value, *exc_tb;  
+        /* After WaitForMainloop deprecation: 
+        if (!self->dispatching)
+            return NULL; */
         if (!WaitForMainloop(self))
             return NULL;
         ev = (Tkapp_CallEvent*)attemptckalloc(sizeof(Tkapp_CallEvent));
@@ -1777,6 +1795,10 @@ var_invoke(EventFunc func, PyObject *selfptr, PyObject *args, int flags)
         /* The current thread is not the interpreter thread.  Marshal
            the call to the interpreter thread, then wait for
            completion. */
+
+        /* After WaitForMainloop deprecation: 
+        if (!self->dispatching)
+            return NULL; */
         if (!WaitForMainloop(self))
             return NULL;
 
@@ -2477,6 +2499,10 @@ _tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
         return NULL;
     }
 
+    /*After WaitForMainloop deprecation:
+    if (self->threaded && self->thread_id != Tcl_GetCurrentThread() &&
+        !self->dispatching)
+        return NULL; */
     if (self->threaded && self->thread_id != Tcl_GetCurrentThread() &&
         !WaitForMainloop(self))
         return NULL;
@@ -3024,15 +3050,70 @@ _tkinter.tkapp.willdispatch
 
 [clinic start generated code]*/
 
-static PyObject *
-_tkinter_tkapp_willdispatch_impl(TkappObject *self)
+static PyObject*
+_tkinter_tkapp_willdispatch_impl(TkappObject* self)
 /*[clinic end generated code: output=0e3f46d244642155 input=d88f5970843d6dab]*/
 {
+    if (PyErr_WarnEx(PyExc_DeprecationWarning,
+        "willdispatch() is deprecated; consider polling dispatch() instead.", 1))
+    {
+        return NULL;
+    }
     self->dispatching = 1;
 
     Py_RETURN_NONE;
 }
 
+/*[clinic input]
+_tkinter.tkapp.dispatching
+
+[clinic start generated code]*/
+
+static PyObject*
+_tkinter_tkapp_dispatching_impl(TkappObject* self)
+/*[clinic end generated code: output=0e3f46d244642155 input=d88f5970843d6dab]*/
+{
+    return PyLong_FromLong(self->dispatching);
+}
+
+/*[clinic input]
+_tkinter.setmainloopwaitattempts
+
+    new_val: int
+    /
+
+Set number of 100 millisecond mainloop wait attempts that call(), var_invoke(),
+and createcommand() will use.
+
+Current default is 10 for a 1 second wait, but future behavior will be equivalent 0.
+
+Setting anything other than 0 will trigger a DeprecationWarning.
+
+[clinic start generated code]*/
+
+static PyObject*
+_tkinter_tkapp_setmainloopwaitattempts_impl(PyObject* self, int new_val)
+/*[clinic end generated code: output=42bf7757dc2d0ab6 input=deca1d6f9e6dae47]*/
+{
+    if (new_val < 0) 
+    {
+        PyErr_SetString(PyExc_ValueError,
+            "mainloopwaitattempts must be >= 0");
+        return NULL;
+    }
+    if (new_val) 
+    {
+        if (PyErr_WarnEx(PyExc_DeprecationWarning,
+            "It seems you want to wait for the mainloop to come up.\n"
+            "This behavior is deprecated; consider polling dispatch() instead.", 1))
+        {
+            return NULL;
+        }
+    }
+    mainloopwaitattempts = new_val;
+    Py_RETURN_NONE;
+}
+
 
 /**** Tkapp Type Methods ****/
 
@@ -3252,6 +3333,8 @@ static PyType_Spec Tktt_Type_spec = {
 static PyMethodDef Tkapp_methods[] =
 {
     _TKINTER_TKAPP_WILLDISPATCH_METHODDEF
+    _TKINTER_TKAPP_DISPATCHING_METHODDEF
+    _TKINTER_TKAPP_SETMAINLOOPWAITATTEMPTS_METHODDEF
     {"wantobjects",            Tkapp_WantObjects, METH_VARARGS},
     {"call",                   Tkapp_Call, METH_VARARGS},
     _TKINTER_TKAPP_EVAL_METHODDEF