.. function:: start_new_thread(function, args[, kwargs])
- Start a new thread and return its identifier. The thread executes the function
- *function* with the argument list *args* (which must be a tuple). The optional
- *kwargs* argument specifies a dictionary of keyword arguments. When the function
- returns, the thread silently exits. When the function terminates with an
- unhandled exception, a stack trace is printed and then the thread exits (but
- other threads continue to run).
+ Start a new thread and return its identifier. The thread executes the
+ function *function* with the argument list *args* (which must be a tuple).
+ The optional *kwargs* argument specifies a dictionary of keyword arguments.
+
+ When the function returns, the thread silently exits.
+
+ When the function terminates with an unhandled exception,
+ :func:`sys.unraisablehook` is called to handle the exception. The *object*
+ attribute of the hook argument is *function*. By default, a stack trace is
+ printed and then the thread exits (but other threads continue to run).
+
+ When the function raises a :exc:`SystemExit` exception, it is silently
+ ignored.
+
+ .. versionchanged:: 3.8
+ :func:`sys.unraisablehook` is now used to handle unhandled exceptions.
.. function:: interrupt_main()
started.acquire()
self.assertIn("Traceback", stderr.getvalue())
+ def test_unraisable_exception(self):
+ def task():
+ started.release()
+ raise ValueError("task failed")
+
+ started = thread.allocate_lock()
+ with support.catch_unraisable_exception() as cm:
+ with support.wait_threads_exit():
+ started.acquire()
+ thread.start_new_thread(task, ())
+ started.acquire()
+
+ self.assertEqual(str(cm.unraisable.exc_value), "task failed")
+ self.assertIs(cm.unraisable.object, task)
+ self.assertEqual(cm.unraisable.err_msg,
+ "Exception ignored in thread started by")
+ self.assertIsNotNone(cm.unraisable.exc_traceback)
+
class Barrier:
def __init__(self, num_threads):
--- /dev/null
+:func:`_thread.start_new_thread` now logs uncaught exception raised by the
+function using :func:`sys.unraisablehook`, rather than :func:`sys.excepthook`,
+so the hook gets access to the function which raised the exception.
res = PyObject_Call(boot->func, boot->args, boot->keyw);
if (res == NULL) {
if (PyErr_ExceptionMatches(PyExc_SystemExit))
+ /* SystemExit is ignored silently */
PyErr_Clear();
else {
- PyObject *file;
- PyObject *exc, *value, *tb;
- PySys_WriteStderr(
- "Unhandled exception in thread started by ");
- PyErr_Fetch(&exc, &value, &tb);
- file = _PySys_GetObjectId(&PyId_stderr);
- if (file != NULL && file != Py_None)
- PyFile_WriteObject(boot->func, file, 0);
- else
- PyObject_Print(boot->func, stderr, 0);
- PySys_WriteStderr("\n");
- PyErr_Restore(exc, value, tb);
- PyErr_PrintEx(0);
+ _PyErr_WriteUnraisableMsg("in thread started by", boot->func);
}
}
- else
+ else {
Py_DECREF(res);
+ }
Py_DECREF(boot->func);
Py_DECREF(boot->args);
Py_XDECREF(boot->keyw);