Add an exclusive parameter to GIL.lock and GIL.@lock

Setting the exclusive parameter to false allow for the old behavior
of only depending on Python's GIL mechanisms. Setting the exclusive
parameter to false bypasses the ReentrantLock `GIL._jl_gil_lock`.

Author: mkitti

src/GIL/GIL.jl

@@ -24,18 +24,23 @@ Returns `true` if the current thread has the GIL or `false` otherwise.
 hasgil() = C.PyGILState_Check() == Cint(1)
 
 """
-    lock(f)
+    lock(f; exclusive=true)
 
 Lock the GIL, compute `f()`, unlock the GIL, then return the result of `f()`.
 
 Use this to run Python code from threads that do not currently hold the GIL, such as new
 threads. Since the main Julia thread holds the GIL by default, you will need to
 [`unlock`](@ref) the GIL before using this function.
 
+Setting the `exclusive` keyword to `false` allows more than one Julia `Task`
+to attempt to acquire the GIL. This may be useful if one Julia `Task` calls
+code which releases the GIL, in which case another Julia task could acquire
+it. However, this is probably not a sound approach.
+
 See [`@lock`](@ref) for the macro form.
 """
-function lock(f)
-    Base.lock(_jl_gil_lock)
+function lock(f; exclusive=true)
+    exclusive && Base.lock(_jl_gil_lock)
     try
         state = C.PyGILState_Ensure()
         try
@@ -44,19 +49,24 @@ function lock(f)
             C.PyGILState_Release(state)
         end
     finally
-        Base.unlock(_jl_gil_lock)
+        exclusive && Base.unlock(_jl_gil_lock)
     end
 end
 
 """
-    @lock expr
+    @lock [exclusive=true] expr
 
 Lock the GIL, compute `expr`, unlock the GIL, then return the result of `expr`.
 
 Use this to run Python code from threads that do not currently hold the GIL, such as new
 threads. Since the main Julia thread holds the GIL by default, you will need to
 [`@unlock`](@ref) the GIL before using this function.
 
+Setting the `exclusive` parameter to `false` allows more than one Julia `Task`
+to attempt to acquire the GIL. This may be useful if one Julia `Task` calls
+code which releases the GIL, in which case another Julia task could acquire
+it. However, this is probably not a sound approach.
+
 The macro equivalent of [`lock`](@ref).
 """
 macro lock(expr)
@@ -75,6 +85,27 @@ macro lock(expr)
     end
 end
 
+macro lock(parameter, expr)
+    parameter.head == :(=) &&
+        parameter.args[1] == :exclusive ||
+        throw(ArgumentError("The only accepted parameter to @lock is `exclusive`."))
+
+    do_lock = esc(parameter.args[2])
+    quote
+        $do_lock && Base.lock(_jl_gil_lock)
+        try
+            state = C.PyGILState_Ensure()
+            try
+                $(esc(expr))
+            finally
+                C.PyGILState_Release(state)
+            end
+        finally
+            $do_lock && Base.unlock(_jl_gil_lock)
+        end
+    end
+end
+
 """
     unlock(f)
 

test/GIL.jl

@@ -4,7 +4,7 @@
     function threaded_sleep()
         PythonCall.GIL.unlock() do
             Threads.@threads for i = 1:2
-                PythonCall.GIL.lock() do
+                PythonCall.GIL.lock(exclusive=false) do
                     pyimport("time").sleep(1)
                 end
             end
@@ -33,7 +33,7 @@ end
     # GIL, these can happen in parallel if Julia has at least 2 threads.
     function threaded_sleep()
         PythonCall.GIL.@unlock Threads.@threads for i = 1:2
-            PythonCall.GIL.@lock pyimport("time").sleep(1)
+            PythonCall.GIL.@lock exclusive=false pyimport("time").sleep(1)
         end
     end
     # one run to ensure it's compiled