Index: Lib/test/test_capi.py
===================================================================
--- Lib/test/test_capi.py	(revision 67120)
+++ Lib/test/test_capi.py	(working copy)
@@ -35,6 +35,49 @@
             raise test_support.TestFailed, \
                   "Couldn't find main thread correctly in the list"
 
+    def TestPendingCalls_Submit(l, n):
+        def callback():
+            l[0] += 1
+            
+        _testcapi._pending_threadfunc(callback, n);
+        
+    def TestPendingCalls_Wait(l, n):
+        #now, stick around until l[0] has grown to 10
+        count = 0;
+        while l[0] != n:
+            #this busy loop is where we expect to be interrupted to
+            #run our callbacks.  Note that callbacks are only run on the
+            #main thread
+            if test_support.verbose:
+                print "(%i)"%(l[0],),
+            for i in xrange(1000):
+                a = i*i
+            count += 1
+            if count > 10000:
+                raise test_support.TestFailed, \
+                    "timeout waiting for %i callbacks, got %i"%(n, count)
+        if test_support.verbose:
+            print "(%i)"%(l[0],)
+
+    def TestPendingCalls():
+        if test_support.verbose:
+            print "pending-calls"
+        l = [0]
+        n = 5
+        import threading
+        t = threading.Thread(target=TestPendingCalls_Submit, args = (l, n))
+        t.start()
+        TestPendingCalls_Wait(l, n)
+        t.join()
+        
+        #again, just using the main thread, likely they will all be dispathced at
+        #once.  We must be careful not to ask for too many.  The queue can handle
+        #at most 32 and since we are on a single thread, we would wait forever
+        #for the queue to become free
+        l[0] = 0
+        TestPendingCalls_Submit(l, n)
+        TestPendingCalls_Wait(l, n)
+        
     try:
         _testcapi._test_thread_state
         have_thread_state = True
Index: Modules/_testcapimodule.c
===================================================================
--- Modules/_testcapimodule.c	(revision 67120)
+++ Modules/_testcapimodule.c	(working copy)
@@ -709,6 +709,50 @@
 		return NULL;
 	Py_RETURN_NONE;
 }
+
+/* test Py_AddPendingCalls using threads */
+static int _pending_callback(void *arg)
+{
+	/* we assume the argument is callable object to which we own a reference */
+	PyObject *callable = (PyObject *)arg;
+	PyObject *r = PyObject_CallObject(callable, NULL);
+	Py_DECREF(callable);
+	Py_DECREF(r);
+	return r != NULL ? 0 : -1;
+}
+
+/* The following requests n callbacks to _pending_callback.  It can be
+ * run from any python thread.
+ */
+PyObject *pending_threadfunc(PyObject *self, PyObject *arg)
+{
+	PyObject *callable;
+	int n;
+	int i, j, k;
+	if (PyArg_ParseTuple(arg, "Oi", &callable, &n) == 0)
+		return NULL;
+
+	/* create references upfront, while we hold the lock */
+	for(i = 0; i<n; i++)
+		Py_INCREF(callable);
+
+	Py_BEGIN_ALLOW_THREADS
+	k = 0;
+	for(i = 0; i<n; i++) {
+		int r = Py_AddPendingCall(&_pending_callback, callable);
+		if (r < 0)
+			i--; /* deal with full queue */
+		if (i+1<n) {
+			/* sleep a bit.  No good portable way to do this, so lets just spend
+			 * cpu cycles
+			 */
+			for(j = 0; j< 10000000; j++)
+				k += j;
+		}
+	}
+	Py_END_ALLOW_THREADS
+	Py_RETURN_NONE;
+}
 #endif
 
 /* Some tests of PyString_FromFormat().  This needs more tests. */
@@ -811,6 +855,7 @@
 #endif
 #ifdef WITH_THREAD
 	{"_test_thread_state",  test_thread_state, 		 METH_VARARGS},
+	{"_pending_threadfunc",	pending_threadfunc,		 METH_VARARGS},
 #endif
 	{"traceback_print", traceback_print, 	         METH_VARARGS},
 	{NULL, NULL} /* sentinel */
Index: Python/ceval.c
===================================================================
--- Python/ceval.c	(revision 67120)
+++ Python/ceval.c	(working copy)
@@ -213,6 +213,7 @@
 #include "pythread.h"
 
 static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */
+static PyThread_type_lock pending_lock = 0; /* for pending calls */
 static long main_thread = 0;
 
 int
@@ -284,6 +285,7 @@
 	  adding a new function to each thread_*.h.  Instead, just
 	  create a new lock and waste a little bit of memory */
 	interpreter_lock = PyThread_allocate_lock();
+	pending_lock = PyThread_allocate_lock();
 	PyThread_acquire_lock(interpreter_lock, 1);
 	main_thread = PyThread_get_thread_ident();
 
@@ -357,7 +359,102 @@
    Any thread can schedule pending calls, but only the main thread
    will execute them.
 #endif
+*/
 
+#ifdef WITH_THREAD
+
+/* The WITH_THREAD implementation is thread-safe.  It allows
+   scheduling to be made from any thread, and even from an executing
+   callback.
+ */
+
+#define NPENDINGCALLS 32
+static struct {
+	int (*func)(void *);
+	void *arg;
+} pendingcalls[NPENDINGCALLS];
+static int pendingfirst = 0;
+static int pendinglast = 0;
+static int things_to_do = 1; /* trigger initialization of lock */
+
+int
+Py_AddPendingCall(int (*func)(void *), void *arg)
+{
+	int i, j, result=0;
+	
+	/* try a few times for the lock.  Since this mechanism is used
+	 * for signal handling (on the main thread), there is a (slim)
+	 * chance that a signal is delivered on the same thread while we
+	 * hold the lock during the Py_MakePendingCalls() function.
+	 * This avoids a deadlock in that case.
+	 * Note that signals can be delivered on any thread.  In particular,
+	 * on Windows, a SIGINT is delivered on a system-created worker
+	 * thread.
+	 */
+	for (i = 0; i<100; i++) {
+		if (PyThread_acquire_lock(pending_lock, NOWAIT_LOCK))
+			break;
+	}
+	if (i == 100)
+		return -1;
+
+	i = pendinglast;
+	j = (i + 1) % NPENDINGCALLS;
+	if (j == pendingfirst) {
+		result = -1; /* Queue full */
+	} else {
+		pendingcalls[i].func = func;
+		pendingcalls[i].arg = arg;
+		pendinglast = j;
+	}
+	/* signal main loop */
+	_Py_Ticker = 0;
+	things_to_do = 1;
+	PyThread_release_lock(pending_lock);
+	return result;
+}
+
+int
+Py_MakePendingCalls(void)
+{
+	int i;
+	if (!pending_lock)
+		/* initial allocation of the lock */
+		pending_lock = PyThread_allocate_lock();
+
+	/* only service pending calls on main thread */
+	if (main_thread && PyThread_get_thread_ident() != main_thread)
+		return 0; 
+	/* perform a bounded number of calls, in case of recursion */
+	for (i=0; i<NPENDINGCALLS; i++) {
+		int j;  
+		int (*func)(void *);
+		void *arg;
+		
+		/* pop one item off the queue while holding the lock */
+		PyThread_acquire_lock(pending_lock, WAIT_LOCK);
+		j = pendingfirst;
+		if (j == pendinglast) {
+			func = NULL; /* Queue empty */
+		} else {
+			func = pendingcalls[j].func;
+			arg = pendingcalls[j].arg;
+			pendingfirst = (j + 1) % NPENDINGCALLS;
+		}
+		things_to_do = pendingfirst != pendinglast;
+		PyThread_release_lock(pending_lock);
+		/* having released the lock, perform the callback */
+		if (func == NULL)
+			break;
+		if (func(arg) < 0)
+			return -1;
+	}
+	return 0;
+}
+
+#else
+
+/*
    XXX WARNING!  ASYNCHRONOUSLY EXECUTING CODE!
    There are two possible race conditions:
    (1) nested asynchronous registry calls;
@@ -440,7 +537,9 @@
 	return 0;
 }
 
+#endif /* WITH_THREAD */
 
+
 /* The interpreter's recursion limit */
 
 #ifndef Py_DEFAULT_RECURSION_LIMIT