单列模式之饿汉式和懒汉式

单列模式的特点：从系统的启动到终止，这个过程只会产生一个对象

1. 懒汉式
   - 懒汉式，只有在使用的时候才会new对象

package com.tian.day03

object SingletonOps1 {

  def main(args: Array[String]): Unit = {

    for (i <- 1 to 10){
      new Thread(new Runnable {
        override def run(): Unit = {
          println(Singleton1.getInstance())
          Thread.sleep(50)
        }
      }).start()

    }
  }
  class Singleton1 private(){

  }
  object Singleton1{

    var singltelon1:Singleton1 = null
    def getInstance(): Singleton1 ={
      if (singltelon1 == null ){
        Singleton1.synchronized{
          if (singltelon1 == null){
             singltelon1 = new Singleton1
          }
        }
      }
      singltelon1
    }
  }
}

2. 饿汉式
   - 在一开始就会创建对象

package com.tian.day03

object SingletonOps {

  def main(args: Array[String]): Unit = {

    val s1 = Singleton.getInstance()

    val s2 = Singleton.getInstance()
    s1.x = 6
    /*
    * 单列模式：在整个程序的运行过程中，只会创建一次对象
    * 创建出来的对象，在改变了数据的值之后，之后取出来的值就是新的值
    * */
    println(s1.x == s2.x) //true
    println(s1.x)         //6
    println(s2.x)         //6

  }
  class Singleton private(){
    var x = 5
  }
  //饿汉式
  object Singleton{
    private val p = new Singleton
    def getInstance():Singleton={
      p
    }
  }
}