diff --git a/Makefile.pre.in b/Makefile.pre.in

index 8da1965..9864fe2 100644

--- a/Makefile.pre.in

+++ b/Makefile.pre.in

@@ -884,7 +884,8 @@ regen-opcode-targets:

 		$(srcdir)/Python/opcode_targets.h.new

 	$(UPDATE_FILE) $(srcdir)/Python/opcode_targets.h $(srcdir)/Python/opcode_targets.h.new

-Python/ceval.o: $(srcdir)/Python/opcode_targets.h $(srcdir)/Python/ceval_gil.h

+Python/ceval.o: $(srcdir)/Python/opcode_targets.h $(srcdir)/Python/ceval_gil.h \

+		$(srcdir)/Python/condvar.h

 Python/frozen.o: $(srcdir)/Python/importlib.h $(srcdir)/Python/importlib_external.h

@@ -1706,7 +1707,7 @@ patchcheck: @DEF_MAKE_RULE@

 # Dependencies

-Python/thread.o: @THREADHEADERS@

+Python/thread.o: @THREADHEADERS@ $(srcdir)/Python/condvar.h

 # Declare targets that aren't real files

 .PHONY: all build_all sharedmods check-clean-src oldsharedmods test quicktest

diff --git a/Python/ceval.c b/Python/ceval.c

index 0b30cc1..3f1300c 100644

--- a/Python/ceval.c

+++ b/Python/ceval.c

@@ -232,6 +232,7 @@ PyEval_InitThreads(void)

 {

     if (gil_created())

         return;

+    PyThread_init_thread();

     create_gil();

     take_gil(PyThreadState_GET());

     main_thread = PyThread_get_thread_ident();

diff --git a/Python/condvar.h b/Python/condvar.h

index 9a71b17..39a420f 100644

--- a/Python/condvar.h

+++ b/Python/condvar.h

@@ -59,20 +59,6 @@

 #include <pthread.h>

-#define PyCOND_ADD_MICROSECONDS(tv, interval) \

-do { /* TODO: add overflow and truncation checks */ \

-    tv.tv_usec += (long) interval; \

-    tv.tv_sec += tv.tv_usec / 1000000; \

-    tv.tv_usec %= 1000000; \

-} while (0)

-

-/* We assume all modern POSIX systems have gettimeofday() */

-#ifdef GETTIMEOFDAY_NO_TZ

-#define PyCOND_GETTIMEOFDAY(ptv) gettimeofday(ptv)

-#else

-#define PyCOND_GETTIMEOFDAY(ptv) gettimeofday(ptv, (struct timezone *)NULL)

-#endif

-

 /* The following functions return 0 on success, nonzero on error */

 #define PyMUTEX_T pthread_mutex_t

 #define PyMUTEX_INIT(mut)       pthread_mutex_init((mut), NULL)

@@ -81,32 +67,30 @@ do { /* TODO: add overflow and truncation checks */ \

 #define PyMUTEX_UNLOCK(mut)     pthread_mutex_unlock(mut)

 #define PyCOND_T pthread_cond_t

-#define PyCOND_INIT(cond)       pthread_cond_init((cond), NULL)

+#define PyCOND_INIT(cond)       _PyThread_cond_init(cond)

 #define PyCOND_FINI(cond)       pthread_cond_destroy(cond)

 #define PyCOND_SIGNAL(cond)     pthread_cond_signal(cond)

 #define PyCOND_BROADCAST(cond)  pthread_cond_broadcast(cond)

 #define PyCOND_WAIT(cond, mut)  pthread_cond_wait((cond), (mut))

+/* These private functions are implemented in Python/thread_pthread.h */

+int _PyThread_cond_init(PyCOND_T *cond);

+void _PyThread_cond_after(long long us, struct timespec *abs);

+

 /* return 0 for success, 1 on timeout, -1 on error */

 Py_LOCAL_INLINE(int)

 PyCOND_TIMEDWAIT(PyCOND_T *cond, PyMUTEX_T *mut, long long us)

 {

-    int r;

-    struct timespec ts;

-    struct timeval deadline;

-

-    PyCOND_GETTIMEOFDAY(&deadline);

-    PyCOND_ADD_MICROSECONDS(deadline, us);

-    ts.tv_sec = deadline.tv_sec;

-    ts.tv_nsec = deadline.tv_usec * 1000;

-

-    r = pthread_cond_timedwait((cond), (mut), &ts);

-    if (r == ETIMEDOUT)

+    struct timespec abs;

+    _PyThread_cond_after(us, &abs;;

+    int ret = pthread_cond_timedwait(cond, mut, &abs;;

+    if (ret == ETIMEDOUT) {

         return 1;

-    else if (r)

+    }

+    if (ret) {

         return -1;

-    else

-        return 0;

+    }

+    return 0;

 }

 #elif defined(NT_THREADS)

diff --git a/Python/thread.c b/Python/thread.c

index 63eeb1e..c5d0e59 100644

--- a/Python/thread.c

+++ b/Python/thread.c

@@ -6,6 +6,7 @@

    Stuff shared by all thread_*.h files is collected here. */

 #include "Python.h"

+#include "condvar.h"

 #ifndef _POSIX_THREADS

 /* This means pthreads are not implemented in libc headers, hence the macro

diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h

index baea71f..7dc295e 100644

--- a/Python/thread_pthread.h

+++ b/Python/thread_pthread.h

@@ -66,16 +66,6 @@

 #endif

 #endif

-#if !defined(pthread_attr_default)

-#  define pthread_attr_default ((pthread_attr_t *)NULL)

-#endif

-#if !defined(pthread_mutexattr_default)

-#  define pthread_mutexattr_default ((pthread_mutexattr_t *)NULL)

-#endif

-#if !defined(pthread_condattr_default)

-#  define pthread_condattr_default ((pthread_condattr_t *)NULL)

-#endif

-

 /* Whether or not to use semaphores directly rather than emulating them with

  * mutexes and condition variables:

@@ -120,6 +110,56 @@ do { \

 } while(0)

+/*

+ * pthread_cond support

+ */

+

+#if defined(HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)

+// monotonic is supported statically.  It doesn't mean it works on runtime.

+#define CONDATTR_MONOTONIC

+#endif

+

+// NULL when pthread_condattr_setclock(CLOCK_MONOTONIC) is not supported.

+static pthread_condattr_t *condattr_monotonic = NULL;

+

+static void

+init_condattr()

+{

+#ifdef CONDATTR_MONOTONIC

+    static pthread_condattr_t ca;

+    pthread_condattr_init(&ca);

+    if (pthread_condattr_setclock(&ca, CLOCK_MONOTONIC) == 0) {

+        condattr_monotonic = &ca;  // Use monotonic clock

+    }

+#endif

+}

+

+int

+_PyThread_cond_init(PyCOND_T *cond)

+{

+    return pthread_cond_init(cond, condattr_monotonic);

+}

+

+void

+_PyThread_cond_after(long long us, struct timespec *abs)

+{

+#ifdef CONDATTR_MONOTONIC

+    if (condattr_monotonic) {

+        clock_gettime(CLOCK_MONOTONIC, abs);

+        abs->tv_sec  += us / 1000000;

+        abs->tv_nsec += (us % 1000000) * 1000;

+        abs->tv_sec  += abs->tv_nsec / 1000000000;

+        abs->tv_nsec %= 1000000000;

+        return;

+    }

+#endif

+

+    struct timespec ts;

+    MICROSECONDS_TO_TIMESPEC(us, ts);

+    *abs = ts;

+}

+

+

 /* A pthread mutex isn't sufficient to model the Python lock type

  * because, according to Draft 5 of the docs (P1003.4a/D5), both of the

  * following are undefined:

@@ -175,6 +215,7 @@ PyThread__init_thread(void)

     extern void pthread_init(void);

     pthread_init();

 #endif

+    init_condattr();

 }

 #endif /* !_HAVE_BSDI */

@@ -449,8 +490,7 @@ PyThread_allocate_lock(void)

         memset((void *)lock, '\0', sizeof(pthread_lock));

         lock->locked = 0;

-        status = pthread_mutex_init(&lock->mut,

-                                    pthread_mutexattr_default);

+        status = pthread_mutex_init(&lock->mut, NULL);

         CHECK_STATUS_PTHREAD("pthread_mutex_init");

         /* Mark the pthread mutex underlying a Python mutex as

            pure happens-before.  We can't simply mark the

@@ -459,8 +499,7 @@ PyThread_allocate_lock(void)

            will cause errors. */

         _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&lock->mut);

-        status = pthread_cond_init(&lock->lock_released,

-                                   pthread_condattr_default);

+        status = _PyThread_cond_init(&lock->lock_released);

         CHECK_STATUS_PTHREAD("pthread_cond_init");

         if (error) {

@@ -519,9 +558,10 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,

             success = PY_LOCK_ACQUIRED;

         }

         else if (microseconds != 0) {

-            struct timespec ts;

-            if (microseconds > 0)

-                MICROSECONDS_TO_TIMESPEC(microseconds, ts);

+            struct timespec abs;

+            if (microseconds > 0) {

+                _PyThread_cond_after(microseconds, &abs;;

+            }

             /* continue trying until we get the lock */

             /* mut must be locked by me -- part of the condition

@@ -530,10 +570,13 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,

                 if (microseconds > 0) {

                     status = pthread_cond_timedwait(

                         &thelock->lock_released,

-                        &thelock->mut, &ts);

+                        &thelock->mut, &abs;;

+                    if (status == 1) {

+                        break;

+                    }

                     if (status == ETIMEDOUT)

                         break;

-                    CHECK_STATUS_PTHREAD("pthread_cond_timed_wait");

+                    CHECK_STATUS_PTHREAD("pthread_cond_timedwait");

                 }

                 else {

                     status = pthread_cond_wait(

diff --git a/configure.ac b/configure.ac

index a0e3613..8a17559 100644

--- a/configure.ac

+++ b/configure.ac

@@ -3582,7 +3582,7 @@ AC_CHECK_FUNCS(alarm accept4 setitimer getitimer bind_textdomain_codeset chown \

  memrchr mbrtowc mkdirat mkfifo \

  mkfifoat mknod mknodat mktime mremap nice openat pathconf pause pipe2 plock poll \

  posix_fallocate posix_fadvise pread \

- pthread_init pthread_kill putenv pwrite readlink readlinkat readv realpath renameat \

+ pthread_condattr_setclock pthread_init pthread_kill putenv pwrite readlink readlinkat readv realpath renameat \

  select sem_open sem_timedwait sem_getvalue sem_unlink sendfile setegid seteuid \

  setgid sethostname \

  setlocale setregid setreuid setresuid setresgid setsid setpgid setpgrp setpriority setuid setvbuf \