黑马程序员--单例模式

什么叫单例模式

单例模式（Singleton）是一种常用的设计模式。单例模式，也叫单子模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为

单例模式特点

显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

单例大致分为5种

1.懒汉式

2.恶汉式

3.静态内部类

4.枚举

5.双重校验锁

目前只知道懒汉式和恶汉式  所以只重点总结下这两个啦 

这两种模式的步骤大致相同

1.私有本类的构造方法

2.创建本类对象

3.对外提供访问本类对象的功能

代码体现:

//恶汉式:    缺点没有达到Lazy loading的效果
class Single{
	private static Single s = new Single();
	private Single(){
	}
	public static Single getInstance(){
		return s ;
	}
}

//懒汉式    比较常用的写法
class Single2{
	private Single2(){
	}
	private static Single2 instance = null;
	public static Single2 getInstance(){
		if (instance == null){
			instance = new Single2();
		}
		return instance ;
	}
}

//测试类
class SingleTest{
	public static void main(String[] args){
		Single s = Single.getInstance();
		Single s2 = Single.getInstance();
		System.out.println("s="+s);
		System.out.println("s2="+s2);
		System.out.println(s == s2);	//不多说 肯定是true
	}
}

这两种实现方式个人觉得懒汉式比较好点   其特点就是需要创建对象的时候才会有,而恶汉式是类一加载就会创建对象

下面再列举其他方式的代码体现

//双重校验锁,在当前的内存模型中无效
class LockSingleton{

    private volatile static LockSingleton singleton;

    private LockSingleton(){}


    public static LockSingleton getInstance(){

        if(singleton==null){

            synchronized(LockSingleton.class){

                if(singleton==null){

                    singleton=new LockSingleton();

                }
            }

        }
        return singleton;

    }

     

}

//枚举,  优点: 不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象
enum EnumSingleton{
		INSTANCE;
		public  void doSomeThing(){
		}
}

//静态内部类  优点: 加载是不会初始化静态变量INSTANCE,因为没有主动使用,达到Lazyloading(这是啥)

class InternalSingleton{

    private static class SingletonHolder{

        private final static  InternalSingleton INSTANCE=new InternalSingleton();

    }  

    private InternalSingleton(){}

    public static InternalSingleton getInstance(){

        return SingletonHolder.INSTANCE;

    }

}