Fix assert_havelock(::ReentrantLock) to assert that the _current-task_ has the lock.

[NHDaly]

Before this commit, new threads would incorrectly believe that they held
a lock on a Condition when they actually didn't, and would allow illegal
operations, e.g. notify:

julia> c = Threads.Condition()
Base.GenericCondition{ReentrantLock}(Base.InvasiveLinkedList{Task}(nothing, nothing), ReentrantLock(nothing, Base.GenericCondition{Base.Threads.SpinLock}(Base.InvasiveLinkedList{Task}(nothing, nothing), Base.Threads.SpinLock(Base.Threads.Atomic{Int64}(0))), 0))

julia> lock(c)

julia> fetch(Threads.@spawn Base.assert_havelock(c))  # This should be an ERROR (the new thread doesn't have the lock)

julia> fetch(Threads.@spawn notify(c))                # This should be an ERROR (the new thread doesn't have the lock)
0

julia> fetch(Threads.@spawn wait(c))                  # This error should be caught earlier (in assert_havelock).
ERROR: TaskFailedException:
unlock from wrong thread
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] unlockall(::ReentrantLock) at ./lock.jl:121
 [3] wait(::Base.GenericCondition{ReentrantLock}) at ./condition.jl:105
 [4] (::var"##19#20")() at ./threadingconstructs.jl:113

(The same holds for @async as @spawn.)

After this change, the assertion works correctly:

julia> c = Threads.Condition();

julia> lock(c)

julia> fetch(Threads.@spawn Base.assert_havelock(c))  # This correctly ERRORs
ERROR: TaskFailedException:
concurrency violation detected
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] concurrency_violation() at ./condition.jl:8
 [3] assert_havelock at ./condition.jl:28 [inlined]
 [4] assert_havelock at ./REPL[22]:1 [inlined]
 [5] assert_havelock(::Base.GenericCondition{ReentrantLock}) at ./condition.jl:73
 [6] (::var"##21#22")() at ./threadingconstructs.jl:113

Also adds unit test that failed before this commit but now succeeds

---

(As I was experimenting with NHDaly/Select.jl#2, I noticed that this was missed for ReentrantLocks.)

[JeffBezanson]

Thanks, I believe this is a bugfix. I also think probably this method:

assert_havelock(l::AbstractLock) = assert_havelock(l, Threads.threadid())

should be removed since the current thread can't be generically assumed to be the lock holder. Then we can add a method for SpinLock that just checks islocked; we can't actually tell whether the current thread holds a SpinLock but that's better than nothing.

[NHDaly]

I agree. I was considering suggesting we remove the default-implementation, but wasn't confident in suggesting a larger refactoring.

+1 I'll make that change now. :) Thanks!

[NHDaly]

(Done)