Miscellaneous task/thread related tweaks (JuliaLang#36927)

- use ThreadSynchronizer type alias in ReentrantLock
- tweak the `timedwait` documentation; in particular, rename the `testcb`
  argument to `callback`
- clarify an "Special note for Threads.Condition" to not reference a
  variable `c` that was never defined

base/asyncevent.jl

@@ -256,11 +256,11 @@ function Timer(cb::Function, timeout::Real; interval::Real=0.0)
 end
 
 """
-    timedwait(testcb::Function, timeout::Real; pollint::Real=0.1)
+    timedwait(callback::Function, timeout::Real; pollint::Real=0.1)
 
-Waits until `testcb` returns `true` or for `timeout` seconds, whichever is earlier.
-`testcb` is polled every `pollint` seconds. The minimum duration for `timeout` and `pollint`
-is 1 millisecond or `0.001`.
+Waits until `callback` returns `true` or `timeout` seconds have passed, whichever is earlier.
+`callback` is polled every `pollint` seconds. The minimum value for `timeout` and `pollint`
+is `0.001`, that is, 1 millisecond.
 
 Returns :ok or :timed_out
 """

base/lock.jl

@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+const ThreadSynchronizer = GenericCondition{Threads.SpinLock}
+
 # Advisory reentrant lock
 """
     ReentrantLock()
@@ -10,10 +12,10 @@ Each [`lock`](@ref) must be matched with an [`unlock`](@ref).
 """
 mutable struct ReentrantLock <: AbstractLock
     locked_by::Union{Task, Nothing}
-    cond_wait::GenericCondition{Threads.SpinLock}
+    cond_wait::ThreadSynchronizer
     reentrancy_cnt::Int
 
-    ReentrantLock() = new(nothing, GenericCondition{Threads.SpinLock}(), 0)
+    ReentrantLock() = new(nothing, ThreadSynchronizer(), 0)
 end
 
 assert_havelock(l::ReentrantLock) = assert_havelock(l, l.locked_by)
@@ -232,17 +234,15 @@ end
     """
     Special note for [`Threads.Condition`](@ref):
 
-    The caller must be holding the [`lock`](@ref) that owns `c` before calling this method.
+    The caller must be holding the [`lock`](@ref) that owns a `Threads.Condition` before calling this method.
     The calling task will be blocked until some other task wakes it,
-    usually by calling [`notify`](@ref) on the same Condition object.
+    usually by calling [`notify`](@ref) on the same `Threads.Condition` object.
     The lock will be atomically released when blocking (even if it was locked recursively),
     and will be reacquired before returning.
     """
     wait(c::Condition)
 end
 
-const ThreadSynchronizer = GenericCondition{Threads.SpinLock}
-
 """
     Semaphore(sem_size)