单例模式,Singleton Pattern,创建型。
一个单一的类,该类创建自己的对象,同时保证只有一个对象被创建。
提供访问其唯一的对象的方式,可直接访问,不需要实例化该类的对象。
关键代码:构造函数是私有的。
大部分时候,都把类的构造器定义为public访问权限,允许任何类自由的创建该类的对象。但在某些时候,允许其他类自由的创建该类的对象没有任何意义,还可能导致系统性能下降(因为频繁的创建对象,回收对象带来的系统开销问题)。例如,一个系统只有一个窗口管理器。
总之,在一些特殊场景下,要求不允许自由创建该类的对象,而只允许为该类创建一个对象,避免其他类自由创建该类的实例,应该把该类的构造器,使用private修饰,从而把该类的所有构造器隐藏起来。
根据封装型的原则:一旦把类的构造器隐藏起来,就需要提供一个public方法作为这个类的访问点,用于创建这个类的对象,且这个方法必须是static修饰(因为调用这个方法之前还不存在对象,因此调用这个方法不可能是对象,只能是类);
五种单例模式:
懒汉式
线程不安全:
class Singleton
{
//使用一个变量来缓存曾经创建的实例
private static Singleton instance;
//将构造器使用private修饰,隐藏该构造器
private Singleton(){}
//提供一个静态方法,用于返回Singleton实例
//该方法可以加入自定义的控制,保证只产生一个Singleton对象
public static Singleton getInstance()
{
//如果instance为null,表明还不曾创建Singleton对象
//如果instance不为null,则表明已经创建了Singleton对象,将不会执行该方法
if (instance == null)
{
//创建一个Singleton对象,并将其缓存起来
instance = new Singleton();
}
return instance;
}
}
public class TestSingleton
{
public static void main(String[] args)
{
//创建Singleton对象不能通过构造器,只能通过getInstance方法
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
//将输出true
System.out.println(s1 == s2);
}
}
这种写法lazy loading很明显,但是致命的是在多线程不能正常工作。
线程安全:
class Singleton{
private static Singleton instance;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
这种写法能够在多线程中很好的工作,而且看起来它也具备很好的lazy loading,但是,每次调用getInstance方式时,都要去判断锁,效率很低,99%情况下不需要同步
饿汉式
class Single {
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}
这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用getInstance方法, 但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy loading的效果。
双重锁校验
class Single {
private volatile static Singleton instance;
private Singleton(){}
public static Singleton getInstance (){
if(instance == null){
synchronized(Singleton.class){
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
在JDK1.5之后,双重检查锁定才能够正常达到单例效果
枚举
public enum Singleton{
INSTANCE;
public void whateverMethod(){
System.out.println("something");
}
}
这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒啊,不过,由于1.5中才加入enum特性,用这种方式写不免让人感觉生疏。
静态内部类
class Singleton{
private Singleton(){}
private static class SingletonHolder{
private static final Singleton instance = new Singleton();
}
public static final Singleton getInstance(){
return SingletonHoldler.instance;
}
}
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,但Singleton类被装载了,instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显式装载SingletonHolder类,从而实例化instance。
各种方法各有利弊,斟酌使用。
推荐阅读:
http://www.blogjava.net/kenzhh/archive/2016/03/28/357824.html
https://blog.csdn.net/chenchaofuck1/article/details/51702129
https://blog.csdn.net/lzm18064126848/article/details/50074887