04 单例设计模式

单例模式的意义

单例模式是最常用到的设计模式之一，其定义是一个类的对象只能有一个实例。
有些对象我们只需要一个：线程池、缓存、硬件设备等。如果存在多个实例会有造成冲突、导致结果的不一致性等问题。当然也可以用静态（static）变量方式来实现。或者程序员之间协商个全局变量来实现。
我们再次介绍单例模式：确保一个类最多只有一个实例，并提供一个全局访问点

基本实现思路

单例模式要求类能够有返回对象的一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）。

实现的两个步骤

1：私有构造器
2：静态一实例（再次强调必须是static）
3:给其他对象提供统一实例

实现单例模式的方式（代码）

1.懒汉式单例（延迟加载方式）：该示例虽然用延迟加载方式实现了懒汉式单例，但在多线程环境下会产生多个single对象。

package com.ghl.demo;
public class Singleton1 {
	 // 私有构造
    private Singleton1() { } 
    private static Singleton1 single1 = null;//创建静态变量
    
    public static Singleton1 getgetInstance() {//静态一实例
    	 if(single1== null){//第一次创建的时候会进入if 体内
             single1 = new Singleton1();//创建一个但国当前类对象 
         }
         
         return single1;
    }
}

2：懒汉式(线程安全，同步方法)[不推荐用]
在方法上加synchronized同步锁或是用同步代码块对类加同步锁，此种方式虽然解决了多个实例对象问题，但是该方式运行效率却很低下，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，才可以继续运行。

package com.ghl.demo;
第一种方式不足的改造：加一个线程锁
public class Singleton2 {

	public Singleton2() {//私有构造器
		
	}
	 private static   Singleton2 single2 = null;//创建静态变量
	//静态一实例，加一个线程锁，线程同步块，每一次都在当前线程执行完后在执行下一次线程
	public static synchronized Singleton2 getgetInstance() {
   	 if(single2== null){
            single2 = new Singleton2();
        }
        return single2;
   	
   }
	
}

3.双重检查[推荐用]
使用双重检查进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。

package com.ghl.demo;

public class Singleton3 {
    // 私有构造
    private Singleton3() {}

    private static Singleton3 single = null;

    // 双重检查
    public static Singleton3 getInstance() {
        if (single == null) {
            synchronized (Singleton3.class) {
                if (single == null) {
                    single = new Singleton3();
                }
            }
        }
        return single;
    }
}

4.静态内部类实现
静态内部类保证了单例在多线程并发下的线程安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的

package com.ghl.demo;

public class Singleton4 {
    // 私有构造
    private Singleton4() {}

    // 静态内部类
    private static class InnerObject{
        private static Singleton4 single = new Singleton4();
    }
    
    public static Singleton4 getInstance() {
        return InnerObject.single;
    }
}

5.static静态代码块实现

package com.ghl.demo;
public class Singleton5 {
    
    // 私有构造
    private Singleton5() {}
    
    private static Singleton5 single = null;

    // 静态代码块
    static{
        single = new Singleton5();
    }
    
    public static Singleton5 getInstance() {
        return single;
    }
}

6.饿汉式
1）.优点：没有加锁，执行效率会提高。
2）.缺点：类加载时就初始化，浪费内存。

package com.ghl.demo;
//饿汉式（推荐使用）
public class Singleton6 {  
    private static Singleton6 instance = new Singleton6();  
    private Singleton6 (){}  
    public static Singleton6 getInstance() {  
    return instance;  
    }  
}

单例模式的优点

对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

单例模式的缺点

一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。