remove unused and not-recommended Threads.Mutex (#32875)

Author: JeffBezanson

NEWS.md

@@ -106,6 +106,8 @@ Deprecated or removed
 ---------------------
 
 * `@spawn expr` from the `Distributed` standard library should be replaced with `@spawnat :any expr` ([#32600]).
+* `Threads.Mutex` and `Threads.RecursiveSpinLock` have been removed; use `ReentrantLock` (preferred) or
+  `Threads.SpinLock` instead ([#32875]).
 
 External dependencies
 ---------------------

base/deprecated.jl

@@ -188,3 +188,12 @@ MPFR.BigFloat(x::Real, prec::Int) = BigFloat(x; precision=prec)
 MPFR.BigFloat(x::Real, prec::Int, rounding::RoundingMode) = BigFloat(x, rounding; precision=prec)
 
 # END 1.0 deprecations
+
+# BEGIN 1.3 deprecations
+
+@eval Threads begin
+    Base.@deprecate_binding RecursiveSpinLock ReentrantLock
+    Base.@deprecate_binding Mutex ReentrantLock
+end
+
+# END 1.3 deprecations

base/locks-mt.jl

@@ -2,7 +2,7 @@
 
 import .Base: unsafe_convert, lock, trylock, unlock, islocked, wait, notify, AbstractLock
 
-export SpinLock, RecursiveSpinLock, Mutex
+export SpinLock
 
 # Important Note: these low-level primitives defined here
 #   are typically not for general usage
@@ -24,9 +24,6 @@ Each [`lock`](@ref) must be matched with an [`unlock`](@ref).
 Test-and-test-and-set spin locks are quickest up to about 30ish
 contending threads. If you have more contention than that, perhaps
 a lock is the wrong way to synchronize.
-
-See also [`Mutex`](@ref) for a more efficient version on one core or if the
-lock may be held for a considerable length of time.
 """
 struct SpinLock <: AbstractLock
     handle::Atomic{Int}
@@ -63,142 +60,3 @@ end
 function islocked(l::SpinLock)
     return l.handle[] != 0
 end
-
-"""
-    RecursiveSpinLock()
-
-Creates a reentrant lock.
-The same thread can acquire the lock as many times as required.
-Each [`lock`](@ref) must be matched with an [`unlock`](@ref).
-
-See also [`SpinLock`](@ref) for a slightly faster version.
-
-See also [`Mutex`](@ref) for a more efficient version on one core or if the lock
-may be held for a considerable length of time.
-"""
-struct RecursiveSpinLock <: AbstractLock
-    ownertid::Atomic{Int16}
-    handle::Atomic{Int}
-    RecursiveSpinLock() = new(Atomic{Int16}(0), Atomic{Int}(0))
-end
-
-function lock(l::RecursiveSpinLock)
-    if l.ownertid[] == threadid()
-        l.handle[] += 1
-        return
-    end
-    while true
-        if l.handle[] == 0
-            if atomic_cas!(l.handle, 0, 1) == 0
-                l.ownertid[] = threadid()
-                return
-            end
-        end
-        ccall(:jl_cpu_pause, Cvoid, ())
-        # Temporary solution before we have gc transition support in codegen.
-        ccall(:jl_gc_safepoint, Cvoid, ())
-    end
-end
-
-function trylock(l::RecursiveSpinLock)
-    if l.ownertid[] == threadid()
-        l.handle[] += 1
-        return true
-    end
-    if l.handle[] == 0
-        if atomic_cas!(l.handle, 0, 1) == 0
-            l.ownertid[] = threadid()
-            return true
-        end
-        return false
-    end
-    return false
-end
-
-function unlock(l::RecursiveSpinLock)
-    @assert(l.ownertid[] == threadid(), "unlock from wrong thread")
-    @assert(l.handle[] != 0, "unlock count must match lock count")
-    if l.handle[] == 1
-        l.ownertid[] = 0
-        l.handle[] = 0
-        ccall(:jl_cpu_wake, Cvoid, ())
-    else
-        l.handle[] -= 1
-    end
-    return
-end
-
-function islocked(l::RecursiveSpinLock)
-    return l.handle[] != 0
-end
-
-##########################################
-# System Mutexes
-##########################################
-
-# These are mutexes from libuv.
-const UV_MUTEX_SIZE = ccall(:jl_sizeof_uv_mutex, Cint, ())
-
-"""
-    Mutex()
-
-These are standard system mutexes for locking critical sections of logic.
-
-On Windows, this is a critical section object,
-on pthreads, this is a `pthread_mutex_t`.
-
-See also [`SpinLock`](@ref) for a lighter-weight lock.
-"""
-mutable struct Mutex <: AbstractLock
-    ownertid::Int16
-    handle::Ptr{Cvoid}
-    function Mutex()
-        m = new(zero(Int16), Libc.malloc(UV_MUTEX_SIZE))
-        ccall(:uv_mutex_init, Cvoid, (Ptr{Cvoid},), m.handle)
-        finalizer(mutex_destroy, m)
-        return m
-    end
-end
-
-unsafe_convert(::Type{Ptr{Cvoid}}, m::Mutex) = m.handle
-
-function mutex_destroy(x::Mutex)
-    h = x.handle
-    if h != C_NULL
-        x.handle = C_NULL
-        ccall(:uv_mutex_destroy, Cvoid, (Ptr{Cvoid},), h)
-        Libc.free(h)
-        nothing
-    end
-end
-
-function lock(m::Mutex)
-    m.ownertid == threadid() && concurrency_violation() # deadlock
-    # Temporary solution before we have gc transition support in codegen.
-    # This could mess up gc state when we add codegen support.
-    gc_state = ccall(:jl_gc_safe_enter, Int8, ())
-    ccall(:uv_mutex_lock, Cvoid, (Ptr{Cvoid},), m)
-    ccall(:jl_gc_safe_leave, Cvoid, (Int8,), gc_state)
-    m.ownertid = threadid()
-    return
-end
-
-function trylock(m::Mutex)
-    m.ownertid == threadid() && concurrency_violation() # deadlock
-    r = ccall(:uv_mutex_trylock, Cint, (Ptr{Cvoid},), m)
-    if r == 0
-        m.ownertid = threadid()
-    end
-    return r == 0
-end
-
-function unlock(m::Mutex)
-    m.ownertid == threadid() || concurrency_violation()
-    m.ownertid = 0
-    ccall(:uv_mutex_unlock, Cvoid, (Ptr{Cvoid},), m)
-    return
-end
-
-function islocked(m::Mutex)
-    return m.ownertid != 0
-end

doc/src/base/multi-threading.md

@@ -36,6 +36,5 @@ Base.@threadcall
 These building blocks are used to create the regular synchronization objects.
 
 ```@docs
-Base.Threads.Mutex
 Base.Threads.SpinLock
 ```

src/sys.c

@@ -75,7 +75,6 @@ JL_DLLEXPORT uint32_t jl_getutf8(ios_t *s)
     return wc;
 }
 
-JL_DLLEXPORT int jl_sizeof_uv_mutex(void) { return sizeof(uv_mutex_t); }
 JL_DLLEXPORT int jl_sizeof_off_t(void) { return sizeof(off_t); }
 #ifndef _OS_WINDOWS_
 JL_DLLEXPORT int jl_sizeof_mode_t(void) { return sizeof(mode_t); }

test/threads_exec.jl

@@ -2,7 +2,7 @@
 
 using Test
 using Base.Threads
-using Base.Threads: SpinLock, Mutex
+using Base.Threads: SpinLock
 
 # threading constructs
 
@@ -110,7 +110,6 @@ end
 
 @test threaded_add_locked(SpinLock, 0, 10000) == 10000
 @test threaded_add_locked(ReentrantLock, 0, 10000) == 10000
-@test threaded_add_locked(Mutex, 0, 10000) == 10000
 
 # Check if the recursive lock can be locked and unlocked correctly.
 let critical = ReentrantLock()
@@ -151,7 +150,6 @@ end
 
 threaded_gc_locked(SpinLock)
 threaded_gc_locked(Threads.ReentrantLock)
-threaded_gc_locked(Mutex)
 
 # Issue 14726
 # Make sure that eval'ing in a different module doesn't mess up other threads