RFC: Add Lockable{T, L<:AbstractLock} struct

[DilumAluthge]

I find myself using this pattern a lot, so I'm curious if it would be worth adding to Base.

The basic idea is that there is some object that should only ever be accessed when its corresponding lock is held, so it makes sense to package the object and its lock together into a single object.

Here is the code that this PR adds to base/lock.jl:

struct Lockable{T, L<:AbstractLock}
    value::T
    lock::L
end

Lockable(value) = Lockable(value, ReentrantLock())

function lock(f, l::Lockable)
    lock(l.lock) do
        f(l.value)
    end
end

Example usage:

julia> function foo(x::Lockable)
           lock(x) do value
               push!(value, value[end-1] + value[end])
           end
       end
foo (generic function with 1 method)

julia> bar = Lockable([1, 1], ReentrantLock())

julia> foo(bar)
3-element Array{Int64,1}:
 1
 1
 2

julia> foo(bar)
4-element Array{Int64,1}:
 1
 1
 2
 3

julia> foo(bar)
5-element Array{Int64,1}:
 1
 1
 2
 3
 5

[TsurHerman]

Maybe change the name to Lockable?

[DilumAluthge]

Maybe change the name to Lockable?

Done!

[DilumAluthge]

I have added docstrings, compat annotations, tests, and a NEWS.md entry. I've also applied all of the suggestions from code review.

[DilumAluthge]

Bump.

What did triage think of this PR?

[DilumAluthge]

The more I think about this, the more I think this doesn't need to be in Base.

I think it is a useful design pattern, but it is easy to put this in a package instead of Base or a stdlib.

[quinnj]

I've come across the need several times lately for something like this; does it live in a package somewhere?

[DilumAluthge]

Not that I'm aware of. Want to take the code and submit it somewhere?

If there is some kind of "threading utilities" package, it could go there.

[quinnj]

I mean, for my use case, I realized I only needed:

struct Lockable{T}
    x::T
    lock::ReentrantLock
end

Lockable(x::T) where {T} = Lockable{T}(x, ReentrantLock())

Base.lock(x::Lockable) = lock(x.lock)
Base.unlock(x::Lockable) = unlock(x.lock)

So I just put it in my package directly. But yeah, sounds like a good fit for a thread utils package.

[quinnj]

Well, I was planning on registering this new package soon anyway, so now it includes Lockable.

[quinnj]

https://github.com/JuliaServices/WorkerUtilities.jl