Swift中使用C11标准的原子操作

最新推荐文章于 2024-06-17 09:51:39 发布
最新推荐文章于 2024-06-17 09:51:39 发布
阅读量3.9k 收藏
点赞数 2
分类专栏： Swift编程语言相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zenny_chen/article/details/52607814
版权

当前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源文件：

/** 所有原子类型所需遵循的原子类型协议 */

public protocol 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位带符号整数原子类型 */

public struct AtomicInt:AtomicType {

    

    privatevar mAtomicValue = AtomicIntSwift()

    

    publictypealias RawType = Int32

    

    publicinit() {

        AtomicSwiftInit(&mAtomicValue,0)

    }

    

    publicinit(value: Int32) {

        AtomicSwiftInit(&mAtomicValue, value)

    }

    

    publicmutating func load() ->Int32 {

        returnAtomicSwiftLoad(&mAtomicValue)

    }

    

    publicmutating func store(by value:Int32) {

        AtomicSwiftStore(&mAtomicValue, value)

    }

    

    publicmutating func exchange(with value:Int32) -> Int32 {

        returnAtomicSwiftExchange(&mAtomicValue, value)

    }

    

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

        returnAtomicSwiftCAS(&mAtomicValue, expected, desired)

    }

    

    publicmutating func fetch_add(operand:Int32) -> Int32 {

        returnAtomicSwiftFetchAdd(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_sub(operand:Int32) -> Int32 {

        returnAtomicSwiftFetchSub(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_or(operand:Int32) -> Int32 {

        returnAtomicSwiftFetchOr(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_xor(operand:Int32) -> Int32 {

        returnAtomicSwiftFetchXor(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_and(operand:Int32) -> Int32 {

        returnAtomicSwiftFetchAnd(&mAtomicValue, operand)

    }

}


/** 布尔原子类型 */

public struct AtomicBool:AtomicType {

    

    privatevar mAtomicValue = AtomicBoolSwift()

    

    publictypealias RawType = Bool

    

    publicinit() {

        AtomicSwiftInit(&mAtomicValue,false)

    }

    

    publicinit(value: Bool) {

        AtomicSwiftInit(&mAtomicValue, value)

    }

    

    publicmutating func load() ->Bool {

        returnAtomicSwiftLoad(&mAtomicValue)

    }

    

    publicmutating func store(by value:Bool) {

        AtomicSwiftStore(&mAtomicValue, value)

    }

    

    publicmutating func exchange(with value:Bool) -> Bool {

        returnAtomicSwiftExchange(&mAtomicValue, value)

    }

    

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

        returnAtomicSwiftCAS(&mAtomicValue, expected, desired)

    }

    

    publicmutating func fetch_add(operand:Bool) -> Bool {

        assertionFailure("Atomic Bool does not support fetch operation!")

        returnfalse

    }

    

    publicmutating func fetch_sub(operand:Bool) -> Bool {

        assertionFailure("Atomic Bool does not support fetch operation!")

        returnfalse

    }

    

    publicmutating func fetch_or(operand:Bool) -> Bool {

        assertionFailure("Atomic Bool does not support fetch operation!")

        returnfalse

    }

    

    publicmutating func fetch_xor(operand:Bool) -> Bool {

        assertionFailure("Atomic Bool does not support fetch operation!")

        returnfalse

    }

    

    publicmutating func fetch_and(operand:Bool) -> Bool {

        assertionFailure("Atomic Bool does not support fetch operation!")

        returnfalse

    }

}


/** 64位无符号整数原子类型 */

public struct AtomicULong:AtomicType {

    

    privatevar mAtomicValue = AtomicULongSwift()

    

    publictypealias RawType = UInt64

    

    publicinit() {

        AtomicSwiftInit(&mAtomicValue,0)

    }

    

    publicinit(value: UInt64) {

        AtomicSwiftInit(&mAtomicValue, value)

    }

    

    publicmutating func load() ->UInt64 {

        returnAtomicSwiftLoad(&mAtomicValue)

    }

    

    publicmutating func store(by value:UInt64) {

        AtomicSwiftStore(&mAtomicValue, value)

    }

    

    publicmutating func exchange(with value:UInt64) -> UInt64 {

        returnAtomicSwiftExchange(&mAtomicValue, value)

    }

    

    publicmutating func cas(expected:UnsafeMutablePointer<UInt64>, desired:UInt64) -> Bool {

        returnAtomicSwiftCAS(&mAtomicValue, expected, desired)

    }

    

    publicmutating func fetch_add(operand:UInt64) -> UInt64 {

        returnAtomicSwiftFetchAdd(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_sub(operand:UInt64) -> UInt64 {

        returnAtomicSwiftFetchSub(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_or(operand:UInt64) -> UInt64 {

        returnAtomicSwiftFetchOr(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_xor(operand:UInt64) -> UInt64 {

        returnAtomicSwiftFetchXor(&mAtomicValue, operand)

    }

    

    publicmutating func fetch_and(operand:UInt64) -> UInt64 {

        returnAtomicSwiftFetchAnd(&mAtomicValue, operand)

    }

}


然后我们可以对这些原子类型进行测试：

fileprivate func atomIntTest() {

    

    var atom =AtomicInt(value: 10)

    var value = atom.load()

    print("The initial atom value is:\(value)")

    atom.store(by: value +100)

    value = atom.load()

    print("Now, the atom value is:\(value)")

    

    var value2 = atom.exchange(with:-100)

    value = atom.load()

    print("Before exchange:\(value2), after exchange:\(value)")

    

    value = atom.load()

    value += 1 // 模拟被读取的值受外界破坏

    var bResult = atom.cas(expected: &value, desired:10)

    value = atom.load()

    print("cas result:\(bResult), value =\(value)")

    

    value = atom.load()

    bResult = atom.cas(expected: &value, desired:10)

    value = atom.load()

    print("cas result:\(bResult), new value:\(value)")

    

    value = atom.fetch_add(operand:5)

    value2 = atom.load()

    print("before add:\(value), after add:\(value2)")

    

    value = atom.fetch_sub(operand:5)

    value2 = atom.load()

    print("before sub:\(value), after sub:\(value2)")

}


fileprivate func atomBoolTest() {

    

    var atom =AtomicBool(value: true)

    var value = atom.load()

    print("The initial atom value is:\(value)")

    atom.store(by:false)

    value = atom.load()

    print("Now, the atom value is:\(value)")

    

    let value2 = atom.exchange(with:true)

    value = atom.load()

    print("Before exchange:\(value2), after exchange:\(value)")

    

    value = atom.load()

    value = !value // 模拟被读取的值受外界破坏

    var bResult = atom.cas(expected: &value, desired:false)

    value = atom.load()

    print("cas result:\(bResult), value =\(value)")

    

    value = atom.load()

    bResult = atom.cas(expected: &value, desired:false)

    value = atom.load()

    print("cas result:\(bResult), new value:\(value)")

    

    let _ = atom.fetch_add(operand:false)

}


fileprivate func atomULongTest() {

    

    var atom =AtomicULong(value: 10)

    var value = atom.load()

    print("The initial atom value is:\(value)")

    atom.store(by: value +100)

    value = atom.load()

    print("Now, the atom value is:\(value)")

    

    var value2 = atom.exchange(with:10000)

    value = atom.load()

    print("Before exchange:\(value2), after exchange:\(value)")

    

    value = atom.load()

    value += 1 // 模拟被读取的值受外界破坏

    var bResult = atom.cas(expected: &value, desired:10)

    value = atom.load()

    print("cas result:\(bResult), value =\(value)")

    

    value = atom.load()

    bResult = atom.cas(expected: &value, desired:10)

    value = atom.load()

    print("cas result:\(bResult), new value:\(value)")

    

    value = atom.fetch_add(operand:5)

    value2 = atom.load()

    print("before add:\(value), after add:\(value2)")

    

    value = atom.fetch_sub(operand:5)

    value2 = atom.load()

    print("before sub:\(value), after sub:\(value2)")

}


class ViewController: NSViewController {

    

    overridefunc viewDidLoad() {

        super.viewDidLoad()

                

        atomIntTest()

        atomULongTest()

        atomBoolTest()

    }

}


我们在执行最后一个atomBoolTest函数的时候会发生异常，由于原子布尔类型是不支持原子算术逻辑运算操作的，所以在实现中大家也能看到，我使用了assertionFailure函数来处理进入这些实现的方法中。

完整的工程代码可从此链接下载：http://download.csdn.net/detail/zenny_chen/9639566。


zenny_chen
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
探索 Swift Atomics：构建高效并发代码的新工具
gitblog_00055的博客
04-10 846
探索 Swift Atomics：构建高效并发代码的新工具 项目地址:https://gitcode.com/apple/swift-atomics 在现代软件开发中，多线程和并发编程已经成为常态，以充分利用多核处理器的潜力。swift-atomics 是 Apple 开源的一个项目，它为 Swift 编程语言提供了一组原子操作（Atomic Operations）API，旨在帮助开发者安全、高效...
Swift之深入解析内存安全
╰つ栺尖篴夢ゞ
04-20 1079
默认情况下，Swift 会阻止你代码里不安全的行为。例如，Swift 会保证变量在使用之前就完成初始化，在内存被回收之后就无法被访问，并且数组的索引会做越界检查。Swift 也保证同时访问同一块内存时不会冲突，通过约束代码里对于存储地址的写操作，去获取那一块内存的访问独占权。因为 Swift 自动管理内存，所以大部分时候你完全不需要考虑内存访问的事情。然而，理解潜在的冲突也是很重要的，可以避免你写出访问冲突的代码。而如果你的代码确实存在冲突，那在编译时或者运行时就会得到错误。
Swift的GCD详解
watertekhqx的博客
03-13 931
swift GCD
C11与C++11关于Atomic原子类型的异同
最新发布
fish的专栏
06-17 420
头文件C11 使用。C++11 使用。数据类型C11 使用atomic_int等_Atomic类型定义。C++11 使用模板类。初始化C11 推荐使用宏进行初始化，也可以直接赋值。C++11 通过构造函数直接初始化。操作函数C11 使用标准库函数，如。C++11 使用类成员函数，如storeload。编译参数C11 需要使用-std=c11。C++11 需要使用-std=c++11。
Swift线程安全变量实现
HelloMagina的博客
07-09 1436
为了保证线程安全操作，一般语言都提供了锁Lock来保证临界区安全。所以我们可以通过NSLock来实现对变量的读和写都加锁来实现线程安全。 class Sample { var intValue = 0 let lock:NSLock = NSLock func getValue()->Int { lock.lock() let value = intValue lock.unlock() return value } func setVal
[Linux C] 多线程使用原子操作API进行线程同步
qq_39667609的博客
05-20 629
多线程同步是一个非常常见的问题，本质是多个线程对共享资源的同时访问并不是原子的而导致的逻辑错误，因此需要使用相关的技术来实现多线程之间的协同工作。如果只是对某个全局变量进行操作的多线程简单场景，我们可以使用原子变量来进行线程同步。在C11中，提供了原子操作的接口，使得C语言程序员能够通过调用接口来使用原子操作。要使用原子操作，需要将对应的共享资源用原子类型来定义。原子变量的对程序的影响较小，适合对全局变量等临界区代码较少的简单操作的多线程场景。C11提供了丰富的原子操作API,用于实现原子操作。
c语言 原子 字符串,Atomic operations library（原子操作库）
weixin_29079743的博客
05-17 591
如果宏常量__STDC_NO_ATOMICS__(C11)由编译器定义，则不提供此处列出的标题，关键字_Atomic和所有名称。类型| Defined in header ||:----|| memory_order(C11)| 定义内存排序约束(枚举)|| atomic_flag(C11)| 无锁原子布尔标志(结构)|宏| Defined in header ||:----|| ATOMIC...
用于Swift的顺从C11标准的原子操作
09-25
各位只需要将CLib4Swift.h、CLib4Swift.c以及SwiftAtomic.swift三个文件放入到自己项目工程中即可，然后还需要将"CLib4Swift.h"头文件include到你的brdige...具体使用非常简单，直接看main.swift中的测试代码即可。
Swift中的指针操作及使用
03-01
这在一定程度上造成了在Swift中指针使用的困难，特别是对那些并不熟悉指针，也没有多少指针操作经验的开发者（包括我自己也是）来说，在Swift中使用指针确实是一个挑战。在这篇文章里，我希望能从最基本的使用开始，...
Swift中的指针操作和使用详细介绍
09-03
在Swift编程语言中，指针的操作和使用与传统的C/C++等语言有所不同，因为Apple希望在Swift中降低指针的使用频率，以提高代码的安全性和易读性。Swift中的指针被抽象为泛型类型，主要有`UnsafePointer<T>`和`...
在Swift中使用JavaScript的方法和技巧
02-26
在本文中，他介绍了在Swift中使用JavaScript的方法和技巧，对于iOS和Web工程师有着非常实用的价值。本文作者NateCook是一位独立的Web及移动应用开发者，是继Mattt大神之后NSHipster的主要维护者，也是非常知名活跃的...
swift-atomics:这个包为Swift实现了一个atomics库，为各种Swift类型提供了atomic操作，包括整数和指针值。 目的是使勇敢的开发人员能够直接在Swift中开始构建同步结构
03-17
迅捷原子:atom_symbol:︎︎ 这个包为Swift实现了一个atomics库，为各种Swift类型提供了atomic操作，包括整数和指针值。 目的是使勇敢的开发人员能够直接在Swift中开始构建同步结构。 原子操作不受通常的排他性规则约束。 只要所有这些访问都是通过原子操作完成的，就可以安全地从多个并发的执行线程中读取和更新相同的内存位置。 例如，这是一个简单的原子计数器： import Atomics import Dispatch let counter = ManagedAtomic < Int> ( 0 ) DispatchQueue. concurrentPerform ( iterations : 10 ) { _ in for _ in 0 ..< 1_000_000 { counter. wrappingIncrement ( ordering : . relaxed
这个包为Swift实现了一个原子库-Swift开发
05-27
这个包为Swift实现了一个atomics库，为各种Swift类型提供了atomic操作，包括整数和指针值。 目的是使勇敢的开发人员能够直接在Swift中开始构建同步结构。 Swift Atomics:atom_symbol:︎︎该软件包为Swift实现了一个原子库，为各种Swift类型提供了原子操作，包括整数和指针值。 目的是使勇敢的开发人员能够直接在Swift中开始构建同步结构。 原子操作不受通常的排他性规则约束。 可以从多个并发执行线程安全地读取和更新相同的内存位置，只要所有此类访问都是通过原子操作完成的
C语言与swift语言的初步学习
2301_79894300的博客
11-11 111
c程序中的注释以“/*”符号开始，以“*/”结束，可以使用“//”注释。
C语言的_Atomic类型限定符(C11)
Galaxy_Robot的博客
06-28 6700
C语言的_Atomic类型限定符(C11) 并发程序设计把程序执行分成可以同时执行的多个线程。这程序设计带来了新的挑战，包括如何管理访问相同数据的不同线程。C11通过包含可选的头文件stdatomic.h和threads.h，提供了一些可选的（不是必须实现的）管理方法。值得注意的是，要通过各种红函数类访问原子类型。当一个线程对一个原子类型的对象执行原子操作时，其他线程不能访问该对象。 所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位
Swift如何保证线程安全
Hello World
02-12 1478
Swift可以通过以下几种方式来保证线程安全 使用互斥锁（Mutex）：使用互斥锁可以防止多个线程同时访问共享数据，保证线程安全。 使用OSAtomic操作：OSAtomic操作可以在多线程环境中安全地执行原子操作。 使用DispatchQueue：DispatchQueue可以使用GCD技术实现线程安全。您可以使用DispatchQueue.sync和DispatchQueue.async方法在指定队列中执行任务，以保证线程安全。 使用NSLock和NSCondition：NSLock和N
关于C11标准中原子操作，看这篇就够了！
热门推荐
qq_33777090的博客
06-24 1万+
关于C11标准中原子操作，看这篇就够了！
C11 标准库中的原子操作
麦子点点的博客
11-07 2620
C11 标准库中的原子操作atomic 只是对于嵌入式编程 c语言中避免不了原子操作atomic，防止多线程中数据竞争。 C11 atomic variables and the kernel Atomic primitives in the kernel Atomic usage patterns in the kernel Semantics and Behavior of Atomic and Bitmask Operations 参考链接:C11标准库中的atomic原子操作 stdatomi
使用C11的原子操作来实现线性单链表操作
zenny_chen的专栏
11-14 3429
随着多核处理器的逐步普及，各种对于多核多线程并行计算的算法也得到了深入研究。而在高性能并行计算方面，许多处理器引入了原子操作以便同步多核多线程可共享的资源。在多核多线程环境中，要对某一个共享资源进行同步必须用到原子操作，即便是像mutex、semaphore等传统的锁机制也是需要通过原子操作来实现。为了加速对共享资源的访问操作，许多无锁的算法（lock-free或non-blocking）被设计出来，通过消除锁来避免锁带来的系统开销。
Swift 编程语言中文教程
* 字符串操作：Swift 中的字符串可以进行多种操作，如字符串连接、字符串比较和字符串插值等。 **8. Swift 语言集合类型** * 数组定义：在 Swift 中，数组是使用 [] 定义的，数组可以存储多种类型的数据。 * 字典...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值