Swift中使用C11標準的原子操作

當前Swift 3.0中還沒有正式引入基本型別相對應的原子型別。而在macOS以及iOS下，我們可以用系統自帶的OSAtomic API進行原子操作處理。但這組API只能在Apple自家平臺上使用，我們無法在Linux/FreeBSD中使用，所以我這邊封裝了順應C11標準的一組原子型別與原子操作提供給Swift程式語言。

當前在Swift中，如果我們在C語言標頭檔案聲明瞭一個比如atomic_int型別的全域性物件，那麼該物件在Swift中是無法被匯入的，因為atomic_int型別在Swift中無法被轉換為它所能識別的相應型別。所以，我這邊的思路是將C11標準中支援的原子型別通過結構體進行封裝。我在下列程式碼中封裝了3種原子型別，分別為：atomic_int、atomic_bool以及atomic_uint_fast64_t，分別表示int原子型別、布林原子型別以及無符號64位整數原子型別。我這邊建立的專案名為SwiftTest，所以Swift所需要的橋接標頭檔案名為SwiftTest-Bridging-Header.h

。下面先給出此標頭檔案的完整原始碼：

#include <stdint.h>
#include <stdbool.h>
#include <stdatomic.h>

/** 用於Swift的AtomicInt原子型別 */
struct AtomicIntSwift {
    volatile atomic_int atom;
};

/**
 * 對原子物件進行初始化
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定要給原子物件初始化的值
*/
extern void __attribute__((overloadable)) AtomicSwiftInit(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 對原子物件進行載入操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @return 指定原子物件所儲存的值
*/
extern int __attribute__((overloadable)) AtomicSwiftLoad(struct AtomicIntSwift* __nonnull pAtom);

/** 
 * 對原子物件進行儲存操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 要儲存到指定原子物件中的值
*/
extern void __attribute__((overloadable)) AtomicSwiftStore(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 將原子物件中存放的值與所指定的基本型別的值進行交換。
 *
 * 也就是說，將基本型別的值存放到原子物件中去，並將原子物件的原始值返回
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern int __attribute__((overloadable)) AtomicSwiftExchange(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 原子比較與交換
 *
 * 將原子物件中的值與expected的值進行比較，如果相同則將desired的值寫入到原子物件中，並返回true；
 * 否則，將當前原子物件中的值寫入到expected中去，並返回false
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param expected 存放與原子物件進行比較的值的指標。
 *                 該指標一般指向用原子載入操作所得到值的變數，並且不能為空。
 * @param desired 要存入到原子物件中的值
 * @return 如果expected中的值與原子物件中所存放的值相同，則返回true，否則返回false
*/
extern bool __attribute__((overloadable)) AtomicSwiftCAS(struct AtomicIntSwift* __nonnull pAtom, int* __nonnull expected, int desired);

/**
 * 原子加法操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern int __attribute__((overloadable)) AtomicSwiftFetchAdd(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 原子減法操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern int __attribute__((overloadable)) AtomicSwiftFetchSub(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 原子按位或操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern int __attribute__((overloadable)) AtomicSwiftFetchOr(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 原子按位異或操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern int __attribute__((overloadable)) AtomicSwiftFetchXor(struct AtomicIntSwift* __nonnull pAtom, int value);

/**
 * 原子按位與操作
 * @param pAtom 指向Swift中AtomicInt型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern int __attribute__((overloadable)) AtomicSwiftFetchAnd(struct AtomicIntSwift* __nonnull pAtom, int value);


/** 用於Swift的AtomicBool原子型別 */
struct AtomicBoolSwift {
    volatile atomic_bool atom;
};

/**
 * 對原子物件進行初始化
 * @param pAtom 指向Swift中AtomicBool型別的原子物件，並且不允許為空
 * @param value 指定要給原子物件初始化的值
*/
extern void __attribute__((overloadable)) AtomicSwiftInit(struct AtomicBoolSwift* __nonnull pAtom, bool value);

/**
 * 對原子物件進行載入操作
 * @param pAtom 指向Swift中AtomicBool型別的原子物件，並且不允許為空
 * @return 指定原子物件所儲存的值
*/
extern bool __attribute__((overloadable)) AtomicSwiftLoad(struct AtomicBoolSwift* __nonnull pAtom);

/**
 * 對原子物件進行儲存操作
 * @param pAtom 指向Swift中AtomicBool型別的原子物件，並且不允許為空
 * @param value 要儲存到指定原子物件中的值
 */
extern void __attribute__((overloadable)) AtomicSwiftStore(struct AtomicBoolSwift* __nonnull pAtom, bool value);

/**
 * 將原子物件中存放的值與所指定的基本型別的值進行交換。
 *
 * 也就是說，將基本型別的值存放到原子物件中去，並將原子物件的原始值返回
 * @param pAtom 指向Swift中AtomicBool型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern bool __attribute__((overloadable)) AtomicSwiftExchange(struct AtomicBoolSwift* __nonnull pAtom, bool value);

/**
 * 原子比較與交換
 *
 * 將原子物件中的值與expected的值進行比較，如果相同則將desired的值寫入到原子物件中，並返回true；
 * 否則，將當前原子物件中的值寫入到expected中去，並返回false
 * @param pAtom 指向Swift中AtomicBool型別的原子物件，並且不允許為空
 * @param expected 存放與原子物件進行比較的值的指標。
 *                 該指標一般指向用原子載入操作所得到值的變數，並且不能為空。
 * @param desired 要存入到原子物件中的值
 * @return 如果expected中的值與原子物件中所存放的值相同，則返回true，否則返回false
*/
extern bool __attribute__((overloadable)) AtomicSwiftCAS(struct AtomicBoolSwift* __nonnull pAtom, bool* __nonnull expected, bool desired);


/** 用於Swift的AtomicULong原子型別 */
struct AtomicULongSwift {
    volatile atomic_uint_fast64_t atom;
};

/**
 * 對原子物件進行初始化
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定要給原子物件初始化的值
*/
extern void __attribute__((overloadable)) AtomicSwiftInit(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 對原子物件進行載入操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @return 指定原子物件所儲存的值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftLoad(struct AtomicULongSwift* __nonnull pAtom);

/**
 * 對原子物件進行儲存操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 要儲存到指定原子物件中的值
*/
extern void __attribute__((overloadable)) AtomicSwiftStore(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 將原子物件中存放的值與所指定的基本型別的值進行交換。
 *
 * 也就是說，將基本型別的值存放到原子物件中去，並將原子物件的原始值返回
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftExchange(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 原子比較與交換
 *
 * 將原子物件中的值與expected的值進行比較，如果相同則將desired的值寫入到原子物件中，並返回true；
 * 否則，將當前原子物件中的值寫入到expected中去，並返回false
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param expected 存放與原子物件進行比較的值的指標。
 *                 該指標一般指向用原子載入操作所得到值的變數，並且不能為空。
 * @param desired 要存入到原子物件中的值
 * @return 如果expected中的值與原子物件中所存放的值相同，則返回true，否則返回false
*/
extern bool __attribute__((overloadable)) AtomicSwiftCAS(struct AtomicULongSwift* __nonnull pAtom, uint64_t* __nonnull expected, uint64_t desired);

/**
 * 原子加法操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftFetchAdd(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 原子減法操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftFetchSub(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 原子按位或操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftFetchOr(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 原子按位異或操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftFetchXor(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

/**
 * 原子按位與操作
 * @param pAtom 指向Swift中AtomicULong型別的原子物件，並且不允許為空
 * @param value 指定的基本型別的值
 * @return 原子物件的原始值
*/
extern uint64_t __attribute__((overloadable)) AtomicSwiftFetchAnd(struct AtomicULongSwift* __nonnull pAtom, uint64_t value);

上述程式碼列出了我們後面在Swift中所需要的C語言底層對C11標準原子操作的封裝實現。下面我們可以在C原始檔（.c檔案）中實現這些宣告的函式介面。

#include <stdio.h>
#include "SwiftTest-Bridging-Header.h"

#pragma mark - atomic int

void __attribute__((overloadable)) AtomicSwiftInit(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return;
    
    atomic_init(&pAtom->atom, value);
}

int __attribute__((overloadable)) AtomicSwiftLoad(struct AtomicIntSwift* __nonnull pAtom)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_load(&pAtom->atom);
}

void __attribute__((overloadable)) AtomicSwiftStore(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return;
    
    atomic_store(&pAtom->atom, value);
}

int __attribute__((overloadable)) AtomicSwiftExchange(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_exchange(&pAtom->atom, value);
}

bool __attribute__((overloadable)) AtomicSwiftCAS(struct AtomicIntSwift* __nonnull pAtom, int* __nonnull expected, int desired)
{
    if(pAtom == NULL || expected == NULL)
        return false;
    
    return atomic_compare_exchange_weak(&pAtom->atom, expected, desired);
}

int __attribute__((overloadable)) AtomicSwiftFetchAdd(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_add(&pAtom->atom, value);
}

int __attribute__((overloadable)) AtomicSwiftFetchSub(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_sub(&pAtom->atom, value);
}

int __attribute__((overloadable)) AtomicSwiftFetchOr(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_or(&pAtom->atom, value);
}

int __attribute__((overloadable)) AtomicSwiftFetchXor(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_xor(&pAtom->atom, value);
}

int __attribute__((overloadable)) AtomicSwiftFetchAnd(struct AtomicIntSwift* __nonnull pAtom, int value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_and(&pAtom->atom, value);
}


#pragma mark - atomic bool

void __attribute__((overloadable)) AtomicSwiftInit(struct AtomicBoolSwift* __nonnull pAtom, bool value)
{
    if(pAtom == NULL)
        return;
    
    atomic_init(&pAtom->atom, value);
}

bool __attribute__((overloadable)) AtomicSwiftLoad(struct AtomicBoolSwift* __nonnull pAtom)
{
    if(pAtom == NULL)
        return false;
    
    return atomic_load(&pAtom->atom);
}

void __attribute__((overloadable)) AtomicSwiftStore(struct AtomicBoolSwift* __nonnull pAtom, bool value)
{
    if(pAtom == NULL)
        return;
    
    atomic_store(&pAtom->atom, value);
}

bool __attribute__((overloadable)) AtomicSwiftExchange(struct AtomicBoolSwift* __nonnull pAtom, bool value)
{
    if(pAtom == NULL)
        return false;
    
    return atomic_exchange(&pAtom->atom, value);
}

bool __attribute__((overloadable)) AtomicSwiftCAS(struct AtomicBoolSwift* __nonnull pAtom, bool* __nonnull expected, bool desired)
{
    if(pAtom == NULL || expected == NULL)
        return false;
    
    return atomic_compare_exchange_weak(&pAtom->atom, expected, desired);
}


#pragma mark - atomic uint64_t

void __attribute__((overloadable)) AtomicSwiftInit(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return;
    
    atomic_init(&pAtom->atom, value);
}

uint64_t __attribute__((overloadable)) AtomicSwiftLoad(struct AtomicULongSwift* __nonnull pAtom)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_load(&pAtom->atom);
}

void __attribute__((overloadable)) AtomicSwiftStore(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return;
    
    atomic_store(&pAtom->atom, value);
}

uint64_t __attribute__((overloadable)) AtomicSwiftExchange(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_exchange(&pAtom->atom, value);
}

bool __attribute__((overloadable)) AtomicSwiftCAS(struct AtomicULongSwift* __nonnull pAtom, uint64_t* __nonnull expected, uint64_t desired)
{
    if(pAtom == NULL || expected == NULL)
        return false;
    
    return atomic_compare_exchange_weak(&pAtom->atom, expected, desired);
}

uint64_t __attribute__((overloadable)) AtomicSwiftFetchAdd(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_add(&pAtom->atom, value);
}

uint64_t __attribute__((overloadable)) AtomicSwiftFetchSub(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_sub(&pAtom->atom, value);
}

uint64_t __attribute__((overloadable)) AtomicSwiftFetchOr(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_or(&pAtom->atom, value);
}

uint64_t __attribute__((overloadable)) AtomicSwiftFetchXor(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_xor(&pAtom->atom, value);
}

uint64_t __attribute__((overloadable)) AtomicSwiftFetchAnd(struct AtomicULongSwift* __nonnull pAtom, uint64_t value)
{
    if(pAtom == NULL)
        return 0;
    
    return atomic_fetch_and(&pAtom->atom, value);
}

我們看到，這個封裝實現其實不是很複雜。為了能讓原子操作在Swift中更OO化，我在Swift中將每個原子型別抽象為一個結構體。下面我們來看Swift原始檔：

/** 所有原子型別所需遵循的原子型別協議 */

publicprotocol AtomicType {

/** 當前原子型別所對應的基本型別 */

associatedtype RawType

/** 初始化器，對當前原子物件初始化為0值。它不具有原子性 */

init()

/**

初始化器，對當前原子物件初始化為形參指定的值。它不具有原子性

- parameters:

- value: 為當前原子物件初始化的初始值

init(value: RawType)

/**

載入當前原子物件的值，並返回。

- returns:當前原子物件對應的基本型別的值

mutatingfunc load() -> RawType

/**

將一個指定的基本型別值存放到當前原子物件中

- parameters:

- value: 指定要存放的基本型別的值

mutatingfunc store(by value: RawType)

/**

將指定的基本型別的值存入當前原子物件中，並返回存入之前的原子物件的原始值

- parameters:

- value: 指定的基本型別的值

- returns:在將指定值存入之前的原子物件的原始值

mutatingfunc exchange(with value: RawType) -> RawType

/**

原子比較與交換。

當前原子物件的值先與expected的值進行比較，如果相同則將desired的值存入當前原子物件，並返回true；

否則將當前原子物件的值存入expected，然後返回false。

- parameters:

- expected: 指向基本型別物件的指標。

此基本型別物件在呼叫該函式前一般會用load方法將當前原子物件的值載入進去。

- desired: 最終所要寫入的值

- returns:如果當前原子物件的值與expected中的值相同，那麼返回true，否則返回false

mutatingfunc cas(expected: UnsafeMutablePointer<RawType>, desired: RawType) ->Bool

/**

原子加法操作

- parameters:

- operand: 加法運算元

- returns:加法操作之前原子物件的原始值

mutatingfunc fetch_add(operand: RawType) -> RawType

/**

原子減法操作

- parameters:

- operand: 減法運算元

- returns:減法操作之前原子物件的原始值

mutatingfunc fetch_sub(operand: RawType) -> RawType

/**

原子按位或操作

- parameters:

- operand: 按位或運算元

- returns:按位或操作之前原子物件的原始值

mutatingfunc fetch_or(operand: RawType) -> RawType

/**

原子按位異或操作

- parameters:

- operand: 按位異或運算元

- returns:按位異或操作之前原子物件的原始值

mutatingfunc fetch_xor(operand: RawType) -> RawType

/**

原子按位與操作

- parameters:

- operand: 按位與運算元

- returns:按位與操作之前原子物件的原始值

mutatingfunc fetch_and(operand: RawType) -> RawType

}

/** 32位帶符號整數原子型別 */

publicstruct AtomicInt:AtomicType {

privatevar mAtomicValue = AtomicIntSwift()

publictypealias RawType = Int32

publicinit() {

AtomicSwiftInit(&mAtomicValue,0)

}

publicinit(value: Int32) {

AtomicSwiftInit(&mAtomicValue, value)

}

publicmutatingfunc load() ->Int32 {

returnAtomicSwiftLoad(&mAtomicValue)

}

publicmutatingfunc store(by value:Int32) {

AtomicSwiftStore(&mAtomicValue, value)

}

publicmutatingfunc exchange(with value:Int32) -> Int32 {

returnAtomicSwiftExchange(&mAtomicValue, value)

}

publicmutatingfunc cas(expected:UnsafeMutablePointer<Int32>, desired:Int32) -> Bool {

returnAtomicSwiftCAS(&mAtomicValue, expected, desired)

}

publicmutatingfunc fetch_add(operand:Int32) -> Int32 {

returnAtomicSwiftFetchAdd(&mAtomicValue, operand)

}

publicmutatingfunc fetch_sub(operand:Int32) -> Int32 {

returnAtomicSwiftFetchSub(&mAtomicValue, operand)

}

publicmutatingfunc fetch_or(operand:Int32) -> Int32 {

returnAtomicSwiftFetchOr(&mAtomicValue, operand)

}

publicmutatingfunc fetch_xor(operand:Int32) -> Int32 {

returnAtomicSwiftFetchXor(&mAtomicValue, operand)

}

publicmutatingfunc fetch_and(operand:Int32) -> Int32 {

returnAtomicSwiftFetchAnd(&mAtomicValue, operand)

}

/** 布林原子型別 */

publicstruct AtomicBool:AtomicType {

privatevar mAtomicValue = AtomicBoolSwift()

publictypealias RawType = Bool

publicinit() {

AtomicSwiftInit(&mAtomicValue,false)

}

publicinit(value: Bool) {

AtomicSwiftInit(&mAtomicValue, value)

}

publicmutatingfunc load() ->Bool {

returnAtomicSwiftLoad(&mAtomicValue)

}

publicmutatingfunc store(by value:Bool) {

AtomicSwiftStore(&mAtomicValue, value)

}

publicmutatingfunc exchange(with value:Bool) -> Bool {

returnAtomicSwiftExchange(&mAtomicValue, value)

}

publicmutatingfunc cas(expected:UnsafeMutablePointer<Bool>, desired:Bool) -> Bool {

returnAtomicSwiftCAS(&mAtomicValue, expected, desired)

}

publicmutatingfunc fetch_add(operand:Bool) -> Bool {