concurrency - 如何使用 Swift 中的 OSAtomicCompareAndSwapPtrBarrier？

Question

这个问题我已经在官方Apple developer forums问过了，可惜没有得到答案。我目前正在尝试在 Swift 中构建一些简单的并发数据结构，但找不到调用 OSAtomicCompareAndSwapPtrBarrier 的方法。来自 Swift 代码。签名是

OSAtomicCompareAndSwapPtrBarrier(
  __oldValue: UnsafePointer<()>,
  __newValue: UnsafePointer<()>,
  __theValue: UnsafePointer<UnsafePointer<()>>)

在 C 中是

OSAtomicCompareAndSwapPtrBarrier(
  void *__oldValue,
  void *__newValue,
  void * volatile *__theValue)

我找不到创建 UnsafePointer<UnsafePointer<()>> 的方法.只是一个简短的代码示例:

class Stack<A> {
  var __head: Node<A>

  init() {
    __head = Node()
  }

  func push(elem: A) {
    var newNode = Node<A>()
    newNode.elem = elem
    var currentHead: Node<A>
    do {
      currentHead = __head
      newNode.next = currentHead
    } while(!OSAtomicCompareAndSwapPtrBarrier(&currentHead, &newNode, &__head))
  }
}

class Node<A> {
  var elem: A?
  var next: Node<A>?
}

使用 &__head显然是行不通的，因为它只会创建一个 UnsafePointer<()> .那么我怎样才能创建 UnsafePointer<UnsafePointer<()>>在这里？

编辑:

在 C 中，我可以按如下方式使用它(我通常不使用 C，所以这段代码可能错得离谱):

#include <stdio.h>
#include <stdlib.h>
#include <libkern/OSAtomic.h>

typedef struct {
  int bar;
} foo;

int main(int argc, const char * argv[]) {
  // insert code here...
  foo * volatile f = malloc(sizeof(foo));
  foo *n = malloc(sizeof(foo));

  f->bar = 1;
  foo *old = f;
  n->bar = 3;

  OSAtomicCompareAndSwapPtrBarrier(old, n, &f);

  free(old);
  printf("%d\n", f->bar);
  free(f);

  return 0;
}

Answer 1

这是一个如何在 Swift 中使用 OSAtomicCompareAndSwapPtrBarrier 或 OSAtomicCompareAndSwapPtr 的例子:

public final class AtomicReference<T : AnyObject> {
    private var _value : T
    public var value : T {
        get {
            OSMemoryBarrier()
            return _value
        }
        set {
            OSMemoryBarrier()
            _value = newValue
        }
    }

    private let pointer : UnsafeMutablePointer<UnsafeMutablePointer<Void>> = UnsafeMutablePointer.alloc(1)
    public init(_ value : T) {
        self._value = value
        pointer.memory = UnsafeMutablePointer<Void>(Unmanaged.passUnretained(value).toOpaque())
    }
    deinit {
        pointer.destroy()
    }

    public func compareAndSwap(#oldValue : T, newValue: T) -> Bool {
        let ov = Unmanaged.passUnretained(oldValue)
        let nv = Unmanaged.passUnretained(newValue)

        if OSAtomicCompareAndSwapPtrBarrier(UnsafeMutablePointer<Void>(ov.toOpaque()), UnsafeMutablePointer<Void>(nv.toOpaque()), pointer) {
            _value = newValue
            return true
        } else {
            return false
        }
    }
}

此代码是一个类似于 Java 中的 AtomicReference 的类。它使您能够在某些情况下使用原子操作来避免线程锁定。原子操作通常在高并发的情况下提供更高的性能。

compareAndSwap 函数只有在前一个值与oldValue 相同时才会更改该值。例如:

class LockArray {
    var value = NSArray()
    let lock = NSLock()
    func addItem(item : Int) {
        lock.lock()
        value = value.arrayByAddingObject(item)
        lock.unlock()
    }
}

class AtomicArray {
    let reference = AtomicRefence<NSArray>([])
    func addItem(item : Int) {
        while true {
            let oldValue = reference.value
            let newValue = oldValue.arrayByAddingObject(item)
            if reference.compareAndSwap(oldValue: oldValue, newValue: newValue) {
                break
            }
        }
    }
}

这两个类都是线程安全的并且做同样的事情。但是，第二个在高并发情况下会更好。