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

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

 
 
  
  classSwiftSingleton{
  
  classvarshared:SwiftSingleton{
  
  if!Inner.instance{
  
  Inner.instance=SwiftSingleton()
  
  }
  
  returnInner.instance!
  
  }
  
  
  
  structInner{
  
  staticvarinstance:SwiftSingleton?
  
  }
  
  }

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

  
  Inner.instance=SwiftSingleton()

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

二、线程抢占原理

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

实现代码如下：

classSwiftSingletonTest:XCTestCase{
  
  letcondition=NSCondition()
  
  letmainCondition=NSCondition()
  
  letsingleton:NSMutableArray=NSMutableArray()
  
  letthreadNumbers=1000
  
  varcount=0
  
  
  
  
  
  functestSingletonThreadSafe(){
  
  
  
  forindexin0...threadNumbers{
  
  NSThread.detachNewThreadSelector("startNewThread",toTarget:self,withObject:nil)
  
  }
  
  condition.broadcast()
  
  mainCondition.lock()
  
  mainCondition.wait()
  
  mainCondition.unlock()
  
  checkOnlyOne()
  
  }
  
  
  
  funcstartNewThread(){
  
  condition.lock()
  
  condition.wait()
  
  condition.unlock()
  
  lettemp=SwiftSingleton.shared
  
  count++
  
  singleton.addObject(temp)
  
  ifcount>=threadNumbers{
  
  mainCondition.signal()
  
  }
  
  }
  
  
  
  funccheckOnlyOne(){
  
  letone=singleton[0]asSwiftSingleton
  
  fortemp:AnyObjectinsingleton{
  
  letnewTemp=tempasSwiftSingleton
  
  if(newTemp!==one){
  
  XCTFail("singletonerror!");
  
  break;
  
  }
  
  }
  
  }
  
  
  
  }

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

  
  condition.wait()

会挂起当前线程，当所有线程都创建并启动完时，主线程会执行

  
  condition.broadcast()

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

  
  mainCondition.wait()

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

ifcount>=threadNumbers{
  
  mainCondition.signal()
  
  }

当所有线程执行完时，通知主线程开始检查引用，执行结果如下：

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

三、其它实现测试结果

1、最简单实现

returnInner.instance
  
  }
  
  
  
  structInner{
  
  staticletinstance:SwiftSingleton=SwiftSingleton()
  
  }
  
  }

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

staticletinstance:SwiftSingleton=SwiftSingleton()

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

测试结果：通过

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

varshared:SwiftSingleton{
  
  dispatch_once(&Inner.token){
  
  Inner.instance=SwiftSingleton()
  
  }
  
  returnInner.instance!
  
  }
  
  structInner{
  
  varinstance:SwiftSingleton?
  
  vartoken:dispatch_once_t=0
  
  }
  
  
  
  }

四、测试说明

1、Mac OS线程总量有限制，你可以创建线程，但是最大线程启动数为2048（我的电脑是这样，不清楚是否跟硬件有关）。

2、如果遇到测试无响应时，可以尝试重启电脑。

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

猜你在找的Swift相关文章