Java/Swift 单例模式的多种写法

        设计模式的书本上一般是这样写：

         public final class SingleTon {

                  private static SingleTon sInstance;     

                  public static SingleTon getInstance() {

                            if (sInstance == null) {

                                     sInstance = new SingleTon();

                            }

                            return sInstance;

                   }

        }

       仔细看这几行代码， 能发现什么问题吗？  脑洞大开一下。

        1. 在外部类中可以new出SingleTon对象。

        2. 多线程时怎么办？ 可能生成多个SingleTon实例， 我们想到了锁。 

         public final class SingleTon {

                  private static SingleTon sInstance;   

                  private SingleTon() {

                         //将构造函数声明成私有函数， 从而在类外部无法实例化该类

                  }  

                  public synchronized static SingleTon getInstance() {

                            if (sInstance == null) {

                                     sInstance = new SingleTon();

                            }

                            return sInstance;

                   }

        }

        添加synchronized关键字后实际上是SingleTon.class上锁， 但对函数上锁的颗粒度较大， 影响多线程并发的性能， 实际上我们只需要对new对象上锁, 读对象时不上锁。 更好的写法是

         public final class SingleTon {

                  private static SingleTon sInstance;     

                  public synchronized static SingleTon getInstance() {

                            if (sInstance != null) {

                                    return sInstance;

                            }

                            synchronized(SingleTon.class) {

                           if (sInstance == null) {

                                     sInstance = new SingleTon();

                           }

                            }

                            return sInstance;

                   }

        }

        如果不使用锁， 能不能实现单例呢？  答案是可以的， 肯定要借助静态内部类了。

        public final class SingleTon {

               private SingleTon() {

               }

               private static class Inner {

                      static SingleTon sInstance = new SingleTon ();  //私有静态类， 只会执行一次new

                }

                public static SingleTon getInstance() {

                       return Inner.sInstance;

                }

        ｝

         这种写法看起来很高大上， 没用到synchroized关键字实现了锁， 保证一个进程只有一个实例。

            

Swift3.0单例模式的2个写法如下， 虽然没有同步关键字， 但苹果已经说了加上static关键字后多线程时也能保证是一个实例。  

        注意要声明init函数， 而且是private访问类型， 从而只能通过类的静态参数得到实例。

苹果的说明：In Swift, you can simply use a static type property, which is guaranteed to be lazily initialized only once, even when accessed across multiple threads simultaneously

final class SingleTon {    //单例类的属性    var name: String    var age: Int        private init() {        name = ""        age = 0        print("SingleTon init is called")    }        static let sInstance = SingleTon()}final class SingleTon2 {    //单例类的属性    var name: String    var age: Int        private init() {        name = ""        age = 0        print("SingleTon init is called")    }        //使用闭包的GET语法, 类似于lazy参数， 在运行时赋初值    static var sInstance: SingleTon2 {        let instance = SingleTon2()        instance.name = "zhangsan"        instance.age = 20                return instance    }}