@@ -157,7 +157,7 @@ platform_launch(void)
     pthread_key_create(&tidkey, NULL);
 }
 
-#endif
+#endif /* pthread threading */
 
 /* Win Thread */
 #ifdef NUMBA_WINTHREAD
@@ -262,7 +262,7 @@ platform_launch(void)
     tidkey = TlsAlloc();
 }
 
-#endif
+#endif /* Windows threading */
 
 typedef struct Task
 {
@@ -321,12 +321,20 @@ static THREAD_LOCAL(int) _TLS_num_threads = 0;
 static void
 set_num_threads(int count)
 {
+    if (!queues)
+    {
+        launch_threads(NUM_THREADS);
+    }
     _TLS_num_threads = count;
 }
 
 static int
 get_num_threads(void)
 {
+    if (!queues)
+    {
+        launch_threads(NUM_THREADS);
+    }
     // This is purely to permit the implementation to survive to the point
     // where it can exit cleanly as multiple threads cannot be used with this
     // backend
@@ -506,6 +514,11 @@ add_task_internal(void *fn, void *args, void *dims, void *steps, void *data, int
 {
     void (*func)(void *args, void *dims, void *steps, void *data) = fn;
 
+    if (!queues)
+    {
+        launch_threads(NUM_THREADS);
+    }
+
     Queue *queue = &queues[queue_pivot];
 
     Task *task = &queue->task;
@@ -581,6 +594,11 @@ static void launch_threads(int count)
 
 static void synchronize(void)
 {
+    // This probably isn't needed, but is put in as a guard
+    if (!queues)
+    {
+        launch_threads(NUM_THREADS);
+    }
     int i;
     for (i = 0; i < queue_count; ++i)
     {
@@ -590,6 +608,11 @@ static void synchronize(void)
 
 static void ready(void)
 {
+    // This probably isn't needed, but is put in as a guard
+    if (!queues)
+    {
+        launch_threads(NUM_THREADS);
+    }
     int i;
     for (i = 0; i < queue_count; ++i)
     {
@@ -601,8 +624,10 @@ static void reset_after_fork(void)
 {
     free(queues);
     queues = NULL;
-    NUM_THREADS = -1;
-    _INIT_NUM_THREADS = -1;
+    if (_INIT_NUM_THREADS != -1)
+    {
+        NUM_THREADS = _INIT_NUM_THREADS;
+    }
     _nesting_level = 0;
 }
 
 
@@ -690,6 +690,47 @@ def main():
             self.assertIn("Terminating: Nested parallel kernel launch detected",
                           e_msg)
 
+    @unittest.skipUnless(_HAVE_OS_FORK, "Test needs fork(2)")
+    def test_workqueue_handles_fork_from_non_main_thread(self):
+        # For context see #7872, but essentially the multiprocessing pool
+        # implementation has a number of Python threads for handling the worker
+        # processes, one of which calls fork(2), this results in a fork from a
+        # non-main thread.
+
+        runme = """if 1:
+            from numba import njit, prange, threading_layer
+            import numpy as np
+            import multiprocessing
+
+            if __name__ == "__main__":
+                # Need for force fork context (OSX default is "spawn")
+                multiprocessing.set_start_method('fork')
+
+                @njit(parallel=True)
+                def func(x):
+                    return 10. * x
+
+                arr = np.arange(2.)
+
+                # run in single process to start Numba's thread pool
+                np.testing.assert_allclose(func(arr), func.py_func(arr))
+
+                # now run in a multiprocessing pool to get a fork from a
+                # non-main thread
+                with multiprocessing.Pool(10) as p:
+                    result = p.map(func, [arr])
+                np.testing.assert_allclose(result,
+                                           func.py_func(np.expand_dims(arr, 0)))
+
+                assert threading_layer() == "workqueue"
+        """
+        cmdline = [sys.executable, '-c', runme]
+        env = os.environ.copy()
+        env['NUMBA_THREADING_LAYER'] = "workqueue"
+        env['NUMBA_NUM_THREADS'] = "4"
+
+        self.run_cmd(cmdline, env=env)
+
 
 # 32bit or windows py27 (not that this runs on windows)
 @skip_parfors_unsupported