单例模式

单例模式

---

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。
   

写单例模式的步骤：

1、必须在该类中,自己先创建出一个对象.

2、私有化自身的构造器,防止外界通过构造器创建新的对象.

3、想外暴露一个公共的静态方法用于获取自身的对象.（提供一个访问它的全局访问点 ）

 
应用实例：

1、一个党只能有一个书记。

2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
 
 
优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
 
 
使用场景：

1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
  
 

---

单例模式的几种实现方式

单件模式属于工厂模式的特例，只是它不需要输入参数并且始终返回同一对象的引用。

1、饿汉式：在程序启动或单例模式类被加载的时候，单件模式实例就已经被创建。

2、懒汉式：当程序第一次访问单例模式实例时才进行创建。

如何选择：

如果单例模式实例在系统中经常会被用到，饿汉式是一个不错的选择。

反之如果单例模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。

1、懒汉式

案例1：线程不安全

class MySingleTon__1 {
    private static  Object lock = new Object();
    
    //创建 MySingleTon__1 的一个引用，赋值为空
    private static MySingleTon__1 singleTon = null;
    
    //让构造函数为 private，这样该类就不会被实例化
    private MySingleTon__1() {
        System.out.println("MySingleTon__1().init");
    }

    //提供一个全局的访问点
    public static MySingleTon__1 getInstance() {

        //1、多个线程时，一部分不为null时，都进来了，创建对象，不安全
        if(singleTon == null) {
            singleTon = new MySingleTon__1();
        }
        return singleTon;
    }
}

public class MySingleTon_1 {
    public static void main(String[] args) {
        //MySingleTon__1 mySigleTon = new MySingleTon__1();
        MySingleTon__1 mySigleTon1 = MySingleTon__1.getInstance();
        MySingleTon__1 mySigleTon2 = MySingleTon__1.getInstance();
        MySingleTon__1 mySigleTon3 = MySingleTon__1.getInstance();
        System.out.println(mySigleTon1);
        System.out.println(mySigleTon2);
        System.out.println(mySigleTon3);
    }
}

案例2：线程安全但是浪费资源(还是放在：public static MySingleTon__1 getInstance() {} 中)

        //2、 对于多个线程是好，但是对于一个线程不方便，外部加锁浪费资源
        synchronized (lock) {
            if(singleTon == null) {
                singleTon = new MySingleTon__1();
            }
        }
        
        //3、多个线程时，可能有部分为null时就进去（singleTon == null），在lock外面等待，陆续又执行生成同一个对象
        if(singleTon == null) {
            
            synchronized (lock) {
                singleTon = new MySingleTon__1();//至少执行2遍
            }
        }

案例3：线程安全(还是放在：public static MySingleTon__1 getInstance() {} 中)

双检锁/双重校验锁（DCL，即 double-checked locking）

        //4.两次判断致使无法再进入生成对象那一块（singleTon = new MySingleTon__1();）
        //double-checked locking 双重检验
        if(singleTon == null) {
            synchronized (lock) {
                if(singleTon == null) {
                    singleTon = new MySingleTon__1();
                }
            }
        }

---

2、饿汉式

这种方式比较常用，但容易产生垃圾对象。

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

class MySingleTon__2{
    private static MySingleTon__2 singleTon__2 = new MySingleTon__2();
    private MySingleTon__2(){
        System.out.println(" MySingleTon__2.init");
    }
    public static MySingleTon__2 getInstance2(){
        return singleTon__2;
    }
}

参考文章：

http://www.cnblogs.com/nolonely/p/5927957.html

http://www.runoob.com/design-pattern/singleton-pattern.html

                                             2018.10.31/周三
                                             by 922