Swift百万线程攻破单例（Singleton)模式

1、不安全的单例实现

在上一篇文章咱们给出了单例的设计模式，直接给出了线程安全的实现方法。单例的实现有多种方法，以下面：

class SwiftSingleton {
    class var shared: SwiftSingleton {
    if !Inner.instance {
        Inner.instance = SwiftSingleton()
        }
        return Inner.instance!
    }
    
    struct Inner {
        static var instance: SwiftSingleton?
    }
}

这段代码的实现，在shared中进行条件判断，若是Inner.instance.为空就生成一个实例，这段代码很简单看出当线程同时访问SwiftSingleton.shared方法时，会有以下问题出现，线程A判断Inner.instance为空，进入if语句后当即切换到线程B执行，线程B也进行判断，因为线程A只是进入了if语句，这行代码

Inner.instance = SwiftSingleton()

并无执行，这时Inner.instance仍是为空，纯种B也进行了if语句，这种状况下就会建立多个实例，没有保证明例的惟一性。上面的理论分析基本上任何一篇文章都会讲的，也不能理解，关键问题，如何测试上面的理论是否正确呢？

2、线程抢占原理

其实要实现上面的例子不是很难，建立N个线程，让他同时访问SwiftSingleton.shared的方法，而后将所返回值保存最后比较引用。原理很正确，可是建立线程的过程也是极为耗时的，如今的电脑执行速度又很是快，模拟具备不稳定性。如何才能最大的程序测试上面的安全性呢？这里咱们能够考虑一个现实的问题，假设找1000人经过一段100米的赛道，咱们想要更多的人同时去冲刺终点，越多越好。若是你找一我的，告诉他去跑100米，而后再找一下，这种确定同时到达终点的概率很底。怎么办才能让更多的人在同一时刻到达终点呢？问题很简单，让这1000人有一个同一块儿跑点，让他们都准备好了，随着一声令下，一块儿奔跑。回到技术问题，咱们想要更多的线程访问SwiftSingleton.shared方法，只要先准备好全部的线程，而后发一个信号，让他们同时去访问这个方法就能够了。

实现代码以下：

class SwiftSingletonTest: XCTestCase {
    let condition = NSCondition()
    let mainCondition = NSCondition()
    let singleton: NSMutableArray = NSMutableArray()
    let threadNumbers = 1000
    var count = 0
    
    
    func testSingletonThreadSafe() {
        
        for index in 0...threadNumbers {
            NSThread.detachNewThreadSelector("startNewThread", toTarget: self, withObject: nil)
        }
        condition.broadcast()
        mainCondition.lock()
        mainCondition.wait()
        mainCondition.unlock()
        checkOnlyOne()
    }
    
    func startNewThread() {
        condition.lock()
        condition.wait()
        condition.unlock()
        let temp = SwiftSingleton.shared
        count++
        singleton.addObject(temp)
        if count >= threadNumbers {
            mainCondition.signal()
        }
    }
    
    func checkOnlyOne () {
        let one = singleton[0] as SwiftSingleton
        for temp : AnyObject  in singleton {
            let newTemp = temp as SwiftSingleton
            if(newTemp !== one) {
                XCTFail("singleton error!");
                break;
            }
        }
    }

}

这段代码主要使用了NSCondition进行同步，其中NSCondition分为两组，condition主要负责除主线程外的线程，在for语句中会建立并启动N（threadNumbers）个线程，每一个线程启动后都会去执行startNewThread方法，执行到语句

condition.wait()

会挂起当前线程，当全部线程都建立并启动完时，主线程会执行

condition.broadcast()

来通知挂起的N个线程继承执行，此时主线程调了

mainCondition.wait()

主线和进入持起状态，此处将主线程挂起是为了在全部线程执行完，依次检查取得引用的惟一性。

if count >= threadNumbers {
            mainCondition.signal()
}

当全部线程执行完时，通知主线程开始检查引用 ，执行结果以下：

从上面执行结果能够看出，这种单例并不能保证惟一性。上面用到了NSMutableArray类，网上说是线程不安全的，这里用的Swift语言，这么多线程一块儿操做暂没有发现异常......

3、其它实现测试结果

一、最简单实现

class SwiftSingleton {
    class var shared: SwiftSingleton {
            return Inner.instance
    }

    struct Inner {
        static let instance: SwiftSingleton = SwiftSingleton()
    }
}

解释：上述表明也实现了延迟加载技术

static let instance: SwiftSingleton = SwiftSingleton()

首次访问Inner.instance时才会建立SwiftSingleton,此处的延迟加载由Swift语言原生提供

测试结果：经过

二、使用GCD技术实现的单例模式

class SwiftSingleton {
    class var shared: SwiftSingleton {
        dispatch_once(&Inner.token) {
            Inner.instance = SwiftSingleton()
        }
        return Inner.instance!
    }
    struct Inner {
        static var instance: SwiftSingleton?
        static var token: dispatch_once_t = 0
    }
    
}

测试结果：经过

4、测试说明

一、Mac OS线程总量有限制，你能够建立线程，可是最大线程启动数为2048（个人电脑是这样，不清楚是否跟硬件有关）

二、若是遇到测试无响应时，能够尝试重启电脑