Atomic way to operate on integers in Swift. Inspired by Java's AtomicInteger

AtomicInteger.swift

/// This is free and unencumbered software released into the public domain.
/// 
/// Anyone is free to copy, modify, publish, use, compile, sell, or
/// distribute this software, either in source code form or as a compiled
/// binary, for any purpose, commercial or non-commercial, and by any
/// means.
/// 
/// In jurisdictions that recognize copyright laws, the author or authors
/// of this software dedicate any and all copyright interest in the
/// software to the public domain. We make this dedication for the benefit
/// of the public at large and to the detriment of our heirs and
/// successors. We intend this dedication to be an overt act of
/// relinquishment in perpetuity of all present and future rights to this
/// software under copyright law.

/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
/// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
/// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
/// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
/// OTHER DEALINGS IN THE SOFTWARE.
/// 
/// For more information, please refer to <http://unlicense.org/>

import Foundation

public final class AtomicInteger {
    
    private let lock = DispatchSemaphore(value: 1)
    private var _value: Int
    
    public init(value initialValue: Int = 0) {
        _value = initialValue
    }
    
    public var value: Int {
        get {
            lock.wait()
            defer { lock.signal() }
            return _value
        }
        set {
            lock.wait()
            defer { lock.signal() }
            _value = newValue
        }
    }
    
    public func decrementAndGet() -> Int {
        lock.wait()
        defer { lock.signal() }
        _value -= 1
        return _value
    }
    
    public func incrementAndGet() -> Int {
        lock.wait()
        defer { lock.signal() }
        _value += 1
        return _value
    }
}

In lines 17, 22, 30, 31, 38 and 39 should be _value instead of value, right?

@diogot You're correct. Thank you for attentiveness. I'll adjust the code right now.

Do you know if DispatchQueue.sync() would be faster than a DispatchSemaphore?

I tried to look for an answer, but I found only https://github.com/nyisztor/LockTest, which compares multiple synchronisation mechanisms but not this one.

@nestserau would you be willing to add a line to this gist stating what license it can be used under? This is perfect and I'd love to use it in our application, but the lawyers are uncomfortable since there isn't a license explicitly listed.

@algrs Just use it as your own, it's nonsense to license this piece of code.

@nestserau Thank you!

It looks like line 56 needs to be _value as well, otherwise, it will deadlock.

@enozero You're correct. I'll fix it now. Thank you.

Thanks! Great work!

Thank you for the great work and for sharing this and especially without the nonsense about licensing. Big thumbs up !

This class really should be provided by Swift out of the box. What were/are they thinking ?