threading.Timer is implemented with threading.Event.wait(timeout) which is implemented with threading.Condition.wait(timeout).

threading.Condition.wait(timeout) creates a lock called "waiter" and uses it to implement the wait:

   waiter.acquire(True, timeout)

So at the end of the chain, you find a lock created by _thread.allocate_lock() and the Lock.acquire(True, timeout) call.

At the C level, a lock is created by PyThread_allocate_lock(). The implementation of PyThread_allocate_lock() depends on the platform. Check:

>>> sys.thread_info
sys.thread_info(name='pthread', lock='semaphore', version='NPTL 2.25')

So in my case (Fedora 25), a Python lock is implemented as a semaphore:

* create the lock: sem_init()
* acquire the lock with a timeout: sem_timedwait(thelock, &ts)

The problem is that the sem_timedwait() function of the glibc doesn't allow to specify which clock is used:

https://sourceware.org/bugzilla/show_bug.cgi?id=14717

The second problem is that the glibc relies on the Linux kernel, and the kernel doesn't support specifiying a clock (extract of the glib bug):

"It seems this would need kernel work"

--

For sys.thread_info.lock == "mutex+cond", PyThread_allocate_lock(timeout) is implemented with pthread_mutex_lock() + pthread_cond_timedwait(). The good news is that this API allows to specify the clock:

pthread_condattr_init(&attr);
pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
pthread_cond_init(&cond, &attr);

... I already created bpo-23428 to call "pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);" in Python, it was 2 years ago ;-)