add @acquire

Author: IanButterworth

NEWS.md

@@ -22,6 +22,7 @@ New language features
   The available metrics are:
   - actual running time for the task (`Base.Experimental.task_running_time_ns`), and
   - wall-time for the task (`Base.Experimental.task_wall_time_ns`).
+  - New `Base.@acquire` macro for a non-closure version of `Base.acquire(f, s::Base.Semaphore)`, like `@lock`. ([#xxx])
 
 Language changes
 ----------------

base/lock.jl

@@ -479,6 +479,70 @@ function acquire(f, s::Semaphore)
     end
 end
 
+"""
+    @acquire s::Semaphore expr
+
+Execute `f` after acquiring from Semaphore `s`,
+and `release` on completion or error.
+
+For example, a do-block form that ensures only 2
+calls of `foo` will be active at the same time:
+
+```julia
+s = Base.Semaphore(2)
+@sync for _ in 1:100
+    Threads.@spawn begin
+        Base.acquire(s) do
+            foo()
+        end
+    end
+end
+```
+
+!!! compat "Julia 1.8"
+    This method requires at least Julia 1.8.
+
+"""
+function acquire(f, s::Semaphore)
+    acquire(s)
+    try
+        return f()
+    finally
+        release(s)
+    end
+end
+
+"""
+    @acquire s::Semaphore expr
+
+Macro version of `Base.acquire(f, s::Semaphore)` but with `expr` instead of `f` function.
+Expands to:
+```julia
+Base.acquire(s)
+try
+    expr
+finally
+    Base.release(s)
+end
+```
+This is similar to using [`acquire`](@ref) with a `do` block, but avoids creating a closure
+and thus can improve the performance.
+
+!!! compat
+    `@acquire` was added in Julia 1.12
+"""
+macro acquire(s, expr)
+    quote
+        temp = $(esc(s))
+        Base.acquire(temp)
+        try
+            $(esc(expr))
+        finally
+            Base.release(temp)
+        end
+    end
+end
+
 """
     release(s::Semaphore)
 

base/public.jl

@@ -26,6 +26,7 @@ public
 # Semaphores
     Semaphore,
     acquire,
+    @acquire,
     release,
 
 # arrays

test/misc.jl

@@ -237,6 +237,24 @@ end
     @test all(<=(sem_size), history)
     @test all(>=(0), history)
     @test history[end] == 0
+
+    # macro form
+    clock = Threads.Atomic{Int}(1)
+    occupied = Threads.Atomic{Int}(0)
+    history = fill!(Vector{Int}(undef, 2n), -1)
+    @sync for _ in 1:n
+        @async begin
+            @test Base.@acquire s begin
+                history[Threads.atomic_add!(clock, 1)] = Threads.atomic_add!(occupied, 1) + 1
+                sleep(rand(0:0.01:0.1))
+                history[Threads.atomic_add!(clock, 1)] = Threads.atomic_sub!(occupied, 1) - 1
+                return :resultvalue
+            end === :resultvalue
+        end
+    end
+    @test all(<=(sem_size), history)
+    @test all(>=(0), history)
+    @test history[end] == 0
 end
 
 # task switching